Set up Grunt

Fixing up Grunt file to watch for directories

Exclude node modules folder from Jekyll built site

node_modules/autoprefixer-core/lib/hacks/align-content.js

@@ -0,0 +1,57 @@
+(function() {
+  var AlignContent, Declaration, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  AlignContent = (function(superClass) {
+    extend(AlignContent, superClass);
+
+    function AlignContent() {
+      return AlignContent.__super__.constructor.apply(this, arguments);
+    }
+
+    AlignContent.names = ['align-content', 'flex-line-pack'];
+
+    AlignContent.oldValues = {
+      'flex-end': 'end',
+      'flex-start': 'start',
+      'space-between': 'justify',
+      'space-around': 'distribute'
+    };
+
+    AlignContent.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012) {
+        return prefix + 'flex-line-pack';
+      } else {
+        return AlignContent.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    AlignContent.prototype.normalize = function(prop) {
+      return 'align-content';
+    };
+
+    AlignContent.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2012) {
+        decl.value = AlignContent.oldValues[decl.value] || decl.value;
+        return AlignContent.__super__.set.call(this, decl, prefix);
+      } else if (spec === 'final') {
+        return AlignContent.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return AlignContent;
+
+  })(Declaration);
+
+  module.exports = AlignContent;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/align-items.js

@@ -0,0 +1,57 @@
+(function() {
+  var AlignItems, Declaration, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  AlignItems = (function(superClass) {
+    extend(AlignItems, superClass);
+
+    function AlignItems() {
+      return AlignItems.__super__.constructor.apply(this, arguments);
+    }
+
+    AlignItems.names = ['align-items', 'flex-align', 'box-align'];
+
+    AlignItems.oldValues = {
+      'flex-end': 'end',
+      'flex-start': 'start'
+    };
+
+    AlignItems.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return prefix + 'box-align';
+      } else if (spec === 2012) {
+        return prefix + 'flex-align';
+      } else {
+        return AlignItems.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    AlignItems.prototype.normalize = function(prop) {
+      return 'align-items';
+    };
+
+    AlignItems.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2009 || spec === 2012) {
+        decl.value = AlignItems.oldValues[decl.value] || decl.value;
+        return AlignItems.__super__.set.call(this, decl, prefix);
+      } else {
+        return AlignItems.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return AlignItems;
+
+  })(Declaration);
+
+  module.exports = AlignItems;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/align-self.js

@@ -0,0 +1,55 @@
+(function() {
+  var AlignSelf, Declaration, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  AlignSelf = (function(superClass) {
+    extend(AlignSelf, superClass);
+
+    function AlignSelf() {
+      return AlignSelf.__super__.constructor.apply(this, arguments);
+    }
+
+    AlignSelf.names = ['align-self', 'flex-item-align'];
+
+    AlignSelf.oldValues = {
+      'flex-end': 'end',
+      'flex-start': 'start'
+    };
+
+    AlignSelf.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012) {
+        return prefix + 'flex-item-align';
+      } else {
+        return AlignSelf.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    AlignSelf.prototype.normalize = function(prop) {
+      return 'align-self';
+    };
+
+    AlignSelf.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2012) {
+        decl.value = AlignSelf.oldValues[decl.value] || decl.value;
+        return AlignSelf.__super__.set.call(this, decl, prefix);
+      } else if (spec === 'final') {
+        return AlignSelf.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return AlignSelf;
+
+  })(Declaration);
+
+  module.exports = AlignSelf;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/background-size.js

@@ -0,0 +1,32 @@
+(function() {
+  var BackgroundSize, Declaration,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  BackgroundSize = (function(superClass) {
+    extend(BackgroundSize, superClass);
+
+    function BackgroundSize() {
+      return BackgroundSize.__super__.constructor.apply(this, arguments);
+    }
+
+    BackgroundSize.names = ['background-size'];
+
+    BackgroundSize.prototype.set = function(decl, prefix) {
+      var value;
+      value = decl.value.toLowerCase();
+      if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
+        decl.value = decl.value + ' ' + decl.value;
+      }
+      return BackgroundSize.__super__.set.call(this, decl, prefix);
+    };
+
+    return BackgroundSize;
+
+  })(Declaration);
+
+  module.exports = BackgroundSize;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/block-logical.js

@@ -0,0 +1,35 @@
+(function() {
+  var BlockLogical, Declaration,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  BlockLogical = (function(superClass) {
+    extend(BlockLogical, superClass);
+
+    function BlockLogical() {
+      return BlockLogical.__super__.constructor.apply(this, arguments);
+    }
+
+    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'];
+
+    BlockLogical.prototype.prefixed = function(prop, prefix) {
+      return prefix + (prop.indexOf('-start') !== -1 ? prop.replace('-block-start', '-before') : prop.replace('-block-end', '-after'));
+    };
+
+    BlockLogical.prototype.normalize = function(prop) {
+      if (prop.indexOf('-before') !== -1) {
+        return prop.replace('-before', '-block-start');
+      } else {
+        return prop.replace('-after', '-block-end');
+      }
+    };
+
+    return BlockLogical;
+
+  })(Declaration);
+
+  module.exports = BlockLogical;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/border-image.js

@@ -0,0 +1,28 @@
+(function() {
+  var BorderImage, Declaration,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  BorderImage = (function(superClass) {
+    extend(BorderImage, superClass);
+
+    function BorderImage() {
+      return BorderImage.__super__.constructor.apply(this, arguments);
+    }
+
+    BorderImage.names = ['border-image'];
+
+    BorderImage.prototype.set = function(decl, prefix) {
+      decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
+      return BorderImage.__super__.set.call(this, decl, prefix);
+    };
+
+    return BorderImage;
+
+  })(Declaration);
+
+  module.exports = BorderImage;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/border-radius.js

@@ -0,0 +1,56 @@
+(function() {
+  var BorderRadius, Declaration,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  BorderRadius = (function(superClass) {
+    var hor, i, j, len, len1, mozilla, normal, ref, ref1, ver;
+
+    extend(BorderRadius, superClass);
+
+    function BorderRadius() {
+      return BorderRadius.__super__.constructor.apply(this, arguments);
+    }
+
+    BorderRadius.names = ['border-radius'];
+
+    BorderRadius.toMozilla = {};
+
+    BorderRadius.toNormal = {};
+
+    ref = ['top', 'bottom'];
+    for (i = 0, len = ref.length; i < len; i++) {
+      ver = ref[i];
+      ref1 = ['left', 'right'];
+      for (j = 0, len1 = ref1.length; j < len1; j++) {
+        hor = ref1[j];
+        normal = "border-" + ver + "-" + hor + "-radius";
+        mozilla = "border-radius-" + ver + hor;
+        BorderRadius.names.push(normal);
+        BorderRadius.names.push(mozilla);
+        BorderRadius.toMozilla[normal] = mozilla;
+        BorderRadius.toNormal[mozilla] = normal;
+      }
+    }
+
+    BorderRadius.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-moz-') {
+        return prefix + (BorderRadius.toMozilla[prop] || prop);
+      } else {
+        return BorderRadius.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    BorderRadius.prototype.normalize = function(prop) {
+      return BorderRadius.toNormal[prop] || prop;
+    };
+
+    return BorderRadius;
+
+  })(Declaration);
+
+  module.exports = BorderRadius;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/break-inside.js

@@ -0,0 +1,54 @@
+(function() {
+  var BreakInside, Declaration,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  BreakInside = (function(superClass) {
+    extend(BreakInside, superClass);
+
+    function BreakInside() {
+      return BreakInside.__super__.constructor.apply(this, arguments);
+    }
+
+    BreakInside.names = ['break-inside', 'page-break-inside', 'column-break-inside'];
+
+    BreakInside.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-webkit-') {
+        return prefix + 'column-break-inside';
+      } else if (prefix === '-moz-') {
+        return 'page-break-inside';
+      } else {
+        return BreakInside.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    BreakInside.prototype.normalize = function() {
+      return 'break-inside';
+    };
+
+    BreakInside.prototype.set = function(decl, prefix) {
+      if (decl.value === 'avoid-column' || decl.value === 'avoid-page') {
+        decl.value = 'avoid';
+      }
+      return BreakInside.__super__.set.apply(this, arguments);
+    };
+
+    BreakInside.prototype.insert = function(decl, prefix, prefixes) {
+      if (decl.value === 'avoid-region') {
+
+      } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
+
+      } else {
+        return BreakInside.__super__.insert.apply(this, arguments);
+      }
+    };
+
+    return BreakInside;
+
+  })(Declaration);
+
+  module.exports = BreakInside;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/crisp-edges.js

@@ -0,0 +1,31 @@
+(function() {
+  var CrispEdges, Value,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Value = require('../value');
+
+  CrispEdges = (function(superClass) {
+    extend(CrispEdges, superClass);
+
+    function CrispEdges() {
+      return CrispEdges.__super__.constructor.apply(this, arguments);
+    }
+
+    CrispEdges.names = ['crisp-edges'];
+
+    CrispEdges.prototype.replace = function(string, prefix) {
+      if (prefix === '-webkit-') {
+        return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
+      } else {
+        return CrispEdges.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    return CrispEdges;
+
+  })(Value);
+
+  module.exports = CrispEdges;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/display-flex.js

@@ -0,0 +1,68 @@
+(function() {
+  var DisplayFlex, OldDisplayFlex, OldValue, Value, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  OldDisplayFlex = (function(superClass) {
+    extend(OldDisplayFlex, superClass);
+
+    function OldDisplayFlex(unprefixed, prefixed1) {
+      this.unprefixed = unprefixed;
+      this.prefixed = prefixed1;
+    }
+
+    OldDisplayFlex.prototype.check = function(value) {
+      return value === this.name;
+    };
+
+    return OldDisplayFlex;
+
+  })(OldValue);
+
+  DisplayFlex = (function(superClass) {
+    extend(DisplayFlex, superClass);
+
+    DisplayFlex.names = ['display-flex', 'inline-flex'];
+
+    function DisplayFlex(name, prefixes) {
+      DisplayFlex.__super__.constructor.apply(this, arguments);
+      if (name === 'display-flex') {
+        this.name = 'flex';
+      }
+    }
+
+    DisplayFlex.prototype.check = function(decl) {
+      return decl.value === this.name;
+    };
+
+    DisplayFlex.prototype.prefixed = function(prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      return prefix + (spec === 2009 ? this.name === 'flex' ? 'box' : 'inline-box' : spec === 2012 ? this.name === 'flex' ? 'flexbox' : 'inline-flexbox' : spec === 'final' ? this.name : void 0);
+    };
+
+    DisplayFlex.prototype.replace = function(string, prefix) {
+      return this.prefixed(prefix);
+    };
+
+    DisplayFlex.prototype.old = function(prefix) {
+      var prefixed;
+      prefixed = this.prefixed(prefix);
+      if (prefixed) {
+        return new OldValue(this.name, prefixed);
+      }
+    };
+
+    return DisplayFlex;
+
+  })(Value);
+
+  module.exports = DisplayFlex;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/fill-available.js

@@ -0,0 +1,41 @@
+(function() {
+  var FillAvailable, OldValue, Value,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  FillAvailable = (function(superClass) {
+    extend(FillAvailable, superClass);
+
+    function FillAvailable() {
+      return FillAvailable.__super__.constructor.apply(this, arguments);
+    }
+
+    FillAvailable.names = ['fill-available'];
+
+    FillAvailable.prototype.replace = function(string, prefix) {
+      if (prefix === '-moz-') {
+        return string.replace(this.regexp(), '$1-moz-available$3');
+      } else {
+        return FillAvailable.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    FillAvailable.prototype.old = function(prefix) {
+      if (prefix === '-moz-') {
+        return new OldValue(this.name, '-moz-available');
+      } else {
+        return FillAvailable.__super__.old.apply(this, arguments);
+      }
+    };
+
+    return FillAvailable;
+
+  })(Value);
+
+  module.exports = FillAvailable;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/filter-value.js

@@ -0,0 +1,69 @@
+(function() {
+  var FilterValue, OldFilterValue, OldValue, Value, utils,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  utils = require('../utils');
+
+  OldFilterValue = (function(superClass) {
+    extend(OldFilterValue, superClass);
+
+    function OldFilterValue() {
+      return OldFilterValue.__super__.constructor.apply(this, arguments);
+    }
+
+    OldFilterValue.prototype.clean = function(decl) {
+      return decl.value = utils.editList(decl.value, (function(_this) {
+        return function(props) {
+          if (props.every(function(i) {
+            return i.indexOf(_this.unprefixed) !== 0;
+          })) {
+            return props;
+          }
+          return props.filter(function(i) {
+            return i.indexOf(_this.prefixed) === -1;
+          });
+        };
+      })(this));
+    };
+
+    return OldFilterValue;
+
+  })(OldValue);
+
+  FilterValue = (function(superClass) {
+    extend(FilterValue, superClass);
+
+    function FilterValue() {
+      return FilterValue.__super__.constructor.apply(this, arguments);
+    }
+
+    FilterValue.names = ['filter'];
+
+    FilterValue.prototype.replace = function(value, prefix) {
+      if (prefix === '-webkit-') {
+        if (value.indexOf('-webkit-filter') === -1) {
+          return FilterValue.__super__.replace.apply(this, arguments) + ', ' + value;
+        } else {
+          return value;
+        }
+      } else {
+        return FilterValue.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    FilterValue.prototype.old = function(prefix) {
+      return new OldFilterValue(this.name, prefix + this.name);
+    };
+
+    return FilterValue;
+
+  })(Value);
+
+  module.exports = FilterValue;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/filter.js

@@ -0,0 +1,29 @@
+(function() {
+  var Declaration, Filter,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  Filter = (function(superClass) {
+    extend(Filter, superClass);
+
+    function Filter() {
+      return Filter.__super__.constructor.apply(this, arguments);
+    }
+
+    Filter.names = ['filter'];
+
+    Filter.prototype.check = function(decl) {
+      var v;
+      v = decl.value;
+      return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
+    };
+
+    return Filter;
+
+  })(Declaration);
+
+  module.exports = Filter;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-basis.js

@@ -0,0 +1,47 @@
+(function() {
+  var Declaration, FlexBasis, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  FlexBasis = (function(superClass) {
+    extend(FlexBasis, superClass);
+
+    function FlexBasis() {
+      return FlexBasis.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexBasis.names = ['flex-basis', 'flex-preferred-size'];
+
+    FlexBasis.prototype.normalize = function() {
+      return 'flex-basis';
+    };
+
+    FlexBasis.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012) {
+        return prefix + 'flex-preferred-size';
+      } else {
+        return FlexBasis.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    FlexBasis.prototype.set = function(decl, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012 || spec === 'final') {
+        return FlexBasis.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return FlexBasis;
+
+  })(Declaration);
+
+  module.exports = FlexBasis;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-direction.js

@@ -0,0 +1,71 @@
+(function() {
+  var Declaration, FlexDirection, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  FlexDirection = (function(superClass) {
+    extend(FlexDirection, superClass);
+
+    function FlexDirection() {
+      return FlexDirection.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexDirection.names = ['flex-direction', 'box-direction', 'box-orient'];
+
+    FlexDirection.prototype.normalize = function(prop) {
+      return 'flex-direction';
+    };
+
+    FlexDirection.prototype.insert = function(decl, prefix, prefixes) {
+      var already, cloned, dir, orient, ref, spec, value;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        already = decl.parent.some(function(i) {
+          return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
+        });
+        if (already) {
+          return;
+        }
+        value = decl.value;
+        orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
+        dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal';
+        cloned = this.clone(decl);
+        cloned.prop = prefix + 'box-orient';
+        cloned.value = orient;
+        if (this.needCascade(decl)) {
+          cloned.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.before = this.calcBefore(prefixes, decl, prefix);
+        }
+        return decl.parent.insertBefore(decl, cloned);
+      } else {
+        return FlexDirection.__super__.insert.apply(this, arguments);
+      }
+    };
+
+    FlexDirection.prototype.old = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return [prefix + 'box-orient', prefix + 'box-direction'];
+      } else {
+        return FlexDirection.__super__.old.apply(this, arguments);
+      }
+    };
+
+    return FlexDirection;
+
+  })(Declaration);
+
+  module.exports = FlexDirection;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-flow.js

@@ -0,0 +1,35 @@
+(function() {
+  var Declaration, FlexFlow, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  FlexFlow = (function(superClass) {
+    extend(FlexFlow, superClass);
+
+    function FlexFlow() {
+      return FlexFlow.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexFlow.names = ['flex-flow'];
+
+    FlexFlow.prototype.set = function(decl, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012) {
+        return FlexFlow.__super__.set.apply(this, arguments);
+      } else if (spec === 'final') {
+        return FlexFlow.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return FlexFlow;
+
+  })(Declaration);
+
+  module.exports = FlexFlow;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-grow.js

@@ -0,0 +1,41 @@
+(function() {
+  var Declaration, Flex, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  Flex = (function(superClass) {
+    extend(Flex, superClass);
+
+    function Flex() {
+      return Flex.__super__.constructor.apply(this, arguments);
+    }
+
+    Flex.names = ['flex-grow', 'flex-positive'];
+
+    Flex.prototype.normalize = function() {
+      return 'flex';
+    };
+
+    Flex.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return prefix + 'box-flex';
+      } else if (spec === 2012) {
+        return prefix + 'flex-positive';
+      } else {
+        return Flex.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    return Flex;
+
+  })(Declaration);
+
+  module.exports = Flex;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-shrink.js

@@ -0,0 +1,47 @@
+(function() {
+  var Declaration, FlexShrink, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  FlexShrink = (function(superClass) {
+    extend(FlexShrink, superClass);
+
+    function FlexShrink() {
+      return FlexShrink.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexShrink.names = ['flex-shrink', 'flex-negative'];
+
+    FlexShrink.prototype.normalize = function() {
+      return 'flex-shrink';
+    };
+
+    FlexShrink.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012) {
+        return prefix + 'flex-negative';
+      } else {
+        return FlexShrink.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    FlexShrink.prototype.set = function(decl, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2012 || spec === 'final') {
+        return FlexShrink.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return FlexShrink;
+
+  })(Declaration);
+
+  module.exports = FlexShrink;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-spec.js

@@ -0,0 +1,11 @@
+(function() {
+  module.exports = function(prefix) {
+    var spec;
+    spec = prefix === '-webkit- 2009' || prefix === '-moz-' ? 2009 : prefix === '-ms-' ? 2012 : prefix === '-webkit-' ? 'final' : void 0;
+    if (prefix === '-webkit- 2009') {
+      prefix = '-webkit-';
+    }
+    return [spec, prefix];
+  };
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-values.js

@@ -0,0 +1,37 @@
+(function() {
+  var FlexValues, OldValue, Value,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  FlexValues = (function(superClass) {
+    extend(FlexValues, superClass);
+
+    function FlexValues() {
+      return FlexValues.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexValues.names = ['flex', 'flex-grow', 'flex-shrink', 'flex-basis'];
+
+    FlexValues.prototype.prefixed = function(prefix) {
+      return this.all.prefixed(this.name, prefix);
+    };
+
+    FlexValues.prototype.replace = function(string, prefix) {
+      return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3');
+    };
+
+    FlexValues.prototype.old = function(prefix) {
+      return new OldValue(this.name, this.prefixed(prefix));
+    };
+
+    return FlexValues;
+
+  })(Value);
+
+  module.exports = FlexValues;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex-wrap.js

@@ -0,0 +1,33 @@
+(function() {
+  var Declaration, FlexWrap, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  FlexWrap = (function(superClass) {
+    extend(FlexWrap, superClass);
+
+    function FlexWrap() {
+      return FlexWrap.__super__.constructor.apply(this, arguments);
+    }
+
+    FlexWrap.names = ['flex-wrap'];
+
+    FlexWrap.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec !== 2009) {
+        return FlexWrap.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return FlexWrap;
+
+  })(Declaration);
+
+  module.exports = FlexWrap;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/flex.js

@@ -0,0 +1,58 @@
+(function() {
+  var Declaration, Flex, flexSpec, list,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  list = require('postcss/lib/list');
+
+  Flex = (function(superClass) {
+    extend(Flex, superClass);
+
+    function Flex() {
+      return Flex.__super__.constructor.apply(this, arguments);
+    }
+
+    Flex.names = ['flex', 'box-flex'];
+
+    Flex.oldValues = {
+      'auto': '1',
+      'none': '0'
+    };
+
+    Flex.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return prefix + 'box-flex';
+      } else {
+        return Flex.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    Flex.prototype.normalize = function() {
+      return 'flex';
+    };
+
+    Flex.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2009) {
+        decl.value = list.space(decl.value)[0];
+        decl.value = Flex.oldValues[decl.value] || decl.value;
+        return Flex.__super__.set.call(this, decl, prefix);
+      } else {
+        return Flex.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return Flex;
+
+  })(Declaration);
+
+  module.exports = Flex;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/fullscreen.js

@@ -0,0 +1,33 @@
+(function() {
+  var Fullscreen, Selector,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Selector = require('../selector');
+
+  Fullscreen = (function(superClass) {
+    extend(Fullscreen, superClass);
+
+    function Fullscreen() {
+      return Fullscreen.__super__.constructor.apply(this, arguments);
+    }
+
+    Fullscreen.names = [':fullscreen'];
+
+    Fullscreen.prototype.prefixed = function(prefix) {
+      if ('-webkit-' === prefix) {
+        return ':-webkit-full-screen';
+      } else if ('-moz-' === prefix) {
+        return ':-moz-full-screen';
+      } else {
+        return ":" + prefix + "fullscreen";
+      }
+    };
+
+    return Fullscreen;
+
+  })(Selector);
+
+  module.exports = Fullscreen;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/gradient.js

@@ -0,0 +1,234 @@
+(function() {
+  var Gradient, OldValue, Value, isDirection, list, utils,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  utils = require('../utils');
+
+  list = require('postcss/lib/list');
+
+  isDirection = /top|left|right|bottom/gi;
+
+  Gradient = (function(superClass) {
+    extend(Gradient, superClass);
+
+    function Gradient() {
+      return Gradient.__super__.constructor.apply(this, arguments);
+    }
+
+    Gradient.names = ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'];
+
+    Gradient.prototype.replace = function(string, prefix) {
+      return list.space(string).map((function(_this) {
+        return function(value) {
+          var after, args, close, params;
+          if (value.slice(0, +_this.name.length + 1 || 9e9) !== _this.name + '(') {
+            return value;
+          }
+          close = value.lastIndexOf(')');
+          after = value.slice(close + 1);
+          args = value.slice(_this.name.length + 1, +(close - 1) + 1 || 9e9);
+          params = list.comma(args);
+          params = _this.newDirection(params);
+          if (prefix === '-webkit- old') {
+            return _this.oldWebkit(value, args, params, after);
+          } else {
+            _this.convertDirection(params);
+            return prefix + _this.name + '(' + params.join(', ') + ')' + after;
+          }
+        };
+      })(this)).join(' ');
+    };
+
+    Gradient.prototype.directions = {
+      top: 'bottom',
+      left: 'right',
+      bottom: 'top',
+      right: 'left'
+    };
+
+    Gradient.prototype.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'
+    };
+
+    Gradient.prototype.newDirection = function(params) {
+      var first, value;
+      first = params[0];
+      if (first.indexOf('to ') === -1 && isDirection.test(first)) {
+        first = first.split(' ');
+        first = (function() {
+          var j, len, results;
+          results = [];
+          for (j = 0, len = first.length; j < len; j++) {
+            value = first[j];
+            results.push(this.directions[value.toLowerCase()] || value);
+          }
+          return results;
+        }).call(this);
+        params[0] = 'to ' + first.join(' ');
+      }
+      return params;
+    };
+
+    Gradient.prototype.oldWebkit = function(value, args, params, after) {
+      if (args.indexOf('px') !== -1) {
+        return value;
+      }
+      if (this.name !== 'linear-gradient') {
+        return value;
+      }
+      if (params[0] && params[0].indexOf('deg') !== -1) {
+        return value;
+      }
+      if (args.indexOf('-corner') !== -1) {
+        return value;
+      }
+      if (args.indexOf('-side') !== -1) {
+        return value;
+      }
+      params = this.oldDirection(params);
+      params = this.colorStops(params);
+      return '-webkit-gradient(linear, ' + params.join(', ') + ')' + after;
+    };
+
+    Gradient.prototype.convertDirection = function(params) {
+      if (params.length > 0) {
+        if (params[0].slice(0, 3) === 'to ') {
+          return params[0] = this.fixDirection(params[0]);
+        } else if (params[0].indexOf('deg') !== -1) {
+          return params[0] = this.fixAngle(params[0]);
+        } else if (params[0].indexOf(' at ') !== -1) {
+          return this.fixRadial(params);
+        }
+      }
+    };
+
+    Gradient.prototype.fixDirection = function(param) {
+      var value;
+      param = param.split(' ');
+      param.splice(0, 1);
+      param = (function() {
+        var j, len, results;
+        results = [];
+        for (j = 0, len = param.length; j < len; j++) {
+          value = param[j];
+          results.push(this.directions[value.toLowerCase()] || value);
+        }
+        return results;
+      }).call(this);
+      return param.join(' ');
+    };
+
+    Gradient.prototype.roundFloat = function(float, digits) {
+      return parseFloat(float.toFixed(digits));
+    };
+
+    Gradient.prototype.fixAngle = function(param) {
+      param = parseFloat(param);
+      param = Math.abs(450 - param) % 360;
+      param = this.roundFloat(param, 3);
+      return param + "deg";
+    };
+
+    Gradient.prototype.oldDirection = function(params) {
+      var direction;
+      if (params.length === 0) {
+        params;
+      }
+      if (params[0].indexOf('to ') !== -1) {
+        direction = params[0].replace(/^to\s+/, '');
+        direction = this.oldDirections[direction];
+        params[0] = direction;
+        return params;
+      } else {
+        direction = this.oldDirections.bottom;
+        return [direction].concat(params);
+      }
+    };
+
+    Gradient.prototype.colorStops = function(params) {
+      return params.map(function(param, i) {
+        var color, match, position, ref;
+        if (i === 0) {
+          return param;
+        }
+        ref = list.space(param), color = ref[0], position = ref[1];
+        if (position == null) {
+          match = param.match(/^(.*\))(\d.*)$/);
+          if (match) {
+            color = match[1];
+            position = match[2];
+          }
+        }
+        if (position && position.indexOf(')') !== -1) {
+          color += ' ' + position;
+          position = void 0;
+        }
+        if (i === 1 && (position === void 0 || position === '0%')) {
+          return "from(" + color + ")";
+        } else if (i === params.length - 1 && (position === void 0 || position === '100%')) {
+          return "to(" + color + ")";
+        } else if (position) {
+          return "color-stop(" + position + ", " + color + ")";
+        } else {
+          return "color-stop(" + color + ")";
+        }
+      });
+    };
+
+    Gradient.prototype.fixRadial = function(params) {
+      var first;
+      first = params[0].split(/\s+at\s+/);
+      return params.splice(0, 1, first[1], first[0]);
+    };
+
+    Gradient.prototype.old = function(prefix) {
+      var regexp, string, type;
+      if (prefix === '-webkit-') {
+        type = this.name === 'linear-gradient' ? 'linear' : 'radial';
+        string = '-gradient';
+        regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
+        return new OldValue(this.name, prefix + this.name, string, regexp);
+      } else {
+        return Gradient.__super__.old.apply(this, arguments);
+      }
+    };
+
+    Gradient.prototype.add = function(decl, prefix) {
+      var p;
+      p = decl.prop;
+      if (p.indexOf('mask') !== -1) {
+        if (prefix === '-webkit-' || prefix === '-webkit- old') {
+          return Gradient.__super__.add.apply(this, arguments);
+        }
+      } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
+        if (prefix === '-webkit-' || prefix === '-webkit- old') {
+          return Gradient.__super__.add.apply(this, arguments);
+        }
+      } else {
+        return Gradient.__super__.add.apply(this, arguments);
+      }
+    };
+
+    return Gradient;
+
+  })(Value);
+
+  module.exports = Gradient;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/image-rendering.js

@@ -0,0 +1,49 @@
+(function() {
+  var Declaration, ImageRendering,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  ImageRendering = (function(superClass) {
+    extend(ImageRendering, superClass);
+
+    function ImageRendering() {
+      return ImageRendering.__super__.constructor.apply(this, arguments);
+    }
+
+    ImageRendering.names = ['image-rendering', 'interpolation-mode'];
+
+    ImageRendering.prototype.check = function(decl) {
+      return decl.value === 'crisp-edges';
+    };
+
+    ImageRendering.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-ms-') {
+        return '-ms-interpolation-mode';
+      } else {
+        return ImageRendering.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    ImageRendering.prototype.set = function(decl, prefix) {
+      if (prefix === '-ms-') {
+        decl.prop = '-ms-interpolation-mode';
+        decl.value = 'nearest-neighbor';
+        return decl;
+      } else {
+        return ImageRendering.__super__.set.apply(this, arguments);
+      }
+    };
+
+    ImageRendering.prototype.normalize = function(prop) {
+      return 'image-rendering';
+    };
+
+    return ImageRendering;
+
+  })(Declaration);
+
+  module.exports = ImageRendering;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/inline-logical.js

@@ -0,0 +1,31 @@
+(function() {
+  var Declaration, InlineLogical,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  InlineLogical = (function(superClass) {
+    extend(InlineLogical, superClass);
+
+    function InlineLogical() {
+      return InlineLogical.__super__.constructor.apply(this, arguments);
+    }
+
+    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'];
+
+    InlineLogical.prototype.prefixed = function(prop, prefix) {
+      return prefix + prop.replace('-inline', '');
+    };
+
+    InlineLogical.prototype.normalize = function(prop) {
+      return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
+    };
+
+    return InlineLogical;
+
+  })(Declaration);
+
+  module.exports = InlineLogical;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/justify-content.js

@@ -0,0 +1,62 @@
+(function() {
+  var Declaration, JustifyContent, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  JustifyContent = (function(superClass) {
+    extend(JustifyContent, superClass);
+
+    function JustifyContent() {
+      return JustifyContent.__super__.constructor.apply(this, arguments);
+    }
+
+    JustifyContent.names = ['justify-content', 'flex-pack', 'box-pack'];
+
+    JustifyContent.oldValues = {
+      'flex-end': 'end',
+      'flex-start': 'start',
+      'space-between': 'justify',
+      'space-around': 'distribute'
+    };
+
+    JustifyContent.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return prefix + 'box-pack';
+      } else if (spec === 2012) {
+        return prefix + 'flex-pack';
+      } else {
+        return JustifyContent.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    JustifyContent.prototype.normalize = function(prop) {
+      return 'justify-content';
+    };
+
+    JustifyContent.prototype.set = function(decl, prefix) {
+      var spec, value;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2009 || spec === 2012) {
+        value = JustifyContent.oldValues[decl.value] || decl.value;
+        decl.value = value;
+        if (spec !== 2009 || value !== 'distribute') {
+          return JustifyContent.__super__.set.call(this, decl, prefix);
+        }
+      } else if (spec === 'final') {
+        return JustifyContent.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return JustifyContent;
+
+  })(Declaration);
+
+  module.exports = JustifyContent;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/order.js

@@ -0,0 +1,52 @@
+(function() {
+  var Declaration, Order, flexSpec,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  flexSpec = require('./flex-spec');
+
+  Declaration = require('../declaration');
+
+  Order = (function(superClass) {
+    extend(Order, superClass);
+
+    function Order() {
+      return Order.__super__.constructor.apply(this, arguments);
+    }
+
+    Order.names = ['order', 'flex-order', 'box-ordinal-group'];
+
+    Order.prototype.prefixed = function(prop, prefix) {
+      var ref, spec;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec === 2009) {
+        return prefix + 'box-ordinal-group';
+      } else if (spec === 2012) {
+        return prefix + 'flex-order';
+      } else {
+        return Order.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    Order.prototype.normalize = function(prop) {
+      return 'order';
+    };
+
+    Order.prototype.set = function(decl, prefix) {
+      var spec;
+      spec = flexSpec(prefix)[0];
+      if (spec === 2009) {
+        decl.value = (parseInt(decl.value) + 1).toString();
+        return Order.__super__.set.call(this, decl, prefix);
+      } else {
+        return Order.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return Order;
+
+  })(Declaration);
+
+  module.exports = Order;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/placeholder.js

@@ -0,0 +1,39 @@
+(function() {
+  var Placeholder, Selector,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Selector = require('../selector');
+
+  Placeholder = (function(superClass) {
+    extend(Placeholder, superClass);
+
+    function Placeholder() {
+      return Placeholder.__super__.constructor.apply(this, arguments);
+    }
+
+    Placeholder.names = [':placeholder-shown', '::placeholder'];
+
+    Placeholder.prototype.possible = function() {
+      return Placeholder.__super__.possible.apply(this, arguments).concat('-moz- old');
+    };
+
+    Placeholder.prototype.prefixed = function(prefix) {
+      if ('-webkit-' === prefix) {
+        return '::-webkit-input-placeholder';
+      } else if ('-ms-' === prefix) {
+        return ':-ms-input-placeholder';
+      } else if ('-moz- old' === prefix) {
+        return ':-moz-placeholder';
+      } else {
+        return "::" + prefix + "placeholder";
+      }
+    };
+
+    return Placeholder;
+
+  })(Selector);
+
+  module.exports = Placeholder;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/transform-decl.js

@@ -0,0 +1,66 @@
+(function() {
+  var Declaration, TransformDecl,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Declaration = require('../declaration');
+
+  TransformDecl = (function(superClass) {
+    extend(TransformDecl, superClass);
+
+    function TransformDecl() {
+      return TransformDecl.__super__.constructor.apply(this, arguments);
+    }
+
+    TransformDecl.names = ['transform', 'transform-origin'];
+
+    TransformDecl.functions3d = ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'perspective'];
+
+    TransformDecl.prototype.keykrameParents = function(decl) {
+      var parent;
+      parent = decl.parent;
+      while (parent) {
+        if (parent.type === 'atrule' && parent.name === 'keyframes') {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    };
+
+    TransformDecl.prototype.contain3d = function(decl) {
+      var func, i, len, ref;
+      if (decl.prop === 'transform-origin') {
+        return false;
+      }
+      ref = TransformDecl.functions3d;
+      for (i = 0, len = ref.length; i < len; i++) {
+        func = ref[i];
+        if (decl.value.indexOf(func + "(") !== -1) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    TransformDecl.prototype.insert = function(decl, prefix, prefixes) {
+      if (prefix === '-ms-') {
+        if (!this.contain3d(decl) && !this.keykrameParents(decl)) {
+          return TransformDecl.__super__.insert.apply(this, arguments);
+        }
+      } else if (prefix === '-o-') {
+        if (!this.contain3d(decl)) {
+          return TransformDecl.__super__.insert.apply(this, arguments);
+        }
+      } else {
+        return TransformDecl.__super__.insert.apply(this, arguments);
+      }
+    };
+
+    return TransformDecl;
+
+  })(Declaration);
+
+  module.exports = TransformDecl;
+
+}).call(this);

node_modules/autoprefixer-core/lib/hacks/transform-value.js

@@ -0,0 +1,31 @@
+(function() {
+  var TransformValue, Value,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Value = require('../value');
+
+  TransformValue = (function(superClass) {
+    extend(TransformValue, superClass);
+
+    function TransformValue() {
+      return TransformValue.__super__.constructor.apply(this, arguments);
+    }
+
+    TransformValue.names = ['transform'];
+
+    TransformValue.prototype.replace = function(value, prefix) {
+      if (prefix === '-ms-') {
+        return value;
+      } else {
+        return TransformValue.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    return TransformValue;
+
+  })(Value);
+
+  module.exports = TransformValue;
+
+}).call(this);