Initial commit

node_modules/autoprefixer/lib/at-rule.js

@@ -0,0 +1,51 @@
+(function() {
+  var AtRule, Prefixer,
+    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;
+
+  Prefixer = require('./prefixer');
+
+  AtRule = (function(superClass) {
+    extend(AtRule, superClass);
+
+    function AtRule() {
+      return AtRule.__super__.constructor.apply(this, arguments);
+    }
+
+    AtRule.prototype.add = function(rule, prefix) {
+      var already, cloned, prefixed;
+      prefixed = prefix + rule.name;
+      already = rule.parent.some(function(i) {
+        return i.name === prefixed && i.params === rule.params;
+      });
+      if (already) {
+        return;
+      }
+      cloned = this.clone(rule, {
+        name: prefixed
+      });
+      return rule.parent.insertBefore(rule, cloned);
+    };
+
+    AtRule.prototype.process = function(node) {
+      var j, len, parent, prefix, ref, results;
+      parent = this.parentPrefix(node);
+      ref = this.prefixes;
+      results = [];
+      for (j = 0, len = ref.length; j < len; j++) {
+        prefix = ref[j];
+        if (parent && parent !== prefix) {
+          continue;
+        }
+        results.push(this.add(node, prefix));
+      }
+      return results;
+    };
+
+    return AtRule;
+
+  })(Prefixer);
+
+  module.exports = AtRule;
+
+}).call(this);

node_modules/autoprefixer/lib/autoprefixer.js

@@ -0,0 +1,92 @@
+(function() {
+  var Browsers, Prefixes, browserslist, cache, isPlainObject, postcss, timeCapsule,
+    slice = [].slice;
+
+  browserslist = require('browserslist');
+
+  postcss = require('postcss');
+
+  Browsers = require('./browsers');
+
+  Prefixes = require('./prefixes');
+
+  isPlainObject = function(obj) {
+    return Object.prototype.toString.apply(obj) === '[object Object]';
+  };
+
+  cache = {};
+
+  timeCapsule = function(result, prefixes) {
+    if (prefixes.browsers.selected.length === 0) {
+      return;
+    }
+    if (prefixes.add.selectors.length > 0) {
+      return;
+    }
+    if (Object.keys(prefixes.add).length > 2) {
+      return;
+    }
+    return result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
+  };
+
+  module.exports = postcss.plugin('autoprefixer', function() {
+    var loadPrefixes, options, plugin, reqs;
+    reqs = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+    if (reqs.length === 1 && isPlainObject(reqs[0])) {
+      options = reqs[0];
+      reqs = void 0;
+    } else if (reqs.length === 0 || (reqs.length === 1 && (reqs[0] == null))) {
+      reqs = void 0;
+    } else if (reqs.length <= 2 && (reqs[0] instanceof Array || (reqs[0] == null))) {
+      options = reqs[1];
+      reqs = reqs[0];
+    } else if (typeof reqs[reqs.length - 1] === 'object') {
+      options = reqs.pop();
+    }
+    options || (options = {});
+    if (options.browser) {
+      throw new Error('Change `browser` option to `browsers` in Autoprefixer');
+    }
+    if (options.browsers != null) {
+      reqs = options.browsers;
+    }
+    loadPrefixes = function(opts) {
+      var browsers, key, stats;
+      stats = options.stats;
+      browsers = new Browsers(module.exports.data.browsers, reqs, opts, stats);
+      key = browsers.selected.join(', ') + JSON.stringify(options);
+      return cache[key] || (cache[key] = new Prefixes(module.exports.data.prefixes, browsers, options));
+    };
+    plugin = function(css, result) {
+      var prefixes, ref;
+      prefixes = loadPrefixes({
+        from: (ref = css.source) != null ? ref.input.file : void 0,
+        env: options.env
+      });
+      timeCapsule(result, prefixes);
+      if (options.remove !== false) {
+        prefixes.processor.remove(css);
+      }
+      if (options.add !== false) {
+        return prefixes.processor.add(css, result);
+      }
+    };
+    plugin.options = options;
+    plugin.info = function(opts) {
+      return require('./info')(loadPrefixes(opts));
+    };
+    return plugin;
+  });
+
+  module.exports.data = {
+    browsers: require('caniuse-db/data.json').agents,
+    prefixes: require('../data/prefixes')
+  };
+
+  module.exports.defaults = browserslist.defaults;
+
+  module.exports.info = function() {
+    return module.exports().info();
+  };
+
+}).call(this);

node_modules/autoprefixer/lib/brackets.js

@@ -0,0 +1,46 @@
+(function() {
+  var brackets, last;
+
+  last = function(array) {
+    return array[array.length - 1];
+  };
+
+  brackets = {
+    parse: function(str) {
+      var current, j, len, stack, sym;
+      current = [''];
+      stack = [current];
+      for (j = 0, len = str.length; j < len; j++) {
+        sym = str[j];
+        if (sym === '(') {
+          current = [''];
+          last(stack).push(current);
+          stack.push(current);
+        } else if (sym === ')') {
+          stack.pop();
+          current = last(stack);
+          current.push('');
+        } else {
+          current[current.length - 1] += sym;
+        }
+      }
+      return stack[0];
+    },
+    stringify: function(ast) {
+      var i, j, len, result;
+      result = '';
+      for (j = 0, len = ast.length; j < len; j++) {
+        i = ast[j];
+        if (typeof i === 'object') {
+          result += '(' + brackets.stringify(i) + ')';
+        } else {
+          result += i;
+        }
+      }
+      return result;
+    }
+  };
+
+  module.exports = brackets;
+
+}).call(this);

node_modules/autoprefixer/lib/browsers.js

@@ -0,0 +1,86 @@
+(function() {
+  var Browsers, browserslist, utils;
+
+  browserslist = require('browserslist');
+
+  utils = require('./utils');
+
+  Browsers = (function() {
+    Browsers.prefixes = function() {
+      var data, i, name;
+      if (this.prefixesCache) {
+        return this.prefixesCache;
+      }
+      data = require('caniuse-db/data.json').agents;
+      return this.prefixesCache = utils.uniq((function() {
+        var results;
+        results = [];
+        for (name in data) {
+          i = data[name];
+          results.push("-" + i.prefix + "-");
+        }
+        return results;
+      })()).sort(function(a, b) {
+        return b.length - a.length;
+      });
+    };
+
+    Browsers.withPrefix = function(value) {
+      if (!this.prefixesRegexp) {
+        this.prefixesRegexp = RegExp("" + (this.prefixes().join('|')));
+      }
+      return this.prefixesRegexp.test(value);
+    };
+
+    function Browsers(data1, requirements, options, stats) {
+      this.data = data1;
+      this.options = options;
+      this.stats = stats;
+      this.selected = this.parse(requirements);
+    }
+
+    Browsers.prototype.parse = function(requirements) {
+      var ref, ref1;
+      return browserslist(requirements, {
+        stats: this.stats,
+        path: (ref = this.options) != null ? ref.from : void 0,
+        env: (ref1 = this.options) != null ? ref1.env : void 0
+      });
+    };
+
+    Browsers.prototype.browsers = function(criteria) {
+      var browser, data, ref, selected, versions;
+      selected = [];
+      ref = this.data;
+      for (browser in ref) {
+        data = ref[browser];
+        versions = criteria(data).map(function(version) {
+          return browser + " " + version;
+        });
+        selected = selected.concat(versions);
+      }
+      return selected;
+    };
+
+    Browsers.prototype.prefix = function(browser) {
+      var data, name, prefix, ref, version;
+      ref = browser.split(' '), name = ref[0], version = ref[1];
+      data = this.data[name];
+      if (data.prefix_exceptions) {
+        prefix = data.prefix_exceptions[version];
+      }
+      prefix || (prefix = data.prefix);
+      return '-' + prefix + '-';
+    };
+
+    Browsers.prototype.isSelected = function(browser) {
+      return this.selected.indexOf(browser) !== -1;
+    };
+
+    return Browsers;
+
+  })();
+
+  module.exports = Browsers;
+
+}).call(this);

node_modules/autoprefixer/lib/declaration.js

@@ -0,0 +1,162 @@
+(function() {
+  var Browsers, Declaration, Prefixer, 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;
+
+  Prefixer = require('./prefixer');
+
+  Browsers = require('./browsers');
+
+  utils = require('./utils');
+
+  Declaration = (function(superClass) {
+    extend(Declaration, superClass);
+
+    function Declaration() {
+      return Declaration.__super__.constructor.apply(this, arguments);
+    }
+
+    Declaration.prototype.check = function(decl) {
+      return true;
+    };
+
+    Declaration.prototype.prefixed = function(prop, prefix) {
+      return prefix + prop;
+    };
+
+    Declaration.prototype.normalize = function(prop) {
+      return prop;
+    };
+
+    Declaration.prototype.otherPrefixes = function(value, prefix) {
+      var j, len, other, ref;
+      ref = Browsers.prefixes();
+      for (j = 0, len = ref.length; j < len; j++) {
+        other = ref[j];
+        if (other === prefix) {
+          continue;
+        }
+        if (value.indexOf(other) !== -1) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    Declaration.prototype.set = function(decl, prefix) {
+      decl.prop = this.prefixed(decl.prop, prefix);
+      return decl;
+    };
+
+    Declaration.prototype.needCascade = function(decl) {
+      return decl._autoprefixerCascade || (decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1);
+    };
+
+    Declaration.prototype.maxPrefixed = function(prefixes, decl) {
+      var j, len, max, prefix;
+      if (decl._autoprefixerMax) {
+        return decl._autoprefixerMax;
+      }
+      max = 0;
+      for (j = 0, len = prefixes.length; j < len; j++) {
+        prefix = prefixes[j];
+        prefix = utils.removeNote(prefix);
+        if (prefix.length > max) {
+          max = prefix.length;
+        }
+      }
+      return decl._autoprefixerMax = max;
+    };
+
+    Declaration.prototype.calcBefore = function(prefixes, decl, prefix) {
+      var before, diff, i, j, max, ref;
+      if (prefix == null) {
+        prefix = '';
+      }
+      before = decl.raw('before');
+      max = this.maxPrefixed(prefixes, decl);
+      diff = max - utils.removeNote(prefix).length;
+      for (i = j = 0, ref = diff; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
+        before += ' ';
+      }
+      return before;
+    };
+
+    Declaration.prototype.restoreBefore = function(decl) {
+      var lines, min;
+      lines = decl.raw('before').split("\n");
+      min = lines[lines.length - 1];
+      this.all.group(decl).up(function(prefixed) {
+        var array, last;
+        array = prefixed.raw('before').split("\n");
+        last = array[array.length - 1];
+        if (last.length < min.length) {
+          return min = last;
+        }
+      });
+      lines[lines.length - 1] = min;
+      return decl.raws.before = lines.join("\n");
+    };
+
+    Declaration.prototype.insert = function(decl, prefix, prefixes) {
+      var already, cloned;
+      cloned = this.set(this.clone(decl), prefix);
+      if (!cloned) {
+        return;
+      }
+      already = decl.parent.some(function(i) {
+        return i.prop === cloned.prop && i.value === cloned.value;
+      });
+      if (already) {
+        return;
+      }
+      if (this.needCascade(decl)) {
+        cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+      }
+      return decl.parent.insertBefore(decl, cloned);
+    };
+
+    Declaration.prototype.isAlready = function(decl, prefixed) {
+      var already;
+      already = this.all.group(decl).up(function(i) {
+        return i.prop === prefixed;
+      });
+      already || (already = this.all.group(decl).down(function(i) {
+        return i.prop === prefixed;
+      }));
+      return already;
+    };
+
+    Declaration.prototype.add = function(decl, prefix, prefixes) {
+      var prefixed;
+      prefixed = this.prefixed(decl.prop, prefix);
+      if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
+        return;
+      }
+      return this.insert(decl, prefix, prefixes);
+    };
+
+    Declaration.prototype.process = function(decl) {
+      var prefixes;
+      if (this.needCascade(decl)) {
+        prefixes = Declaration.__super__.process.apply(this, arguments);
+        if (prefixes != null ? prefixes.length : void 0) {
+          this.restoreBefore(decl);
+          return decl.raws.before = this.calcBefore(prefixes, decl);
+        }
+      } else {
+        return Declaration.__super__.process.apply(this, arguments);
+      }
+    };
+
+    Declaration.prototype.old = function(prop, prefix) {
+      return [this.prefixed(prop, prefix)];
+    };
+
+    return Declaration;
+
+  })(Prefixer);
+
+  module.exports = Declaration;
+
+}).call(this);

node_modules/autoprefixer/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/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/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/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/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/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/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/lib/hacks/break-props.js

@@ -0,0 +1,64 @@
+(function() {
+  var BreakProps, 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');
+
+  BreakProps = (function(superClass) {
+    extend(BreakProps, superClass);
+
+    function BreakProps() {
+      return BreakProps.__super__.constructor.apply(this, arguments);
+    }
+
+    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'];
+
+    BreakProps.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-webkit-') {
+        return '-webkit-column-' + prop;
+      } else if (prefix === '-moz-') {
+        return 'page-' + prop;
+      } else {
+        return BreakProps.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    BreakProps.prototype.normalize = function(prop) {
+      if (prop.indexOf('inside') !== -1) {
+        return 'break-inside';
+      } else if (prop.indexOf('before') !== -1) {
+        return 'break-before';
+      } else if (prop.indexOf('after') !== -1) {
+        return 'break-after';
+      }
+    };
+
+    BreakProps.prototype.set = function(decl, prefix) {
+      var v;
+      v = decl.value;
+      if (decl.prop === 'break-inside' && v === 'avoid-column' || v === 'avoid-page') {
+        decl.value = 'avoid';
+      }
+      return BreakProps.__super__.set.apply(this, arguments);
+    };
+
+    BreakProps.prototype.insert = function(decl, prefix, prefixes) {
+      if (decl.prop !== 'break-inside') {
+        return BreakProps.__super__.insert.apply(this, arguments);
+      } else if (decl.value === 'avoid-region') {
+
+      } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
+
+      } else {
+        return BreakProps.__super__.insert.apply(this, arguments);
+      }
+    };
+
+    return BreakProps;
+
+  })(Declaration);
+
+  module.exports = BreakProps;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/cross-fade.js

@@ -0,0 +1,53 @@
+(function() {
+  var CrossFade, OldValue, Value, 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');
+
+  CrossFade = (function(superClass) {
+    extend(CrossFade, superClass);
+
+    function CrossFade() {
+      return CrossFade.__super__.constructor.apply(this, arguments);
+    }
+
+    CrossFade.names = ['cross-fade'];
+
+    CrossFade.prototype.replace = function(string, prefix) {
+      return list.space(string).map((function(_this) {
+        return function(value) {
+          var after, args, close, match;
+          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);
+          if (prefix === '-webkit-') {
+            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;
+        };
+      })(this)).join(' ');
+    };
+
+    return CrossFade;
+
+  })(Value);
+
+  module.exports = CrossFade;
+
+}).call(this);

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

@@ -0,0 +1,52 @@
+(function() {
+  var DisplayFlex, 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');
+
+  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.prop === 'display' && 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/lib/hacks/display-grid.js

@@ -0,0 +1,34 @@
+(function() {
+  var DisplayGrid, 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');
+
+  DisplayGrid = (function(superClass) {
+    extend(DisplayGrid, superClass);
+
+    DisplayGrid.names = ['display-grid', 'inline-grid'];
+
+    function DisplayGrid(name, prefixes) {
+      DisplayGrid.__super__.constructor.apply(this, arguments);
+      if (name === 'display-grid') {
+        this.name = 'grid';
+      }
+    }
+
+    DisplayGrid.prototype.check = function(decl) {
+      return decl.prop === 'display' && decl.value === this.name;
+    };
+
+    return DisplayGrid;
+
+  })(Value);
+
+  module.exports = DisplayGrid;
+
+}).call(this);

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

@@ -0,0 +1,72 @@
+(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);
+
+    FilterValue.names = ['filter', 'filter-function'];
+
+    function FilterValue(name, prefixes) {
+      FilterValue.__super__.constructor.apply(this, arguments);
+      if (name === 'filter-function') {
+        this.name = 'filter';
+      }
+    }
+
+    FilterValue.prototype.replace = function(value, prefix) {
+      if (prefix === '-webkit-' && value.indexOf('filter(') === -1) {
+        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/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/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/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) {
+        return FlexDirection.__super__.insert.apply(this, arguments);
+      } else {
+        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.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);
+      }
+    };
+
+    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/lib/hacks/flex-flow.js

@@ -0,0 +1,63 @@
+(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', 'box-direction', 'box-orient'];
+
+    FlexFlow.prototype.insert = function(decl, prefix, prefixes) {
+      var already, cloned, dir, orient, ref, spec, value, values;
+      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
+      if (spec !== 2009) {
+        return FlexFlow.__super__.insert.apply(this, arguments);
+      } else {
+        values = decl.value.split(/\s+/).filter(function(i) {
+          return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse';
+        });
+        if (values.length === 0) {
+          return;
+        }
+        already = decl.parent.some(function(i) {
+          return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
+        });
+        if (already) {
+          return;
+        }
+        value = values[0];
+        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.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);
+
+  module.exports = FlexFlow;
+
+}).call(this);

node_modules/autoprefixer/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/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/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/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/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/lib/hacks/flex.js

@@ -0,0 +1,64 @@
+(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 components, 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 if (spec === 2012) {
+        components = list.space(decl.value);
+        if (components.length === 3 && components[2] === '0') {
+          decl.value = components.slice(0, 2).concat('0px').join(' ');
+        }
+        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/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/lib/hacks/gradient.js

@@ -0,0 +1,368 @@
+(function() {
+  var Gradient, OldValue, Value, isDirection, list, parser, range, 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,
+    slice = [].slice;
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  utils = require('../utils');
+
+  parser = require('postcss-value-parser');
+
+  range = require('normalize-range');
+
+  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) {
+      var ast, changes, j, len, node, ref;
+      ast = parser(string);
+      ref = ast.nodes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        node = ref[j];
+        if (node.type === 'function' && node.value === this.name) {
+          node.nodes = this.newDirection(node.nodes);
+          node.nodes = this.normalize(node.nodes);
+          if (prefix === '-webkit- old') {
+            changes = this.oldWebkit(node);
+            if (!changes) {
+              return;
+            }
+          } else {
+            node.nodes = this.convertDirection(node.nodes);
+            node.value = prefix + node.value;
+          }
+        }
+      }
+      return ast.toString();
+    };
+
+    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.replaceFirst = function() {
+      var params, prefix, words;
+      params = arguments[0], words = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+      prefix = words.map(function(i) {
+        if (i === ' ') {
+          return {
+            type: 'space',
+            value: i
+          };
+        } else {
+          return {
+            type: 'word',
+            value: i
+          };
+        }
+      });
+      return prefix.concat(params.slice(1));
+    };
+
+    Gradient.prototype.normalizeUnit = function(str, full) {
+      var deg, num;
+      num = parseFloat(str);
+      deg = (num / full) * 360;
+      return deg + "deg";
+    };
+
+    Gradient.prototype.normalize = function(nodes) {
+      var num;
+      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) {
+        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;
+    };
+
+    Gradient.prototype.newDirection = function(params) {
+      var i, j, ref;
+      if (params[0].value === 'to') {
+        return params;
+      }
+      if (!isDirection.test(params[0].value)) {
+        return params;
+      }
+      params.unshift({
+        type: 'word',
+        value: 'to'
+      }, {
+        type: 'space',
+        value: ' '
+      });
+      for (i = j = 2, ref = params.length; 2 <= ref ? j < ref : j > ref; i = 2 <= ref ? ++j : --j) {
+        if (params[i].type === 'div') {
+          break;
+        }
+        if (params[i].type === 'word') {
+          params[i].value = this.revertDirection(params[i].value);
+        }
+      }
+      return params;
+    };
+
+    Gradient.prototype.convertDirection = function(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 (params[2].value === 'at') {
+          this.fixRadial(params);
+        }
+      }
+      return params;
+    };
+
+    Gradient.prototype.fixDirection = function(params) {
+      var i, j, ref, results;
+      params.splice(0, 2);
+      results = [];
+      for (i = j = 0, ref = params.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
+        if (params[i].type === 'div') {
+          break;
+        }
+        if (params[i].type === 'word') {
+          results.push(params[i].value = this.revertDirection(params[i].value));
+        } else {
+          results.push(void 0);
+        }
+      }
+      return results;
+    };
+
+    Gradient.prototype.fixAngle = function(params) {
+      var first;
+      first = params[0].value;
+      first = parseFloat(first);
+      first = Math.abs(450 - first) % 360;
+      first = this.roundFloat(first, 3);
+      return params[0].value = first + "deg";
+    };
+
+    Gradient.prototype.fixRadial = function(params) {
+      var first, i, j, ref, second;
+      first = params[0];
+      second = [];
+      for (i = j = 4, ref = params.length; 4 <= ref ? j < ref : j > ref; i = 4 <= ref ? ++j : --j) {
+        if (params[i].type === 'div') {
+          break;
+        } else {
+          second.push(params[i]);
+        }
+      }
+      return params.splice.apply(params, [0, i].concat(slice.call(second), [params[i + 2]], [first]));
+    };
+
+    Gradient.prototype.revertDirection = function(word) {
+      return this.directions[word.toLowerCase()] || word;
+    };
+
+    Gradient.prototype.roundFloat = function(float, digits) {
+      return parseFloat(float.toFixed(digits));
+    };
+
+    Gradient.prototype.oldWebkit = function(node) {
+      var i, j, k, len, len1, nodes, param, params, string;
+      nodes = node.nodes;
+      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) {
+        return false;
+      }
+      if (string.indexOf('-corner') !== -1) {
+        return false;
+      }
+      if (string.indexOf('-side') !== -1) {
+        return false;
+      }
+      params = [[]];
+      for (j = 0, len = nodes.length; j < len; j++) {
+        i = nodes[j];
+        params[params.length - 1].push(i);
+        if (i.type === 'div' && i.value === ',') {
+          params.push([]);
+        }
+      }
+      this.oldDirection(params);
+      this.colorStops(params);
+      node.nodes = [];
+      for (k = 0, len1 = params.length; k < len1; k++) {
+        param = params[k];
+        node.nodes = node.nodes.concat(param);
+      }
+      node.nodes.unshift({
+        type: 'word',
+        value: 'linear'
+      }, this.cloneDiv(node.nodes));
+      node.value = '-webkit-gradient';
+      return true;
+    };
+
+    Gradient.prototype.oldDirection = function(params) {
+      var div, j, len, node, old, ref, words;
+      div = this.cloneDiv(params[0]);
+      if (params[0][0].value !== 'to') {
+        return params.unshift([
+          {
+            type: 'word',
+            value: this.oldDirections.bottom
+          }, div
+        ]);
+      } else {
+        words = [];
+        ref = params[0].slice(2);
+        for (j = 0, len = ref.length; j < len; j++) {
+          node = ref[j];
+          if (node.type === 'word') {
+            words.push(node.value.toLowerCase());
+          }
+        }
+        words = words.join(' ');
+        old = this.oldDirections[words] || words;
+        return params[0] = [
+          {
+            type: 'word',
+            value: old
+          }, div
+        ];
+      }
+    };
+
+    Gradient.prototype.cloneDiv = function(params) {
+      var i, j, len;
+      for (j = 0, len = params.length; j < len; j++) {
+        i = params[j];
+        if (i.type === 'div' && i.value === ',') {
+          return i;
+        }
+      }
+      return {
+        type: 'div',
+        value: ',',
+        after: ' '
+      };
+    };
+
+    Gradient.prototype.colorStops = function(params) {
+      var color, div, i, j, len, param, pos, results, stop;
+      results = [];
+      for (i = j = 0, len = params.length; j < len; i = ++j) {
+        param = params[i];
+        if (i === 0) {
+          continue;
+        }
+        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;
+        }
+        stop = i === 1 && (!pos || pos === '0%') ? "from(" + color + ")" : i === params.length - 1 && (!pos || pos === '100%') ? "to(" + color + ")" : pos ? "color-stop(" + pos + ", " + color + ")" : "color-stop(" + color + ")";
+        div = param[param.length - 1];
+        params[i] = [
+          {
+            type: 'word',
+            value: stop
+          }
+        ];
+        if (div.type === 'div' && div.value === ',') {
+          results.push(params[i].push(div));
+        } else {
+          results.push(void 0);
+        }
+      }
+      return results;
+    };
+
+    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/lib/hacks/grid-end.js

@@ -0,0 +1,46 @@
+(function() {
+  var Declaration, GridEnd,
+    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');
+
+  GridEnd = (function(superClass) {
+    extend(GridEnd, superClass);
+
+    function GridEnd() {
+      return GridEnd.__super__.constructor.apply(this, arguments);
+    }
+
+    GridEnd.names = ['grid-row-end', 'grid-column-end', 'grid-row-span', 'grid-column-span'];
+
+    GridEnd.prototype.check = function(decl) {
+      return decl.value.indexOf('span') !== -1;
+    };
+
+    GridEnd.prototype.normalize = function(prop) {
+      return prop.replace(/(-span|-end)/, '');
+    };
+
+    GridEnd.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-ms-') {
+        return prefix + prop.replace('-end', '-span');
+      } else {
+        return GridEnd.__super__.prefixed.call(this, prop, prefix);
+      }
+    };
+
+    GridEnd.prototype.set = function(decl, prefix) {
+      if (prefix === '-ms-') {
+        decl.value = decl.value.replace(/span\s/i, '');
+      }
+      return GridEnd.__super__.set.call(this, decl, prefix);
+    };
+
+    return GridEnd;
+
+  })(Declaration);
+
+  module.exports = GridEnd;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/grid-row-align.js

@@ -0,0 +1,35 @@
+(function() {
+  var Declaration, GridRowAlign,
+    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');
+
+  GridRowAlign = (function(superClass) {
+    extend(GridRowAlign, superClass);
+
+    function GridRowAlign() {
+      return GridRowAlign.__super__.constructor.apply(this, arguments);
+    }
+
+    GridRowAlign.names = ['grid-row-align'];
+
+    GridRowAlign.prototype.check = function(decl) {
+      return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
+    };
+
+    GridRowAlign.prototype.prefixed = function(prop, prefix) {
+      return prefix + 'grid-row-align';
+    };
+
+    GridRowAlign.prototype.normalize = function(prop) {
+      return 'align-self';
+    };
+
+    return GridRowAlign;
+
+  })(Declaration);
+
+  module.exports = GridRowAlign;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/grid-start.js

@@ -0,0 +1,71 @@
+(function() {
+  var Declaration, GridStart,
+    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');
+
+  GridStart = (function(superClass) {
+    extend(GridStart, superClass);
+
+    function GridStart() {
+      return GridStart.__super__.constructor.apply(this, arguments);
+    }
+
+    GridStart.names = ['grid-row-start', 'grid-column-start', 'grid-row', 'grid-column'];
+
+    GridStart.prototype.check = function(decl) {
+      return decl.value.indexOf('/') === -1 || decl.value.indexOf('span') !== -1;
+    };
+
+    GridStart.prototype.normalize = function(prop) {
+      return prop.replace('-start', '');
+    };
+
+    GridStart.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-ms-') {
+        return prefix + prop.replace('-start', '');
+      } else {
+        return GridStart.__super__.prefixed.call(this, prop, prefix);
+      }
+    };
+
+    GridStart.prototype.insert = function(decl, prefix, prefixes) {
+      var parts;
+      parts = this.splitValue(decl, prefix);
+      if (parts.length === 2) {
+        decl.cloneBefore({
+          prop: '-ms-' + decl.prop + '-span',
+          value: parts[1]
+        });
+      }
+      return GridStart.__super__.insert.call(this, decl, prefix, prefixes);
+    };
+
+    GridStart.prototype.set = function(decl, prefix) {
+      var parts;
+      parts = this.splitValue(decl, prefix);
+      if (parts.length === 2) {
+        decl.value = parts[0];
+      }
+      return GridStart.__super__.set.call(this, decl, prefix);
+    };
+
+    GridStart.prototype.splitValue = function(decl, prefix) {
+      var parts;
+      if (prefix === '-ms-' && decl.prop.indexOf('-start') === -1) {
+        parts = decl.value.split(/\s*\/\s*span\s+/);
+        if (parts.length === 2) {
+          return parts;
+        }
+      }
+      return false;
+    };
+
+    return GridStart;
+
+  })(Declaration);
+
+  module.exports = GridStart;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/grid-template.js

@@ -0,0 +1,77 @@
+(function() {
+  var Declaration, GridTemplate, parser,
+    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;
+
+  parser = require('postcss-value-parser');
+
+  Declaration = require('../declaration');
+
+  GridTemplate = (function(superClass) {
+    extend(GridTemplate, superClass);
+
+    function GridTemplate() {
+      return GridTemplate.__super__.constructor.apply(this, arguments);
+    }
+
+    GridTemplate.names = ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns'];
+
+    GridTemplate.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-ms-') {
+        return prefix + prop.replace('template-', '');
+      } else {
+        return GridTemplate.__super__.prefixed.call(this, prop, prefix);
+      }
+    };
+
+    GridTemplate.prototype.normalize = function(prop) {
+      return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
+    };
+
+    GridTemplate.prototype.walkRepeat = function(node) {
+      var count, first, fixed, i, j, len, ref;
+      fixed = [];
+      ref = node.nodes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        i = ref[j];
+        if (i.nodes) {
+          this.walkRepeat(i);
+        }
+        fixed.push(i);
+        if (i.type === 'function' && i.value === 'repeat') {
+          first = i.nodes.shift();
+          if (first) {
+            count = first.value;
+            i.nodes.shift();
+            i.value = '';
+            fixed.push({
+              type: 'word',
+              value: "[" + count + "]"
+            });
+          }
+        }
+      }
+      return node.nodes = fixed;
+    };
+
+    GridTemplate.prototype.changeRepeat = function(value) {
+      var ast;
+      ast = parser(value);
+      this.walkRepeat(ast);
+      return ast.toString();
+    };
+
+    GridTemplate.prototype.set = function(decl, prefix) {
+      if (prefix === '-ms-' && decl.value.indexOf('repeat(') !== -1) {
+        decl.value = this.changeRepeat(decl.value);
+      }
+      return GridTemplate.__super__.set.call(this, decl, prefix);
+    };
+
+    return GridTemplate;
+
+  })(Declaration);
+
+  module.exports = GridTemplate;
+
+}).call(this);

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

@@ -0,0 +1,53 @@
+(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 === 'pixelated';
+    };
+
+    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';
+    };
+
+    ImageRendering.prototype.process = function(node, result) {
+      return ImageRendering.__super__.process.apply(this, arguments);
+    };
+
+    return ImageRendering;
+
+  })(Declaration);
+
+  module.exports = ImageRendering;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/image-set.js

@@ -0,0 +1,33 @@
+(function() {
+  var ImageSet, Value, 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;
+
+  list = require('postcss/lib/list');
+
+  Value = require('../value');
+
+  ImageSet = (function(superClass) {
+    extend(ImageSet, superClass);
+
+    function ImageSet() {
+      return ImageSet.__super__.constructor.apply(this, arguments);
+    }
+
+    ImageSet.names = ['image-set'];
+
+    ImageSet.prototype.replace = function(string, prefix) {
+      if (prefix === '-webkit-') {
+        return ImageSet.__super__.replace.apply(this, arguments).replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
+      } else {
+        return ImageSet.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    return ImageSet;
+
+  })(Value);
+
+  module.exports = ImageSet;
+
+}).call(this);

node_modules/autoprefixer/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/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/lib/hacks/justify-items.js

@@ -0,0 +1,31 @@
+(function() {
+  var Declaration, JustifyItems,
+    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');
+
+  JustifyItems = (function(superClass) {
+    extend(JustifyItems, superClass);
+
+    function JustifyItems() {
+      return JustifyItems.__super__.constructor.apply(this, arguments);
+    }
+
+    JustifyItems.names = ['justify-items', 'grid-column-align'];
+
+    JustifyItems.prototype.prefixed = function(prop, prefix) {
+      return prefix + (prefix === '-ms-' ? 'grid-column-align' : prop);
+    };
+
+    JustifyItems.prototype.normalize = function(prop) {
+      return 'justify-items';
+    };
+
+    return JustifyItems;
+
+  })(Declaration);
+
+  module.exports = JustifyItems;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/mask-border.js

@@ -0,0 +1,35 @@
+(function() {
+  var Declaration, MaskBorder,
+    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');
+
+  MaskBorder = (function(superClass) {
+    extend(MaskBorder, superClass);
+
+    function MaskBorder() {
+      return MaskBorder.__super__.constructor.apply(this, arguments);
+    }
+
+    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'];
+
+    MaskBorder.prototype.normalize = function() {
+      return this.name.replace('box-image', 'border');
+    };
+
+    MaskBorder.prototype.prefixed = function(prop, prefix) {
+      if (prefix === '-webkit-') {
+        return MaskBorder.__super__.prefixed.apply(this, arguments).replace('border', 'box-image');
+      } else {
+        return MaskBorder.__super__.prefixed.apply(this, arguments);
+      }
+    };
+
+    return MaskBorder;
+
+  })(Declaration);
+
+  module.exports = MaskBorder;
+
+}).call(this);

node_modules/autoprefixer/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/lib/hacks/pixelated.js

@@ -0,0 +1,45 @@
+(function() {
+  var OldValue, Pixelated, 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');
+
+  Pixelated = (function(superClass) {
+    extend(Pixelated, superClass);
+
+    function Pixelated() {
+      return Pixelated.__super__.constructor.apply(this, arguments);
+    }
+
+    Pixelated.names = ['pixelated'];
+
+    Pixelated.prototype.replace = function(string, prefix) {
+      if (prefix === '-webkit-') {
+        return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
+      } else if (prefix === '-moz-') {
+        return string.replace(this.regexp(), '$1-moz-crisp-edges');
+      } else {
+        return Pixelated.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    Pixelated.prototype.old = function(prefix) {
+      if (prefix === '-webkit-') {
+        return new OldValue(this.name, '-webkit-optimize-contrast');
+      } else if (prefix === '-moz-') {
+        return new OldValue(this.name, '-moz-crisp-edges');
+      } else {
+        return Pixelated.__super__.old.apply(this, arguments);
+      }
+    };
+
+    return Pixelated;
+
+  })(Value);
+
+  module.exports = Pixelated;
+
+}).call(this);

node_modules/autoprefixer/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/lib/hacks/stretch.js

@@ -0,0 +1,45 @@
+(function() {
+  var OldValue, Stretch, 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');
+
+  Stretch = (function(superClass) {
+    extend(Stretch, superClass);
+
+    function Stretch() {
+      return Stretch.__super__.constructor.apply(this, arguments);
+    }
+
+    Stretch.names = ['stretch', 'fill', 'fill-available'];
+
+    Stretch.prototype.replace = function(string, prefix) {
+      if (prefix === '-moz-') {
+        return string.replace(this.regexp(), '$1-moz-available$3');
+      } else if (prefix === '-webkit-') {
+        return string.replace(this.regexp(), '$1-webkit-fill-available$3');
+      } else {
+        return Stretch.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    Stretch.prototype.old = function(prefix) {
+      if (prefix === '-moz-') {
+        return new OldValue(this.name, '-moz-available');
+      } else if (prefix === '-webkit-') {
+        return new OldValue(this.name, '-webkit-fill-available');
+      } else {
+        return Stretch.__super__.old.apply(this, arguments);
+      }
+    };
+
+    return Stretch;
+
+  })(Value);
+
+  module.exports = Stretch;
+
+}).call(this);

node_modules/autoprefixer/lib/hacks/text-emphasis-position.js

@@ -0,0 +1,32 @@
+(function() {
+  var Declaration, TextEmphasisPosition,
+    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');
+
+  TextEmphasisPosition = (function(superClass) {
+    extend(TextEmphasisPosition, superClass);
+
+    function TextEmphasisPosition() {
+      return TextEmphasisPosition.__super__.constructor.apply(this, arguments);
+    }
+
+    TextEmphasisPosition.names = ['text-emphasis-position'];
+
+    TextEmphasisPosition.prototype.set = function(decl, prefix) {
+      if (prefix === '-webkit-') {
+        decl.value = decl.value.replace(/\s*(right|left)\s*/i, '');
+        return TextEmphasisPosition.__super__.set.call(this, decl, prefix);
+      } else {
+        return TextEmphasisPosition.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return TextEmphasisPosition;
+
+  })(Declaration);
+
+  module.exports = TextEmphasisPosition;
+
+}).call(this);

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

@@ -0,0 +1,74 @@
+(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', 'perspective'];
+
+    TransformDecl.prototype.keyframeParents = 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.set = function(decl, prefix) {
+      decl = TransformDecl.__super__.set.apply(this, arguments);
+      if (prefix === '-ms-') {
+        decl.value = decl.value.replace(/rotateZ/gi, 'rotate');
+      }
+      return decl;
+    };
+
+    TransformDecl.prototype.insert = function(decl, prefix, prefixes) {
+      if (prefix === '-ms-') {
+        if (!this.contain3d(decl) && !this.keyframeParents(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/lib/hacks/writing-mode.js

@@ -0,0 +1,38 @@
+(function() {
+  var Declaration, WritingMode,
+    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');
+
+  WritingMode = (function(superClass) {
+    extend(WritingMode, superClass);
+
+    function WritingMode() {
+      return WritingMode.__super__.constructor.apply(this, arguments);
+    }
+
+    WritingMode.names = ['writing-mode'];
+
+    WritingMode.msValues = {
+      'horizontal-tb': 'lr-tb',
+      'vertical-rl': 'tb-rl',
+      'vertical-lr': 'tb-lr'
+    };
+
+    WritingMode.prototype.set = function(decl, prefix) {
+      if (prefix === '-ms-') {
+        decl.value = WritingMode.msValues[decl.value] || decl.value;
+        return WritingMode.__super__.set.call(this, decl, prefix);
+      } else {
+        return WritingMode.__super__.set.apply(this, arguments);
+      }
+    };
+
+    return WritingMode;
+
+  })(Declaration);
+
+  module.exports = WritingMode;
+
+}).call(this);

node_modules/autoprefixer/lib/info.js

@@ -0,0 +1,113 @@
+(function() {
+  var browserslist, capitalize, names, prefix;
+
+  browserslist = require('browserslist');
+
+  capitalize = function(str) {
+    return str.slice(0, 1).toUpperCase() + str.slice(1);
+  };
+
+  names = {
+    ie: 'IE',
+    ie_mob: 'IE Mobile',
+    ios_saf: 'iOS',
+    op_mini: 'Opera Mini',
+    op_mob: 'Opera Mobile',
+    and_chr: 'Chrome for Android',
+    and_ff: 'Firefox for Android',
+    and_uc: 'UC for Android'
+  };
+
+  prefix = function(name, prefixes) {
+    var out;
+    out = '  ' + name + ': ';
+    out += prefixes.map(function(i) {
+      return i.replace(/^-(.*)-$/g, '$1');
+    }).join(', ');
+    out += "\n";
+    return out;
+  };
+
+  module.exports = function(prefixes) {
+    var atrules, browser, coverage, data, j, k, l, len, len1, len2, list, name, out, props, ref, ref1, ref2, ref3, ref4, ref5, round, selector, selectors, string, value, values, version, versions;
+    if (prefixes.browsers.selected.length === 0) {
+      return "No browsers selected";
+    }
+    versions = [];
+    ref = prefixes.browsers.selected;
+    for (j = 0, len = ref.length; j < len; j++) {
+      browser = ref[j];
+      ref1 = browser.split(' '), name = ref1[0], version = ref1[1];
+      name = names[name] || capitalize(name);
+      if (versions[name]) {
+        versions[name].push(version);
+      } else {
+        versions[name] = [version];
+      }
+    }
+    out = "Browsers:\n";
+    for (browser in versions) {
+      list = versions[browser];
+      list = list.sort(function(a, b) {
+        return parseFloat(b) - parseFloat(a);
+      });
+      out += '  ' + browser + ': ' + list.join(', ') + "\n";
+    }
+    coverage = browserslist.coverage(prefixes.browsers.selected);
+    round = Math.round(coverage * 100) / 100.0;
+    out += "\nThese browsers account for " + round + "% of all users globally\n";
+    atrules = '';
+    ref2 = prefixes.add;
+    for (name in ref2) {
+      data = ref2[name];
+      if (name[0] === '@' && data.prefixes) {
+        atrules += prefix(name, data.prefixes);
+      }
+    }
+    if (atrules !== '') {
+      out += "\nAt-Rules:\n" + atrules;
+    }
+    selectors = '';
+    ref3 = prefixes.add.selectors;
+    for (k = 0, len1 = ref3.length; k < len1; k++) {
+      selector = ref3[k];
+      if (selector.prefixes) {
+        selectors += prefix(selector.name, selector.prefixes);
+      }
+    }
+    if (selectors !== '') {
+      out += "\nSelectors:\n" + selectors;
+    }
+    values = '';
+    props = '';
+    ref4 = prefixes.add;
+    for (name in ref4) {
+      data = ref4[name];
+      if (name[0] !== '@' && data.prefixes) {
+        props += prefix(name, data.prefixes);
+      }
+      if (!data.values) {
+        continue;
+      }
+      ref5 = data.values;
+      for (l = 0, len2 = ref5.length; l < len2; l++) {
+        value = ref5[l];
+        string = prefix(value.name, value.prefixes);
+        if (values.indexOf(string) === -1) {
+          values += string;
+        }
+      }
+    }
+    if (props !== '') {
+      out += "\nProperties:\n" + props;
+    }
+    if (values !== '') {
+      out += "\nValues:\n" + values;
+    }
+    if (atrules === '' && selectors === '' && props === '' && values === '') {
+      out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
+    }
+    return out;
+  };
+
+}).call(this);

node_modules/autoprefixer/lib/old-selector.js

@@ -0,0 +1,68 @@
+(function() {
+  var OldSelector;
+
+  OldSelector = (function() {
+    function OldSelector(selector, prefix1) {
+      var i, len, prefix, ref;
+      this.prefix = prefix1;
+      this.prefixed = selector.prefixed(this.prefix);
+      this.regexp = selector.regexp(this.prefix);
+      this.prefixeds = [];
+      ref = selector.possible();
+      for (i = 0, len = ref.length; i < len; i++) {
+        prefix = ref[i];
+        this.prefixeds.push([selector.prefixed(prefix), selector.regexp(prefix)]);
+      }
+      this.unprefixed = selector.name;
+      this.nameRegexp = selector.regexp();
+    }
+
+    OldSelector.prototype.isHack = function(rule) {
+      var before, i, index, len, ref, ref1, regexp, rules, some, string;
+      index = rule.parent.index(rule) + 1;
+      rules = rule.parent.nodes;
+      while (index < rules.length) {
+        before = rules[index].selector;
+        if (!before) {
+          return true;
+        }
+        if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
+          return false;
+        }
+        some = false;
+        ref = this.prefixeds;
+        for (i = 0, len = ref.length; i < len; i++) {
+          ref1 = ref[i], string = ref1[0], regexp = ref1[1];
+          if (before.indexOf(string) !== -1 && before.match(regexp)) {
+            some = true;
+            break;
+          }
+        }
+        if (!some) {
+          return true;
+        }
+        index += 1;
+      }
+      return true;
+    };
+
+    OldSelector.prototype.check = function(rule) {
+      if (rule.selector.indexOf(this.prefixed) === -1) {
+        return false;
+      }
+      if (!rule.selector.match(this.regexp)) {
+        return false;
+      }
+      if (this.isHack(rule)) {
+        return false;
+      }
+      return true;
+    };
+
+    return OldSelector;
+
+  })();
+
+  module.exports = OldSelector;
+
+}).call(this);

node_modules/autoprefixer/lib/old-value.js

@@ -0,0 +1,30 @@
+(function() {
+  var OldValue, utils;
+
+  utils = require('./utils');
+
+  OldValue = (function() {
+    function OldValue(unprefixed, prefixed, string, regexp) {
+      this.unprefixed = unprefixed;
+      this.prefixed = prefixed;
+      this.string = string;
+      this.regexp = regexp;
+      this.regexp || (this.regexp = utils.regexp(this.prefixed));
+      this.string || (this.string = this.prefixed);
+    }
+
+    OldValue.prototype.check = function(value) {
+      if (value.indexOf(this.string) !== -1) {
+        return !!value.match(this.regexp);
+      } else {
+        return false;
+      }
+    };
+
+    return OldValue;
+
+  })();
+
+  module.exports = OldValue;
+
+}).call(this);

node_modules/autoprefixer/lib/prefixer.js

@@ -0,0 +1,121 @@
+(function() {
+  var Browsers, Prefixer, clone, utils, vendor,
+    hasProp = {}.hasOwnProperty;
+
+  Browsers = require('./browsers');
+
+  utils = require('./utils');
+
+  vendor = require('postcss/lib/vendor');
+
+  clone = function(obj, parent) {
+    var cloned, i, value;
+    cloned = new obj.constructor();
+    for (i in obj) {
+      if (!hasProp.call(obj, i)) continue;
+      value = obj[i];
+      if (i === 'parent' && typeof value === 'object') {
+        if (parent) {
+          cloned[i] = parent;
+        }
+      } else if (i === 'source') {
+        cloned[i] = value;
+      } else if (i === null) {
+        cloned[i] = value;
+      } else if (value instanceof Array) {
+        cloned[i] = value.map(function(i) {
+          return clone(i, cloned);
+        });
+      } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
+        if (typeof value === 'object' && value !== null) {
+          value = clone(value, cloned);
+        }
+        cloned[i] = value;
+      }
+    }
+    return cloned;
+  };
+
+  Prefixer = (function() {
+    Prefixer.hack = function(klass) {
+      var j, len, name, ref, results;
+      this.hacks || (this.hacks = {});
+      ref = klass.names;
+      results = [];
+      for (j = 0, len = ref.length; j < len; j++) {
+        name = ref[j];
+        results.push(this.hacks[name] = klass);
+      }
+      return results;
+    };
+
+    Prefixer.load = function(name, prefixes, all) {
+      var klass, ref;
+      klass = (ref = this.hacks) != null ? ref[name] : void 0;
+      if (klass) {
+        return new klass(name, prefixes, all);
+      } else {
+        return new this(name, prefixes, all);
+      }
+    };
+
+    Prefixer.clone = function(node, overrides) {
+      var cloned, name;
+      cloned = clone(node);
+      for (name in overrides) {
+        cloned[name] = overrides[name];
+      }
+      return cloned;
+    };
+
+    function Prefixer(name1, prefixes1, all1) {
+      this.name = name1;
+      this.prefixes = prefixes1;
+      this.all = all1;
+    }
+
+    Prefixer.prototype.parentPrefix = function(node) {
+      var prefix;
+      prefix = node._autoprefixerPrefix != null ? node._autoprefixerPrefix : node.type === 'decl' && node.prop[0] === '-' ? vendor.prefix(node.prop) : node.type === 'root' ? false : node.type === 'rule' && node.selector.indexOf(':-') !== -1 && /:(-\w+-)/.test(node.selector) ? node.selector.match(/:(-\w+-)/)[1] : node.type === 'atrule' && node.name[0] === '-' ? vendor.prefix(node.name) : this.parentPrefix(node.parent);
+      if (Browsers.prefixes().indexOf(prefix) === -1) {
+        prefix = false;
+      }
+      return node._autoprefixerPrefix = prefix;
+    };
+
+    Prefixer.prototype.process = function(node) {
+      var added, j, k, len, len1, parent, prefix, prefixes, ref;
+      if (!this.check(node)) {
+        return;
+      }
+      parent = this.parentPrefix(node);
+      prefixes = [];
+      ref = this.prefixes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        prefix = ref[j];
+        if (parent && parent !== utils.removeNote(prefix)) {
+          continue;
+        }
+        prefixes.push(prefix);
+      }
+      added = [];
+      for (k = 0, len1 = prefixes.length; k < len1; k++) {
+        prefix = prefixes[k];
+        if (this.add(node, prefix, added.concat([prefix]))) {
+          added.push(prefix);
+        }
+      }
+      return added;
+    };
+
+    Prefixer.prototype.clone = function(node, overrides) {
+      return Prefixer.clone(node, overrides);
+    };
+
+    return Prefixer;
+
+  })();
+
+  module.exports = Prefixer;
+
+}).call(this);

node_modules/autoprefixer/lib/prefixes.js

@@ -0,0 +1,410 @@
+(function() {
+  var AtRule, Browsers, Declaration, Prefixes, Processor, Resolution, Selector, Supports, Transition, Value, declsCache, utils, vendor;
+
+  Declaration = require('./declaration');
+
+  Resolution = require('./resolution');
+
+  Transition = require('./transition');
+
+  Processor = require('./processor');
+
+  Supports = require('./supports');
+
+  Browsers = require('./browsers');
+
+  Selector = require('./selector');
+
+  AtRule = require('./at-rule');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  vendor = require('postcss/lib/vendor');
+
+  Selector.hack(require('./hacks/fullscreen'));
+
+  Selector.hack(require('./hacks/placeholder'));
+
+  Declaration.hack(require('./hacks/flex'));
+
+  Declaration.hack(require('./hacks/order'));
+
+  Declaration.hack(require('./hacks/filter'));
+
+  Declaration.hack(require('./hacks/grid-end'));
+
+  Declaration.hack(require('./hacks/flex-flow'));
+
+  Declaration.hack(require('./hacks/flex-grow'));
+
+  Declaration.hack(require('./hacks/flex-wrap'));
+
+  Declaration.hack(require('./hacks/grid-start'));
+
+  Declaration.hack(require('./hacks/align-self'));
+
+  Declaration.hack(require('./hacks/flex-basis'));
+
+  Declaration.hack(require('./hacks/mask-border'));
+
+  Declaration.hack(require('./hacks/align-items'));
+
+  Declaration.hack(require('./hacks/flex-shrink'));
+
+  Declaration.hack(require('./hacks/break-props'));
+
+  Declaration.hack(require('./hacks/writing-mode'));
+
+  Declaration.hack(require('./hacks/border-image'));
+
+  Declaration.hack(require('./hacks/justify-items'));
+
+  Declaration.hack(require('./hacks/align-content'));
+
+  Declaration.hack(require('./hacks/border-radius'));
+
+  Declaration.hack(require('./hacks/block-logical'));
+
+  Declaration.hack(require('./hacks/grid-template'));
+
+  Declaration.hack(require('./hacks/inline-logical'));
+
+  Declaration.hack(require('./hacks/grid-row-align'));
+
+  Declaration.hack(require('./hacks/transform-decl'));
+
+  Declaration.hack(require('./hacks/flex-direction'));
+
+  Declaration.hack(require('./hacks/image-rendering'));
+
+  Declaration.hack(require('./hacks/justify-content'));
+
+  Declaration.hack(require('./hacks/background-size'));
+
+  Declaration.hack(require('./hacks/text-emphasis-position'));
+
+  Value.hack(require('./hacks/stretch'));
+
+  Value.hack(require('./hacks/gradient'));
+
+  Value.hack(require('./hacks/pixelated'));
+
+  Value.hack(require('./hacks/image-set'));
+
+  Value.hack(require('./hacks/cross-fade'));
+
+  Value.hack(require('./hacks/flex-values'));
+
+  Value.hack(require('./hacks/display-flex'));
+
+  Value.hack(require('./hacks/display-grid'));
+
+  Value.hack(require('./hacks/filter-value'));
+
+  declsCache = {};
+
+  Prefixes = (function() {
+    function Prefixes(data1, browsers, options) {
+      var ref;
+      this.data = data1;
+      this.browsers = browsers;
+      this.options = options != null ? options : {};
+      ref = this.preprocess(this.select(this.data)), this.add = ref[0], this.remove = ref[1];
+      this.transition = new Transition(this);
+      this.processor = new Processor(this);
+    }
+
+    Prefixes.prototype.cleaner = function() {
+      var empty;
+      if (!this.cleanerCache) {
+        if (this.browsers.selected.length) {
+          empty = new Browsers(this.browsers.data, []);
+          this.cleanerCache = new Prefixes(this.data, empty, this.options);
+        } else {
+          return this;
+        }
+      }
+      return this.cleanerCache;
+    };
+
+    Prefixes.prototype.select = function(list) {
+      var add, all, data, name, notes, selected;
+      selected = {
+        add: {},
+        remove: {}
+      };
+      for (name in list) {
+        data = list[name];
+        add = data.browsers.map(function(i) {
+          var params;
+          params = i.split(' ');
+          return {
+            browser: params[0] + ' ' + params[1],
+            note: params[2]
+          };
+        });
+        notes = add.filter(function(i) {
+          return i.note;
+        }).map((function(_this) {
+          return function(i) {
+            return _this.browsers.prefix(i.browser) + ' ' + i.note;
+          };
+        })(this));
+        notes = utils.uniq(notes);
+        add = add.filter((function(_this) {
+          return function(i) {
+            return _this.browsers.isSelected(i.browser);
+          };
+        })(this)).map((function(_this) {
+          return function(i) {
+            var prefix;
+            prefix = _this.browsers.prefix(i.browser);
+            if (i.note) {
+              return prefix + ' ' + i.note;
+            } else {
+              return prefix;
+            }
+          };
+        })(this));
+        add = this.sort(utils.uniq(add));
+        if (this.options.flexbox === 'no-2009') {
+          add = add.filter(function(i) {
+            return i.indexOf('2009') === -1;
+          });
+        }
+        all = data.browsers.map((function(_this) {
+          return function(i) {
+            return _this.browsers.prefix(i);
+          };
+        })(this));
+        if (data.mistakes) {
+          all = all.concat(data.mistakes);
+        }
+        all = all.concat(notes);
+        all = utils.uniq(all);
+        if (add.length) {
+          selected.add[name] = add;
+          if (add.length < all.length) {
+            selected.remove[name] = all.filter(function(i) {
+              return add.indexOf(i) === -1;
+            });
+          }
+        } else {
+          selected.remove[name] = all;
+        }
+      }
+      return selected;
+    };
+
+    Prefixes.prototype.sort = function(prefixes) {
+      return prefixes.sort(function(a, b) {
+        var aLength, bLength;
+        aLength = utils.removeNote(a).length;
+        bLength = utils.removeNote(b).length;
+        if (aLength === bLength) {
+          return b.length - a.length;
+        } else {
+          return bLength - aLength;
+        }
+      });
+    };
+
+    Prefixes.prototype.preprocess = function(selected) {
+      var a, add, j, k, l, len, len1, len2, len3, len4, len5, len6, m, n, name, o, old, olds, p, prefix, prefixed, prefixes, prop, props, ref, ref1, ref2, ref3, remove, selector, value, values;
+      add = {
+        selectors: [],
+        '@supports': new Supports(Prefixes, this)
+      };
+      ref = selected.add;
+      for (name in ref) {
+        prefixes = ref[name];
+        if (name === '@keyframes' || name === '@viewport') {
+          add[name] = new AtRule(name, prefixes, this);
+        } else if (name === '@resolution') {
+          add[name] = new Resolution(name, prefixes, this);
+        } else if (this.data[name].selector) {
+          add.selectors.push(Selector.load(name, prefixes, this));
+        } else {
+          props = this.data[name].props;
+          if (props) {
+            value = Value.load(name, prefixes, this);
+            for (j = 0, len = props.length; j < len; j++) {
+              prop = props[j];
+              if (!add[prop]) {
+                add[prop] = {
+                  values: []
+                };
+              }
+              add[prop].values.push(value);
+            }
+          } else {
+            values = ((ref1 = add[name]) != null ? ref1.values : void 0) || [];
+            add[name] = Declaration.load(name, prefixes, this);
+            add[name].values = values;
+          }
+        }
+      }
+      remove = {
+        selectors: []
+      };
+      ref2 = selected.remove;
+      for (name in ref2) {
+        prefixes = ref2[name];
+        if (this.data[name].selector) {
+          selector = Selector.load(name, prefixes);
+          for (k = 0, len1 = prefixes.length; k < len1; k++) {
+            prefix = prefixes[k];
+            remove.selectors.push(selector.old(prefix));
+          }
+        } else if (name === '@keyframes' || name === '@viewport') {
+          for (l = 0, len2 = prefixes.length; l < len2; l++) {
+            prefix = prefixes[l];
+            prefixed = '@' + prefix + name.slice(1);
+            remove[prefixed] = {
+              remove: true
+            };
+          }
+        } else if (name === '@resolution') {
+          remove[name] = new Resolution(name, prefixes, this);
+        } else {
+          props = this.data[name].props;
+          if (props) {
+            value = Value.load(name, [], this);
+            for (m = 0, len3 = prefixes.length; m < len3; m++) {
+              prefix = prefixes[m];
+              old = value.old(prefix);
+              if (old) {
+                for (n = 0, len4 = props.length; n < len4; n++) {
+                  prop = props[n];
+                  if (!remove[prop]) {
+                    remove[prop] = {};
+                  }
+                  if (!remove[prop].values) {
+                    remove[prop].values = [];
+                  }
+                  remove[prop].values.push(old);
+                }
+              }
+            }
+          } else {
+            for (o = 0, len5 = prefixes.length; o < len5; o++) {
+              prefix = prefixes[o];
+              prop = vendor.unprefixed(name);
+              olds = this.decl(name).old(name, prefix);
+              if (name === 'align-self') {
+                a = (ref3 = add[name]) != null ? ref3.prefixes : void 0;
+                if (a) {
+                  if (prefix === '-webkit- 2009' && a.indexOf('-webkit-') !== -1) {
+                    continue;
+                  } else if (prefix === '-webkit-' && a.indexOf('-webkit- 2009') !== -1) {
+                    continue;
+                  }
+                }
+              }
+              for (p = 0, len6 = olds.length; p < len6; p++) {
+                prefixed = olds[p];
+                if (!remove[prefixed]) {
+                  remove[prefixed] = {};
+                }
+                remove[prefixed].remove = true;
+              }
+            }
+          }
+        }
+      }
+      return [add, remove];
+    };
+
+    Prefixes.prototype.decl = function(prop) {
+      var decl;
+      decl = declsCache[prop];
+      if (decl) {
+        return decl;
+      } else {
+        return declsCache[prop] = Declaration.load(prop);
+      }
+    };
+
+    Prefixes.prototype.unprefixed = function(prop) {
+      var value;
+      value = this.normalize(vendor.unprefixed(prop));
+      if (value === 'flex-direction') {
+        value = 'flex-flow';
+      }
+      return value;
+    };
+
+    Prefixes.prototype.normalize = function(prop) {
+      return this.decl(prop).normalize(prop);
+    };
+
+    Prefixes.prototype.prefixed = function(prop, prefix) {
+      prop = vendor.unprefixed(prop);
+      return this.decl(prop).prefixed(prop, prefix);
+    };
+
+    Prefixes.prototype.values = function(type, prop) {
+      var data, global, ref, ref1, values;
+      data = this[type];
+      global = (ref = data['*']) != null ? ref.values : void 0;
+      values = (ref1 = data[prop]) != null ? ref1.values : void 0;
+      if (global && values) {
+        return utils.uniq(global.concat(values));
+      } else {
+        return global || values || [];
+      }
+    };
+
+    Prefixes.prototype.group = function(decl) {
+      var checker, index, length, rule, unprefixed;
+      rule = decl.parent;
+      index = rule.index(decl);
+      length = rule.nodes.length;
+      unprefixed = this.unprefixed(decl.prop);
+      checker = (function(_this) {
+        return function(step, callback) {
+          var other;
+          index += step;
+          while (index >= 0 && index < length) {
+            other = rule.nodes[index];
+            if (other.type === 'decl') {
+              if (step === -1 && other.prop === unprefixed) {
+                if (!Browsers.withPrefix(other.value)) {
+                  break;
+                }
+              }
+              if (_this.unprefixed(other.prop) !== unprefixed) {
+                break;
+              } else if (callback(other) === true) {
+                return true;
+              }
+              if (step === +1 && other.prop === unprefixed) {
+                if (!Browsers.withPrefix(other.value)) {
+                  break;
+                }
+              }
+            }
+            index += step;
+          }
+          return false;
+        };
+      })(this);
+      return {
+        up: function(callback) {
+          return checker(-1, callback);
+        },
+        down: function(callback) {
+          return checker(+1, callback);
+        }
+      };
+    };
+
+    return Prefixes;
+
+  })();
+
+  module.exports = Prefixes;
+
+}).call(this);

node_modules/autoprefixer/lib/processor.js

@@ -0,0 +1,322 @@
+(function() {
+  var OLD_DIRECTION, Processor, SIZES, Value, utils, vendor;
+
+  vendor = require('postcss/lib/vendor');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  OLD_DIRECTION = /(^|[^-])(linear|radial)-gradient\(\s*(top|left|right|bottom)/i;
+
+  SIZES = ['width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size'];
+
+  Processor = (function() {
+    function Processor(prefixes) {
+      this.prefixes = prefixes;
+    }
+
+    Processor.prototype.add = function(css, result) {
+      var keyframes, resolution, supports, viewport;
+      resolution = this.prefixes.add['@resolution'];
+      keyframes = this.prefixes.add['@keyframes'];
+      viewport = this.prefixes.add['@viewport'];
+      supports = this.prefixes.add['@supports'];
+      css.walkAtRules((function(_this) {
+        return function(rule) {
+          if (rule.name === 'keyframes') {
+            if (!_this.disabled(rule)) {
+              return keyframes != null ? keyframes.process(rule) : void 0;
+            }
+          } else if (rule.name === 'viewport') {
+            if (!_this.disabled(rule)) {
+              return viewport != null ? viewport.process(rule) : void 0;
+            }
+          } else if (rule.name === 'supports') {
+            if (_this.prefixes.options.supports !== false && !_this.disabled(rule)) {
+              return supports.process(rule);
+            }
+          } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) {
+            if (!_this.disabled(rule)) {
+              return resolution != null ? resolution.process(rule) : void 0;
+            }
+          }
+        };
+      })(this));
+      css.walkRules((function(_this) {
+        return function(rule) {
+          var j, len, ref, results, selector;
+          if (_this.disabled(rule)) {
+            return;
+          }
+          ref = _this.prefixes.add.selectors;
+          results = [];
+          for (j = 0, len = ref.length; j < len; j++) {
+            selector = ref[j];
+            results.push(selector.process(rule, result));
+          }
+          return results;
+        };
+      })(this));
+      css.walkDecls((function(_this) {
+        return function(decl) {
+          var display, prefixer;
+          if (_this.disabled(decl)) {
+            return;
+          }
+          if (decl.prop === 'display' && decl.value === 'box') {
+            result.warn('You should write display: flex by final spec ' + 'instead of display: box', {
+              node: decl
+            });
+            return;
+          }
+          if (decl.value.indexOf('linear-gradient') !== -1) {
+            if (OLD_DIRECTION.test(decl.value)) {
+              result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `to left` instead of `right`.', {
+                node: decl
+              });
+            }
+          }
+          if (decl.prop === 'text-emphasis-position') {
+            if (decl.value === 'under' || decl.value === 'over') {
+              result.warn('You should use 2 values for text-emphasis-position ' + 'For example, `under left` instead of just `under`.', {
+                node: decl
+              });
+            }
+          }
+          if (SIZES.indexOf(decl.prop) !== -1) {
+            if (decl.value.indexOf('fill-available') !== -1) {
+              result.warn('Replace fill-available to stretch, ' + 'because spec had been changed', {
+                node: decl
+              });
+            } else if (decl.value.indexOf('fill') !== -1) {
+              result.warn('Replace fill to stretch, because spec had been changed', {
+                node: decl
+              });
+            }
+          }
+          if (_this.prefixes.options.flexbox !== false) {
+            if (decl.prop === 'grid-row-end' && decl.value.indexOf('span') === -1) {
+              result.warn('IE supports only grid-row-end with span. ' + 'You should add grid: false option to Autoprefixer ' + 'and use some JS grid polyfill for full spec support', {
+                node: decl
+              });
+            }
+            if (decl.prop === 'grid-row') {
+              if (decl.value.indexOf('/') !== -1 && decl.value.indexOf('span') === -1) {
+                result.warn('IE supports only grid-row with / and span. ' + 'You should add grid: false option to Autoprefixer ' + 'and use some JS grid polyfill for full spec support', {
+                  node: decl
+                });
+              }
+            }
+          }
+          if (decl.prop === 'transition' || decl.prop === 'transition-property') {
+            return _this.prefixes.transition.add(decl, result);
+          } else if (decl.prop === 'align-self') {
+            display = _this.displayType(decl);
+            if (display !== 'grid' && _this.prefixes.options.flexbox !== false) {
+              prefixer = _this.prefixes.add['align-self'];
+              if (prefixer && prefixer.prefixes) {
+                prefixer.process(decl);
+              }
+            }
+            if (display !== 'flex' && _this.prefixes.options.grid !== false) {
+              prefixer = _this.prefixes.add['grid-row-align'];
+              if (prefixer && prefixer.prefixes) {
+                return prefixer.process(decl);
+              }
+            }
+          } else {
+            prefixer = _this.prefixes.add[decl.prop];
+            if (prefixer && prefixer.prefixes) {
+              return prefixer.process(decl);
+            }
+          }
+        };
+      })(this));
+      return css.walkDecls((function(_this) {
+        return function(decl) {
+          var j, len, ref, unprefixed, value;
+          if (_this.disabled(decl)) {
+            return;
+          }
+          unprefixed = _this.prefixes.unprefixed(decl.prop);
+          ref = _this.prefixes.values('add', unprefixed);
+          for (j = 0, len = ref.length; j < len; j++) {
+            value = ref[j];
+            value.process(decl, result);
+          }
+          return Value.save(_this.prefixes, decl);
+        };
+      })(this));
+    };
+
+    Processor.prototype.remove = function(css) {
+      var checker, j, len, ref, resolution;
+      resolution = this.prefixes.remove['@resolution'];
+      css.walkAtRules((function(_this) {
+        return function(rule, i) {
+          if (_this.prefixes.remove['@' + rule.name]) {
+            if (!_this.disabled(rule)) {
+              return rule.parent.removeChild(i);
+            }
+          } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) {
+            return resolution != null ? resolution.clean(rule) : void 0;
+          }
+        };
+      })(this));
+      ref = this.prefixes.remove.selectors;
+      for (j = 0, len = ref.length; j < len; j++) {
+        checker = ref[j];
+        css.walkRules((function(_this) {
+          return function(rule, i) {
+            if (checker.check(rule)) {
+              if (!_this.disabled(rule)) {
+                return rule.parent.removeChild(i);
+              }
+            }
+          };
+        })(this));
+      }
+      return css.walkDecls((function(_this) {
+        return function(decl, i) {
+          var k, len1, notHack, ref1, ref2, rule, unprefixed;
+          if (_this.disabled(decl)) {
+            return;
+          }
+          rule = decl.parent;
+          unprefixed = _this.prefixes.unprefixed(decl.prop);
+          if (decl.prop === 'transition' || decl.prop === 'transition-property') {
+            _this.prefixes.transition.remove(decl);
+          }
+          if ((ref1 = _this.prefixes.remove[decl.prop]) != null ? ref1.remove : void 0) {
+            notHack = _this.prefixes.group(decl).down(function(other) {
+              return _this.prefixes.normalize(other.prop) === unprefixed;
+            });
+            if (unprefixed === 'flex-flow') {
+              notHack = true;
+            }
+            if (notHack && !_this.withHackValue(decl)) {
+              if (decl.raw('before').indexOf("\n") > -1) {
+                _this.reduceSpaces(decl);
+              }
+              rule.removeChild(i);
+              return;
+            }
+          }
+          ref2 = _this.prefixes.values('remove', unprefixed);
+          for (k = 0, len1 = ref2.length; k < len1; k++) {
+            checker = ref2[k];
+            if (checker.check(decl.value)) {
+              unprefixed = checker.unprefixed;
+              notHack = _this.prefixes.group(decl).down(function(other) {
+                return other.value.indexOf(unprefixed) !== -1;
+              });
+              if (notHack) {
+                rule.removeChild(i);
+                return;
+              } else if (checker.clean) {
+                checker.clean(decl);
+                return;
+              }
+            }
+          }
+        };
+      })(this));
+    };
+
+    Processor.prototype.withHackValue = function(decl) {
+      return decl.prop === '-webkit-background-clip' && decl.value === 'text';
+    };
+
+    Processor.prototype.disabled = function(node) {
+      var other, status;
+      if (this.prefixes.options.grid === false && node.type === 'decl') {
+        if (node.prop === 'display' && node.value.indexOf('grid') !== -1) {
+          return true;
+        }
+        if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') {
+          return true;
+        }
+      }
+      if (this.prefixes.options.flexbox === false && node.type === 'decl') {
+        if (node.prop === 'display' && node.value.indexOf('flex') !== -1) {
+          return true;
+        }
+        other = ['order', 'justify-content', 'align-items', 'align-content'];
+        if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) {
+          return true;
+        }
+      }
+      if (node._autoprefixerDisabled != null) {
+        return node._autoprefixerDisabled;
+      } else if (node.nodes) {
+        status = void 0;
+        node.each(function(i) {
+          if (i.type !== 'comment') {
+            return;
+          }
+          if (/(!\s*)?autoprefixer:\s*off/i.test(i.text)) {
+            status = false;
+            return false;
+          } else if (/(!\s*)?autoprefixer:\s*on/i.test(i.text)) {
+            status = true;
+            return false;
+          }
+        });
+        return node._autoprefixerDisabled = status != null ? !status : node.parent ? this.disabled(node.parent) : false;
+      } else if (node.parent) {
+        return node._autoprefixerDisabled = this.disabled(node.parent);
+      } else {
+        return false;
+      }
+    };
+
+    Processor.prototype.reduceSpaces = function(decl) {
+      var diff, parts, prevMin, stop;
+      stop = false;
+      this.prefixes.group(decl).up(function(other) {
+        return stop = true;
+      });
+      if (stop) {
+        return;
+      }
+      parts = decl.raw('before').split("\n");
+      prevMin = parts[parts.length - 1].length;
+      diff = false;
+      return this.prefixes.group(decl).down(function(other) {
+        var last;
+        parts = other.raw('before').split("\n");
+        last = parts.length - 1;
+        if (parts[last].length > prevMin) {
+          if (diff === false) {
+            diff = parts[last].length - prevMin;
+          }
+          parts[last] = parts[last].slice(0, -diff);
+          return other.raws.before = parts.join("\n");
+        }
+      });
+    };
+
+    Processor.prototype.displayType = function(decl) {
+      var i, j, len, ref;
+      ref = decl.parent.nodes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        i = ref[j];
+        if (i.prop === 'display') {
+          if (i.value.indexOf('flex') !== -1) {
+            return 'flex';
+          } else if (i.value.indexOf('grid') !== -1) {
+            return 'grid';
+          }
+        }
+      }
+      return false;
+    };
+
+    return Processor;
+
+  })();
+
+  module.exports = Processor;
+
+}).call(this);

node_modules/autoprefixer/lib/resolution.js

@@ -0,0 +1,98 @@
+(function() {
+  var Prefixer, Resolution, n2f, regexp, split, 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;
+
+  Prefixer = require('./prefixer');
+
+  utils = require('./utils');
+
+  n2f = require('num2fraction');
+
+  regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi;
+
+  split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i;
+
+  Resolution = (function(superClass) {
+    extend(Resolution, superClass);
+
+    function Resolution() {
+      return Resolution.__super__.constructor.apply(this, arguments);
+    }
+
+    Resolution.prototype.prefixName = function(prefix, name) {
+      return name = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio';
+    };
+
+    Resolution.prototype.prefixQuery = function(prefix, name, colon, value, units) {
+      if (units === 'dpi') {
+        value = Number(value / 96);
+      }
+      if (prefix === '-o-') {
+        value = n2f(value);
+      }
+      return this.prefixName(prefix, name) + colon + value;
+    };
+
+    Resolution.prototype.clean = function(rule) {
+      var j, len, prefix, ref;
+      if (!this.bad) {
+        this.bad = [];
+        ref = this.prefixes;
+        for (j = 0, len = ref.length; j < len; j++) {
+          prefix = ref[j];
+          this.bad.push(this.prefixName(prefix, 'min'));
+          this.bad.push(this.prefixName(prefix, 'max'));
+        }
+      }
+      return rule.params = utils.editList(rule.params, (function(_this) {
+        return function(queries) {
+          return queries.filter(function(query) {
+            return _this.bad.every(function(i) {
+              return query.indexOf(i) === -1;
+            });
+          });
+        };
+      })(this));
+    };
+
+    Resolution.prototype.process = function(rule) {
+      var parent, prefixes;
+      parent = this.parentPrefix(rule);
+      prefixes = parent ? [parent] : this.prefixes;
+      return rule.params = utils.editList(rule.params, (function(_this) {
+        return function(origin, prefixed) {
+          var j, k, len, len1, prefix, processed, query;
+          for (j = 0, len = origin.length; j < len; j++) {
+            query = origin[j];
+            if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) {
+              prefixed.push(query);
+              continue;
+            }
+            for (k = 0, len1 = prefixes.length; k < len1; k++) {
+              prefix = prefixes[k];
+              if (prefix === '-moz-' && rule.params.indexOf('dpi') !== -1) {
+                continue;
+              } else {
+                processed = query.replace(regexp, function(str) {
+                  var parts;
+                  parts = str.match(split);
+                  return _this.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
+                });
+                prefixed.push(processed);
+              }
+            }
+            prefixed.push(query);
+          }
+          return utils.uniq(prefixed);
+        };
+      })(this));
+    };
+
+    return Resolution;
+
+  })(Prefixer);
+
+  module.exports = Resolution;
+
+}).call(this);

node_modules/autoprefixer/lib/selector.js

@@ -0,0 +1,117 @@
+(function() {
+  var Browsers, OldSelector, Prefixer, Selector, 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;
+
+  OldSelector = require('./old-selector');
+
+  Prefixer = require('./prefixer');
+
+  Browsers = require('./browsers');
+
+  utils = require('./utils');
+
+  Selector = (function(superClass) {
+    extend(Selector, superClass);
+
+    function Selector(name1, prefixes, all) {
+      this.name = name1;
+      this.prefixes = prefixes;
+      this.all = all;
+      this.regexpCache = {};
+    }
+
+    Selector.prototype.check = function(rule) {
+      if (rule.selector.indexOf(this.name) !== -1) {
+        return !!rule.selector.match(this.regexp());
+      } else {
+        return false;
+      }
+    };
+
+    Selector.prototype.prefixed = function(prefix) {
+      return this.name.replace(/^([^\w]*)/, '$1' + prefix);
+    };
+
+    Selector.prototype.regexp = function(prefix) {
+      var name;
+      if (this.regexpCache[prefix]) {
+        return this.regexpCache[prefix];
+      }
+      name = prefix ? this.prefixed(prefix) : this.name;
+      return this.regexpCache[prefix] = RegExp("(^|[^:\"'=])" + (utils.escapeRegexp(name)), "gi");
+    };
+
+    Selector.prototype.possible = function() {
+      return Browsers.prefixes();
+    };
+
+    Selector.prototype.prefixeds = function(rule) {
+      var i, len, prefix, prefixeds, ref;
+      if (rule._autoprefixerPrefixeds) {
+        return rule._autoprefixerPrefixeds;
+      }
+      prefixeds = {};
+      ref = this.possible();
+      for (i = 0, len = ref.length; i < len; i++) {
+        prefix = ref[i];
+        prefixeds[prefix] = this.replace(rule.selector, prefix);
+      }
+      return rule._autoprefixerPrefixeds = prefixeds;
+    };
+
+    Selector.prototype.already = function(rule, prefixeds, prefix) {
+      var before, index, key, prefixed, some;
+      index = rule.parent.index(rule) - 1;
+      while (index >= 0) {
+        before = rule.parent.nodes[index];
+        if (before.type !== 'rule') {
+          return false;
+        }
+        some = false;
+        for (key in prefixeds) {
+          prefixed = prefixeds[key];
+          if (before.selector === prefixed) {
+            if (prefix === key) {
+              return true;
+            } else {
+              some = true;
+              break;
+            }
+          }
+        }
+        if (!some) {
+          return false;
+        }
+        index -= 1;
+      }
+      return false;
+    };
+
+    Selector.prototype.replace = function(selector, prefix) {
+      return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
+    };
+
+    Selector.prototype.add = function(rule, prefix) {
+      var cloned, prefixeds;
+      prefixeds = this.prefixeds(rule);
+      if (this.already(rule, prefixeds, prefix)) {
+        return;
+      }
+      cloned = this.clone(rule, {
+        selector: prefixeds[prefix]
+      });
+      return rule.parent.insertBefore(rule, cloned);
+    };
+
+    Selector.prototype.old = function(prefix) {
+      return new OldSelector(this, prefix);
+    };
+
+    return Selector;
+
+  })(Prefixer);
+
+  module.exports = Selector;
+
+}).call(this);

node_modules/autoprefixer/lib/supports.js

@@ -0,0 +1,255 @@
+(function() {
+  var Browsers, Supports, Value, brackets, browser, data, postcss, ref, support, supported, utils, version, versions;
+
+  Browsers = require('./browsers');
+
+  brackets = require('./brackets');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  postcss = require('postcss');
+
+  supported = [];
+
+  data = require('caniuse-db/features-json/css-featurequeries.json');
+
+  ref = data.stats;
+  for (browser in ref) {
+    versions = ref[browser];
+    for (version in versions) {
+      support = versions[version];
+      if (/y/.test(support)) {
+        supported.push(browser + ' ' + version);
+      }
+    }
+  }
+
+  Supports = (function() {
+    function Supports(Prefixes, all1) {
+      this.Prefixes = Prefixes;
+      this.all = all1;
+    }
+
+    Supports.prototype.prefixer = function() {
+      var browsers, filtered;
+      if (this.prefixerCache) {
+        return this.prefixerCache;
+      }
+      filtered = this.all.browsers.selected.filter((function(_this) {
+        return function(i) {
+          return supported.indexOf(i) !== -1;
+        };
+      })(this));
+      browsers = new Browsers(this.all.browsers.data, filtered, this.all.options);
+      return this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options);
+    };
+
+    Supports.prototype.parse = function(str) {
+      var prop, ref1, value;
+      ref1 = str.split(':'), prop = ref1[0], value = ref1[1];
+      value || (value = '');
+      return [prop.trim(), value.trim()];
+    };
+
+    Supports.prototype.virtual = function(str) {
+      var prop, ref1, rule, value;
+      ref1 = this.parse(str), prop = ref1[0], value = ref1[1];
+      rule = postcss.parse('a{}').first;
+      rule.append({
+        prop: prop,
+        value: value,
+        raws: {
+          before: ''
+        }
+      });
+      return rule;
+    };
+
+    Supports.prototype.prefixed = function(str) {
+      var decl, j, k, len, len1, prefixer, ref1, ref2, rule, value;
+      rule = this.virtual(str);
+      if (this.disabled(rule.first)) {
+        return rule.nodes;
+      }
+      prefixer = this.prefixer().add[rule.first.prop];
+      if (prefixer != null) {
+        if (typeof prefixer.process === "function") {
+          prefixer.process(rule.first);
+        }
+      }
+      ref1 = rule.nodes;
+      for (j = 0, len = ref1.length; j < len; j++) {
+        decl = ref1[j];
+        ref2 = this.prefixer().values('add', rule.first.prop);
+        for (k = 0, len1 = ref2.length; k < len1; k++) {
+          value = ref2[k];
+          value.process(decl);
+        }
+        Value.save(this.all, decl);
+      }
+      return rule.nodes;
+    };
+
+    Supports.prototype.isNot = function(node) {
+      return typeof node === 'string' && /not\s*/i.test(node);
+    };
+
+    Supports.prototype.isOr = function(node) {
+      return typeof node === 'string' && /\s*or\s*/i.test(node);
+    };
+
+    Supports.prototype.isProp = function(node) {
+      return typeof node === 'object' && node.length === 1 && typeof node[0] === 'string';
+    };
+
+    Supports.prototype.isHack = function(all, unprefixed) {
+      var check;
+      check = new RegExp('(\\(|\\s)' + utils.escapeRegexp(unprefixed) + ':');
+      return !check.test(all);
+    };
+
+    Supports.prototype.toRemove = function(str, all) {
+      var checker, j, len, prop, ref1, ref2, ref3, unprefixed, value;
+      ref1 = this.parse(str), prop = ref1[0], value = ref1[1];
+      unprefixed = this.all.unprefixed(prop);
+      if (((ref2 = this.all.cleaner().remove[prop]) != null ? ref2.remove : void 0) && !this.isHack(all, unprefixed)) {
+        return true;
+      }
+      ref3 = this.all.cleaner().values('remove', unprefixed);
+      for (j = 0, len = ref3.length; j < len; j++) {
+        checker = ref3[j];
+        if (checker.check(value)) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    Supports.prototype.remove = function(nodes, all) {
+      var i;
+      i = 0;
+      while (i < nodes.length) {
+        if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) {
+          if (this.toRemove(nodes[i][0], all)) {
+            nodes.splice(i, 2);
+          } else {
+            i += 2;
+          }
+        } else {
+          if (typeof nodes[i] === 'object') {
+            nodes[i] = this.remove(nodes[i], all);
+          }
+          i += 1;
+        }
+      }
+      return nodes;
+    };
+
+    Supports.prototype.cleanBrackets = function(nodes) {
+      return nodes.map((function(_this) {
+        return function(i) {
+          if (typeof i === 'object') {
+            if (i.length === 1 && typeof i[0] === 'object') {
+              return _this.cleanBrackets(i[0]);
+            } else {
+              return _this.cleanBrackets(i);
+            }
+          } else {
+            return i;
+          }
+        };
+      })(this));
+    };
+
+    Supports.prototype.convert = function(progress) {
+      var i, j, len, result;
+      result = [''];
+      for (j = 0, len = progress.length; j < len; j++) {
+        i = progress[j];
+        result.push([i.prop + ": " + i.value]);
+        result.push(' or ');
+      }
+      result[result.length - 1] = '';
+      return result;
+    };
+
+    Supports.prototype.normalize = function(nodes) {
+      if (typeof nodes === 'object') {
+        nodes = nodes.filter(function(i) {
+          return i !== '';
+        });
+        if (typeof nodes[0] === 'string' && nodes[0].indexOf(':') !== -1) {
+          return [brackets.stringify(nodes)];
+        } else {
+          return nodes.map((function(_this) {
+            return function(i) {
+              return _this.normalize(i);
+            };
+          })(this));
+        }
+      } else {
+        return nodes;
+      }
+    };
+
+    Supports.prototype.add = function(nodes, all) {
+      return nodes.map((function(_this) {
+        return function(i) {
+          var prefixed;
+          if (_this.isProp(i)) {
+            prefixed = _this.prefixed(i[0]);
+            if (prefixed.length > 1) {
+              return _this.convert(prefixed);
+            } else {
+              return i;
+            }
+          } else if (typeof i === 'object') {
+            return _this.add(i, all);
+          } else {
+            return i;
+          }
+        };
+      })(this));
+    };
+
+    Supports.prototype.process = function(rule) {
+      var ast;
+      ast = brackets.parse(rule.params);
+      ast = this.normalize(ast);
+      ast = this.remove(ast, rule.params);
+      ast = this.add(ast, rule.params);
+      ast = this.cleanBrackets(ast);
+      return rule.params = brackets.stringify(ast);
+    };
+
+    Supports.prototype.disabled = function(node) {
+      var other;
+      if (this.all.options.grid === false) {
+        if (node.prop === 'display' && node.value.indexOf('grid') !== -1) {
+          return true;
+        }
+        if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') {
+          return true;
+        }
+      }
+      if (this.all.options.flexbox === false) {
+        if (node.prop === 'display' && node.value.indexOf('flex') !== -1) {
+          return true;
+        }
+        other = ['order', 'justify-content', 'align-items', 'align-content'];
+        if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    return Supports;
+
+  })();
+
+  module.exports = Supports;
+
+}).call(this);

node_modules/autoprefixer/lib/transition.js

@@ -0,0 +1,291 @@
+(function() {
+  var Transition, list, parser, vendor;
+
+  parser = require('postcss-value-parser');
+
+  vendor = require('postcss/lib/vendor');
+
+  list = require('postcss/lib/list');
+
+  Transition = (function() {
+    function Transition(prefixes) {
+      this.prefixes = prefixes;
+    }
+
+    Transition.prototype.props = ['transition', 'transition-property'];
+
+    Transition.prototype.add = function(decl, result) {
+      var added, declPrefixes, j, k, l, len, len1, len2, names, operaClean, param, params, prefix, prefixValue, prefixed, prefixer, prop, ref, ref1, value, webkitClean;
+      declPrefixes = ((ref = this.prefixes.add[decl.prop]) != null ? ref.prefixes : void 0) || [];
+      params = this.parse(decl.value);
+      names = params.map((function(_this) {
+        return function(i) {
+          return _this.findProp(i);
+        };
+      })(this));
+      added = [];
+      if (names.some(function(i) {
+        return i[0] === '-';
+      })) {
+        return;
+      }
+      for (j = 0, len = params.length; j < len; j++) {
+        param = params[j];
+        prop = this.findProp(param);
+        if (prop[0] === '-') {
+          continue;
+        }
+        prefixer = this.prefixes.add[prop];
+        if (!(prefixer != null ? prefixer.prefixes : void 0)) {
+          continue;
+        }
+        ref1 = prefixer.prefixes;
+        for (k = 0, len1 = ref1.length; k < len1; k++) {
+          prefix = ref1[k];
+          prefixed = this.prefixes.prefixed(prop, prefix);
+          if (prefixed !== '-ms-transform' && names.indexOf(prefixed) === -1) {
+            if (!this.disabled(prop, prefix)) {
+              added.push(this.clone(prop, prefixed, param));
+            }
+          }
+        }
+      }
+      params = params.concat(added);
+      value = this.stringify(params);
+      webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-'));
+      if (declPrefixes.indexOf('-webkit-') !== -1) {
+        this.cloneBefore(decl, '-webkit-' + decl.prop, webkitClean);
+      }
+      this.cloneBefore(decl, decl.prop, webkitClean);
+      if (declPrefixes.indexOf('-o-') !== -1) {
+        operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-'));
+        this.cloneBefore(decl, '-o-' + decl.prop, operaClean);
+      }
+      for (l = 0, len2 = declPrefixes.length; l < len2; l++) {
+        prefix = declPrefixes[l];
+        if (prefix !== '-webkit-' && prefix !== '-o-') {
+          prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix));
+          this.cloneBefore(decl, prefix + decl.prop, prefixValue);
+        }
+      }
+      if (value !== decl.value && !this.already(decl, decl.prop, value)) {
+        this.checkForWarning(result, decl);
+        decl.cloneBefore();
+        return decl.value = value;
+      }
+    };
+
+    Transition.prototype.findProp = function(param) {
+      var i, j, len, prop, token;
+      prop = param[0].value;
+      if (/^\d/.test(prop)) {
+        for (i = j = 0, len = param.length; j < len; i = ++j) {
+          token = param[i];
+          if (i !== 0 && token.type === 'word') {
+            return token.value;
+          }
+        }
+      }
+      return prop;
+    };
+
+    Transition.prototype.already = function(decl, prop, value) {
+      return decl.parent.some(function(i) {
+        return i.prop === prop && i.value === value;
+      });
+    };
+
+    Transition.prototype.cloneBefore = function(decl, prop, value) {
+      if (!this.already(decl, prop, value)) {
+        return decl.cloneBefore({
+          prop: prop,
+          value: value
+        });
+      }
+    };
+
+    Transition.prototype.checkForWarning = function(result, decl) {
+      if (decl.prop === 'transition-property') {
+        return decl.parent.each(function(i) {
+          if (i.type !== 'decl') {
+            return;
+          }
+          if (i.prop.indexOf('transition-') !== 0) {
+            return;
+          }
+          if (i.prop === 'transition-property') {
+            return;
+          }
+          if (list.comma(i.value).length > 1) {
+            decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*');
+          }
+          return false;
+        });
+      }
+    };
+
+    Transition.prototype.remove = function(decl) {
+      var double, params, smaller, value;
+      params = this.parse(decl.value);
+      params = params.filter((function(_this) {
+        return function(i) {
+          var ref;
+          return !((ref = _this.prefixes.remove[_this.findProp(i)]) != null ? ref.remove : void 0);
+        };
+      })(this));
+      value = this.stringify(params);
+      if (decl.value === value) {
+        return;
+      }
+      if (params.length === 0) {
+        decl.remove();
+        return;
+      }
+      double = decl.parent.some(function(i) {
+        return i.prop === decl.prop && i.value === value;
+      });
+      smaller = decl.parent.some(function(i) {
+        return i !== decl && i.prop === decl.prop && i.value.length > value.length;
+      });
+      if (double || smaller) {
+        return decl.remove();
+      } else {
+        return decl.value = value;
+      }
+    };
+
+    Transition.prototype.parse = function(value) {
+      var ast, j, len, node, param, ref, result;
+      ast = parser(value);
+      result = [];
+      param = [];
+      ref = ast.nodes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        node = ref[j];
+        param.push(node);
+        if (node.type === 'div' && node.value === ',') {
+          result.push(param);
+          param = [];
+        }
+      }
+      result.push(param);
+      return result.filter(function(i) {
+        return i.length > 0;
+      });
+    };
+
+    Transition.prototype.stringify = function(params) {
+      var j, len, nodes, param;
+      if (params.length === 0) {
+        return '';
+      }
+      nodes = [];
+      for (j = 0, len = params.length; j < len; j++) {
+        param = params[j];
+        if (param[param.length - 1].type !== 'div') {
+          param.push(this.div(params));
+        }
+        nodes = nodes.concat(param);
+      }
+      if (nodes[0].type === 'div') {
+        nodes = nodes.slice(1);
+      }
+      if (nodes[nodes.length - 1].type === 'div') {
+        nodes = nodes.slice(0, -1);
+      }
+      return parser.stringify({
+        nodes: nodes
+      });
+    };
+
+    Transition.prototype.clone = function(origin, name, param) {
+      var changed, i, j, len, result;
+      result = [];
+      changed = false;
+      for (j = 0, len = param.length; j < len; j++) {
+        i = param[j];
+        if (!changed && i.type === 'word' && i.value === origin) {
+          result.push({
+            type: 'word',
+            value: name
+          });
+          changed = true;
+        } else {
+          result.push(i);
+        }
+      }
+      return result;
+    };
+
+    Transition.prototype.div = function(params) {
+      var j, k, len, len1, node, param;
+      for (j = 0, len = params.length; j < len; j++) {
+        param = params[j];
+        for (k = 0, len1 = param.length; k < len1; k++) {
+          node = param[k];
+          if (node.type === 'div' && node.value === ',') {
+            return node;
+          }
+        }
+      }
+      return {
+        type: 'div',
+        value: ',',
+        after: ' '
+      };
+    };
+
+    Transition.prototype.cleanOtherPrefixes = function(params, prefix) {
+      return params.filter((function(_this) {
+        return function(param) {
+          var current;
+          current = vendor.prefix(_this.findProp(param));
+          return current === '' || current === prefix;
+        };
+      })(this));
+    };
+
+    Transition.prototype.cleanFromUnprefixed = function(params, prefix) {
+      var j, len, p, param, prop, remove, result;
+      result = [];
+      remove = params.map((function(_this) {
+        return function(i) {
+          return _this.findProp(i);
+        };
+      })(this)).filter(function(i) {
+        return i.slice(0, prefix.length) === prefix;
+      }).map((function(_this) {
+        return function(i) {
+          return _this.prefixes.unprefixed(i);
+        };
+      })(this));
+      for (j = 0, len = params.length; j < len; j++) {
+        param = params[j];
+        prop = this.findProp(param);
+        p = vendor.prefix(prop);
+        if (remove.indexOf(prop) === -1 && (p === prefix || p === '')) {
+          result.push(param);
+        }
+      }
+      return result;
+    };
+
+    Transition.prototype.disabled = function(prop, prefix) {
+      var other;
+      other = ['order', 'justify-content', 'align-self', 'align-content'];
+      if (prop.indexOf('flex') !== -1 || other.indexOf(prop) !== -1) {
+        if (this.prefixes.options.flexbox === false) {
+          return true;
+        } else if (this.prefixes.options.flexbox === 'no-2009') {
+          return prefix.indexOf('2009') !== -1;
+        }
+      }
+    };
+
+    return Transition;
+
+  })();
+
+  module.exports = Transition;
+
+}).call(this);

node_modules/autoprefixer/lib/utils.js

@@ -0,0 +1,57 @@
+(function() {
+  var list;
+
+  list = require('postcss/lib/list');
+
+  module.exports = {
+    error: function(text) {
+      var err;
+      err = new Error(text);
+      err.autoprefixer = true;
+      throw err;
+    },
+    uniq: function(array) {
+      var filtered, i, j, len;
+      filtered = [];
+      for (j = 0, len = array.length; j < len; j++) {
+        i = array[j];
+        if (filtered.indexOf(i) === -1) {
+          filtered.push(i);
+        }
+      }
+      return filtered;
+    },
+    removeNote: function(string) {
+      if (string.indexOf(' ') === -1) {
+        return string;
+      } else {
+        return string.split(' ')[0];
+      }
+    },
+    escapeRegexp: function(string) {
+      return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&');
+    },
+    regexp: function(word, escape) {
+      if (escape == null) {
+        escape = true;
+      }
+      if (escape) {
+        word = this.escapeRegexp(word);
+      }
+      return RegExp("(^|[\\s,(])(" + word + "($|[\\s(,]))", "gi");
+    },
+    editList: function(value, callback) {
+      var changed, join, origin;
+      origin = list.comma(value);
+      changed = callback(origin, []);
+      if (origin === changed) {
+        return value;
+      } else {
+        join = value.match(/,\s*/);
+        join = join ? join[0] : ', ';
+        return changed.join(join);
+      }
+    }
+  };
+
+}).call(this);

node_modules/autoprefixer/lib/value.js

@@ -0,0 +1,108 @@
+(function() {
+  var OldValue, Prefixer, Value, utils, vendor,
+    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;
+
+  Prefixer = require('./prefixer');
+
+  OldValue = require('./old-value');
+
+  utils = require('./utils');
+
+  vendor = require('postcss/lib/vendor');
+
+  Value = (function(superClass) {
+    extend(Value, superClass);
+
+    function Value() {
+      return Value.__super__.constructor.apply(this, arguments);
+    }
+
+    Value.save = function(prefixes, decl) {
+      var already, cloned, prefix, prefixed, prop, propPrefix, ref, results, rule, trimmed, value;
+      prop = decl.prop;
+      ref = decl._autoprefixerValues;
+      results = [];
+      for (prefix in ref) {
+        value = ref[prefix];
+        if (value === decl.value) {
+          continue;
+        }
+        propPrefix = vendor.prefix(prop);
+        if (propPrefix === prefix) {
+          results.push(decl.value = value);
+        } else if (propPrefix === '-pie-') {
+          continue;
+        } else {
+          prefixed = prefixes.prefixed(prop, prefix);
+          rule = decl.parent;
+          if (rule.every(function(i) {
+            return i.prop !== prefixed;
+          })) {
+            trimmed = value.replace(/\s+/, ' ');
+            already = rule.some(function(i) {
+              return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
+            });
+            if (!already) {
+              cloned = this.clone(decl, {
+                value: value
+              });
+              results.push(decl.parent.insertBefore(decl, cloned));
+            } else {
+              results.push(void 0);
+            }
+          } else {
+            results.push(void 0);
+          }
+        }
+      }
+      return results;
+    };
+
+    Value.prototype.check = function(decl) {
+      var value;
+      value = decl.value;
+      if (value.indexOf(this.name) !== -1) {
+        return !!value.match(this.regexp());
+      } else {
+        return false;
+      }
+    };
+
+    Value.prototype.regexp = function() {
+      return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
+    };
+
+    Value.prototype.replace = function(string, prefix) {
+      return string.replace(this.regexp(), '$1' + prefix + '$2');
+    };
+
+    Value.prototype.value = function(decl) {
+      if (decl.raws.value && decl.raws.value.value === decl.value) {
+        return decl.raws.value.raw;
+      } else {
+        return decl.value;
+      }
+    };
+
+    Value.prototype.add = function(decl, prefix) {
+      var value;
+      decl._autoprefixerValues || (decl._autoprefixerValues = {});
+      value = decl._autoprefixerValues[prefix] || this.value(decl);
+      value = this.replace(value, prefix);
+      if (value) {
+        return decl._autoprefixerValues[prefix] = value;
+      }
+    };
+
+    Value.prototype.old = function(prefix) {
+      return new OldValue(this.name, prefix + this.name);
+    };
+
+    return Value;
+
+  })(Prefixer);
+
+  module.exports = Value;
+
+}).call(this);