Set up Grunt

Fixing up Grunt file to watch for directories

Exclude node modules folder from Jekyll built site

node_modules/.bin/csswring

@@ -0,0 +1 @@
+../csswring/bin/csswring

node_modules/autoprefixer-core/ChangeLog.md

@@ -0,0 +1,493 @@
+## 5.1.8
+* Fix gradients in `mask` and `mask-image` properties.
+* Fix old webkit prefix on some unsupported gradients.
+
+## 5.1.7
+* Fix placeholder selector (by Vincent De Oliveira).
+
+## 5.1.6
+* Use official `::placeholder-shown` selector (by Vincent De Oliveira).
+
+## 5.1.5
+* Add transition support for CSS Masks properties.
+
+## 5.1.4
+* Use `-webkit-` prefix for Opera Mobile 24.
+
+## 5.1.3
+* Add IE support for `image-rendering: crisp-edges`.
+
+## 5.1.2
+* Add never existed `@-ms-keyframes` to common mistake.
+
+## 5.1.1
+* Safer value split in `flex` hack.
+
+## 5.1 “Jianyuan”
+* Add support for resolution media query (by 一丝).
+* Higher accuracy while removing prefixes in values.
+* Add support for logical properties (by 一丝).
+* Add `@viewport` support.
+* Add `text-overflow` support (by 一丝).
+* Add `text-emphasis` support (by 一丝).
+* Add `image-rendering: crisp-edges` support.
+* Add `text-align-last` support.
+* Return `autoprefixer.defaults` as alias to current `browserslist.defaults`.
+* Save code style while adding prefixes to `@keyframes` and `@viewport`.
+* Do not remove `-webkit-background-clip` with non-spec `text` value.
+* Fix `-webkit-filter` in `transition`.
+* Better support for browser versions joined on Can I Use
+  like `ios_saf 7.0-7.1` (by Vincent De Oliveira).
+* Fix compatibility with `postcss-import` (by Jason Kuhrt).
+* Fix Flexbox prefixes for BlackBerry and UC Browser.
+* Fix gradient prefixes for old Chrome.
+
+## 5.0 “Pravda vítězí”
+* Use PostCSS 4.0.
+* Use Browserslist to parse browsers queries.
+* Use global `browserslist` config.
+* Add `> 5% in US` query to select browsers by usage in some country.
+* Add `object-fit` and `object-position` properties support.
+* Add CSS Shape properties support.
+* Fix UC Browser name in debug info.
+* Remove `autoprefixer.defaults` and use defaults from Browserslist.
+
+## 4.0.2
+* Remove `o-border-radius`, which is common mistake in legacy CSS.
+
+## 4.0.1
+* Fix `@supports` support with brackets in values (by Vincent De Oliveira).
+
+## 4.0 “Indivisibiliter ac Inseparabiliter”
+* Become 2.5 times fatser by new PostCSS 3.0 parser.
+* Do not remove outdated prefixes by `remove: false` option.
+* `map.inline` and `map.sourcesContent` options are now `true` by default.
+* Add `box-decoration-break` support.
+* Do not add old `-webkit-` prefix for gradients with `px` units.
+* Use previous source map to show origin source of CSS syntax error.
+* Use `from` option from previous source map `file` field.
+* Set `to` value to `from` if `to` option is missing.
+* Trim Unicode BOM on source maps parsing.
+* Parse at-rules without spaces like `@import"file"`.
+* Better previous `sourceMappingURL` annotation comment cleaning.
+* Do not remove previous `sourceMappingURL` comment on `map.annotation: false`.
+
+## 3.1.2
+* Update Firefox ESR version from 24 to 31.
+
+## 3.1.1
+* Use Flexbox 2009 spec for Android stock browser < 4.4.
+
+## 3.1 “Satyameva Jayate”
+* Do not remove comments from prefixed values (by Eitan Rousso).
+* Allow Safari 6.1 to use final Flexbox spec (by John Kreitlow).
+* Fix `filter` value in `transition` in Webkits.
+* Show greetings if your browsers don’t require any prefixes.
+* Add `<=` and `<` browsers requirement (by Andreas Lind).
+
+## 3.0.1
+* Fix `autoprefixer.postcss` in callbacks.
+
+## 3.0 “Liberté, Égalité, Fraternité”
+* Project was split to autoprefixer (with CLI) and autoprefixer-core.
+* `autoprefixer()` now receives only `options` object with `browsers` key.
+* GNU format for syntax error messages from PostCSS 2.2.
+
+## 2.2 “Mobilis in mobili”
+* Allow to disable Autoprefixer for some rule by control comment.
+* Use PostCSS 2.1 with Safe Mode option and broken source line
+  in CSS syntax error messages.
+
+## 2.1.1
+* Fix `-webkit-background-size` hack for `contain` and `cover` values.
+* Don’t add `-webkit-` prefix to `filter` with SVG (by Vincent De Oliveira).
+
+## 2.1 “Eleftheria i thanatos”
+* Add support for `clip-path` and `mask` properties.
+* Return `-webkit-` prefix to `filter` with SVG URI.
+
+## 2.0.2
+* Add readable names for new browsers from 2.0 release.
+* Don’t add `-webkit-` prefix to `filter` with SVG URI.
+* Don’t add `-o-` prefix 3D transforms.
+
+## 2.0.1
+* Save declaration style, when clone declaration to prefix.
+
+## 2.0 “Hongik Ingan”
+* Based on PostCSS 1.0.
+  See [options changes](https://github.com/postcss/postcss/releases/tag/1.0.0).
+* Restore visual cascade after declaration removing.
+* Enable visual cascade by default.
+* Prefix declareation in `@supports` at-rule conditions.
+* Add all browsers from Can I Use: `ie_mob`, `and_chr`, `and_ff`,
+  `op_mob` and `op_mini`.
+* Allow to use latest Autoprefixer from GitHub by npm.
+* Add `--no-cascade`, `--annotation` and `--sources-content` options to binary.
+
+## 1.3.1
+* Fix gradient hack, when `background` property contains color.
+
+## 1.3 “Tenka Fubu”
+* Add `text-size-adjust` support.
+* Add `background-size` to support Android 2.
+
+## 1.2 “Meiji”
+* Use Can I Use data from official `caniuse-db` npm package.
+* Remove package data update from binary.
+* Use increment value instead of current date in minor versions.
+
+## 1.1 “Nutrisco et extingo”
+* Add source map annotation comment support.
+* Add inline source map support.
+* Autodetect previous source map.
+* Fix source maps support on Windows.
+* Fix source maps support in subdirectory.
+* Prefix selector even if it is already prefixed by developer.
+* Add option `cascade` to create nice visual cascade of prefixes.
+* Fix flexbox support for IE 10 (by Roland Warmerdam).
+* Better `break-inside` support.
+* Fix prefixing, when two same properties are near.
+
+### 20140222:
+* Add `touch-action` support.
+
+### 20140226:
+* Chrome 33 is moved to released versions.
+* Add Chrome 36 data.
+
+### 20140302:
+* Add `text-decoration-*` properties support.
+* Update browsers usage statistics.
+* Use new PostCSS version.
+
+### 20140319:
+* Check already prefixed properties after current declaration.
+* Normalize spaces before already prefixed check.
+* Firefox 28 is moved to released versions.
+* Add Firefox 31 data.
+* Add some Blackberry data.
+
+### 20140327:
+* Don’t use `-ms-transform` in `@keyframes`, because IE 9 doesn’t support
+  animations.
+* Update BlackBerry 10 data.
+
+### 20140403:
+* Update browsers usage statistics.
+* Opera 20 is moved to released versions.
+* Add Opera 22 data.
+
+### 20140410:
+* Chrome 34 is moved to released versions.
+* Add Chrome 37 data.
+* Fix Chrome 36 data.
+
+### 20140429:
+* Fix `display: inline-flex` support by 2009 spec.
+* Fix old WebKit gradient converter (by Sergey Belov).
+* Fix CSS 3 cursors data (by Nick Schonning).
+
+### 20140430:
+* Separate 2D and 3D transform prefixes to clean unnecessary `-ms-` prefixes.
+* Firefox 29 is moved to released versions.
+* Add Firefox 32 data.
+
+### 20140510
+* Do not add `-ms-` prefix for `transform` with 3D functions.
+* Update browsers global usage statistics.
+
+### 20140512
+* Remove unnecessary `-moz-` prefix for `wavy` in `text-decoration`.
+* Update Safari data for font properties.
+
+### 20140521
+* Chrome 36 is moved to released versions.
+* Add Chrome 38 data.
+
+### 20140523
+* Opera 21 is moved to released versions.
+* Add Opera 23 data.
+
+### 20140605
+* Allow to parse gradients without space between color and position.
+* Add iOS 8, Safari 8 and Android 4.4.3 data.
+* Update browsers usage statistics.
+
+## 1.0 “Plus ultra”
+* Source map support.
+* Save origin indents and code formatting.
+* Change CSS parser to PostCSS.
+* Preserve vendor-prefixed properties put right after unprefixed ones.
+* Rename `compile()` to `process()` and return result object,
+  instead of CSS string.
+* Rename `inspect()` to `info()`.
+* Add in binary `-d` option to specify output directory.
+* Binary now will not concat output files.
+* Allow to select last versions for specified browser.
+* Add full browser names aliases: `firefox`, `explorer` and `blackberry`.
+* Ignore case in browser names.
+* Change license to MIT.
+* Add prefixes inside custom at-rules.
+* Add only necessary prefixes to selector inside prefixed at-rule.
+* Safer backgrounds list parser in gradient hack.
+* Prefix `@keyframes` inside `@media`.
+* Don’t prefix values for CSS3 PIE properties.
+* Binary now shows file name in syntax error.
+* Use browserify to build standalone version.
+
+### 20131225:
+* Fix deprecated API convertor.
+* Add `::placeholder` support for Firefix >= 18.
+* Fix vendor prefixes order.
+
+### 20140103:
+* Add `-webkit-` prefix for `sticky` position.
+* Update browsers popularity statistics.
+
+### 20140109:
+* Add selectors and at-rules sections to debug info.
+* Fix outdated prefixes cleaning.
+
+### 20140110:
+* Add `Firefox ESR` browser requirement.
+* Opera 18 is moved to released versions.
+* Add Opera 20 data.
+
+### 20140117:
+* Chrome 32 is moved to released versions.
+* Add Opera 34 data.
+
+### 20140130:
+* Fix flexbox properties names in transitions.
+* Add Chrome 35 and Firefox 29 data.
+
+### 20140203:
+* Android 4.4 stock browser and Opera 19 are moved to released versions.
+* Add Opera 21 data.
+* Update browsers usage statistics.
+
+### 20140213:
+* Add case insensitive to IE’s filter hack (by Dominik Schilling).
+* Improve selector prefixing in some rare cases (by Simon Lydell).
+* Firefox 27 is moved to released versions.
+* Add Firefox 30 data.
+
+## 0.8 “Unbowed, Unbent, Unbroken”
+* Add more browsers to defaults ("> 1%, last 2 versions, ff 17, opera 12.1"
+  instead of just "last 2 browsers").
+* Keep vendor prefixes without unprefixed version (like vendor-specific hacks).
+* Convert gradients to old WebKit syntax (actual for Android 2.3).
+* Better support for several syntaxes with one prefix (like Flexbox and
+  gradients in WebKit).
+* Add intrinsic and extrinsic sizing values support.
+* Remove never existed prefixes from common mistakes (like -ms-transition).
+* Add Opera 17 data.
+* Fix selector prefixes order.
+* Fix browser versions order in inspect.
+
+### 20130903:
+* Fix old WebKit gradients convertor on rgba() colors.
+* Allow to write old direction syntax in gradients.
+
+### 20130906:
+* Fix direction syntax in radial gradients.
+* Don’t prefix IE filter with modern syntax.
+
+### 20130911:
+* Fix parsing property name with spaces.
+
+### 20130919:
+* Fix processing custom framework prefixes (by Johannes J. Schmidt).
+* Concat outputs if several files compiled to one output.
+* Decrease standalone build size by removing unnecessary Binary class.
+* iOS 7 is moved to released versions.
+* Clean up binary code (by Simon Lydell).
+
+### 20130923:
+* Firefox 24 is moved to released versions.
+
+### 20131001:
+* Add support for grab, grabbing, zoom-in and zoom-out cursor values.
+
+### 20131006:
+* Chrome 30 is moved to released versions.
+
+### 20131007:
+* Don’t add another prefixes in rule with prefixed selector.
+
+### 20131009:
+* Opera 17 is moved to released versions.
+
+### 20131015:
+* Fix converting multiple gradients to old webkit syntax (by Aleksei Androsov).
+
+### 20131017:
+* Fix @host at-rule parsing.
+
+### 20131020:
+* IE 11 and Andrid 4.3 is moved to released versions.
+* Add Opera 18 data.
+* Add @namespace support.
+* Sort browser versions in data file.
+
+### 20131029:
+* Add Safari 6.1 data.
+* Add fx alias for Firefox.
+
+### 20131104:
+* Update Android future version to 4.4.
+* Google Chrome 32 added to future versions list.
+* Firefox 25 now is actual version, 27 and 28 added to future versions.
+* Browsers statistics are updated.
+
+### 20131205:
+* Google Chrome 33 added to future releases list.
+* Google Chrome 31 moved to current releases list.
+
+### 20131209:
+* Use old webkit gradients for old iOS and Safari (by Chad von Nau).
+* Fix direction conversion for old webkit gradients (by Chad von Nau).
+* Update browsers popularity statistics.
+
+### 20131213:
+* Firefox ESR in default browsers was changed to 24 version.
+* Firefox 26 was moved to current releases list.
+* Firefox 28 was added to future releases list.
+
+## 0.7 “We Do Not Sow”
+* Add vendor prefixes to selectors.
+* Add ::selection and ::placeholder selectors support.
+* Allow to load support data from Can I Use pull requests.
+* Remove deprecated API.
+
+### 20130806:
+* Add hyphens support.
+
+### 20130807:
+* Add tab-size support.
+* Add :fullscreen support.
+
+### 20130808:
+* Allow to select browser versions by > and >= operator.
+* Fix flex properties in transition.
+
+### 20130810:
+* Add Firefox 25 data.
+
+### 20130824:
+* Add Chrome 31 and 30 data.
+* Fix CSS comments parsing (by vladkens).
+
+## 0.6 “As High As Honor”
+* New faster API, which cache preprocessed data. Old API is deprecated.
+* A lot of perfomance improvements.
+* Add Opera 15 -webkit- prefix support.
+* Update Chrome 29 and Safari 7 prefixes data.
+* Add minor browsers in popularity select.
+* Better syntax error messages.
+
+### 20130721:
+* Add Chrome 30 data.
+
+### 20130728:
+* Don’t remove non-standard -webkit-background-clip: text.
+* Don’t remove IE hack on CSS parse.
+
+### 20130729:
+* Add Opera 16 data.
+* Fix “Invalid range in character class” error on Firefox.
+
+### 20130730:
+* Fix correct clone comments inside keyframes (by Alexey Plutalov).
+* Fix angle recalculation in gradients (by Roman Komarov).
+
+### 20130731:
+* Add border-image support.
+
+## 0.5 “Ours is the Fury”
+* Rewrite Autoprefixer to be more flexible.
+* Use css, instead of Rework, to fix CSS parsing errors faster.
+* Fix a lot of CSS parsing errors.
+
+### 20130616:
+* More useful message for CSS parsing errors.
+* Remove old WebKit gradient syntax.
+* Fix parsing error on comment with braces.
+
+### 20130617:
+* Remove old Mozilla border-radius.
+* Don’t prefix old IE filter.
+* Remove old background-clip, background-size and background-origin prefixes.
+* Speed up regexps in values.
+* Allow to hack property declarations.
+
+### 20130625:
+* Convert flexbox properties to 2009 and 2012 specifications.
+* Improve messages on syntax errors.
+
+### 20130626:
+* Add Firefox 24 data.
+* Add prefixes for font-feature-settings.
+
+### 20130629:
+* Fix convert flex properties to old box-flex.
+
+## 0.4 “Winter Is Coming”
+* Remove outdated prefixes.
+* Add border-radius and box-shadow properties to database.
+* Change degrees in webkit gradients.
+
+### 20130515:
+* Add old syntax in gradient direction.
+* Add old syntax for display: flex.
+* Update browser global usage statistics.
+
+### 20130521:
+* Add Firefox 23 data.
+
+### 20130524:
+* Add Chrome 29 data.
+
+### 20130528:
+* Fix compatibilty with Rework from git master.
+* Add minor browsers to data, which can be selected only directly.
+
+### 20130530:
+* Add Opera 15 and iOS 6.1 data.
+* Fix iOS versions in properties and values data.
+
+### 20130603:
+* Use latest Rework 0.15 with a lot of CSS parsing fixes.
+* Update browsers usage statistics.
+
+## 0.3 “Growing Strong”
+* Rename `autoprefixer.filter()` to `autoprefixer.rework()`.
+* Use own filters instead of Rework’s `prefix` and `prefixValue`.
+* Smarter value prefixer without false match “order” in “border”.
+* 40% faster.
+* Don’t add unnecessary properties instead of Rework’s `prefixValue`.
+* Don’t change properties order.
+* Sort properties and values in inspect output.
+* Add main to component config (by Jonathan Ong).
+* Fix documentation (by Sergey Leschina and Mark Vasilkov).
+
+### 20130424:
+* Fix value override in prefixer.
+
+### 20130427:
+* Prefix several same values in one property.
+* Fix Windows support in binary.
+* Improve print errors in binary.
+
+### 20130502:
+* Don’t add -webkit- prefix to IE filter.
+* Don’t duplicate prefixes on second run.
+
+## 0.2 “Hear Me Roar!”
+* Update parse libraries.
+* Use component package manager to build standalone script.
+* Add inspect to standalone script.
+
+## 0.1 “Fire and Blood”
+* Initial release.

node_modules/autoprefixer-core/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/autoprefixer-core/README.md

@@ -0,0 +1,194 @@
+# Autoprefixer Core [![Build Status](https://travis-ci.org/postcss/autoprefixer-core.svg)](https://travis-ci.org/postcss/autoprefixer-core)
+
+<img align="right" width="94" height="71" src="http://postcss.github.io/autoprefixer/logo.svg" title="Autoprefixer logo by Anton Lovchikov">
+
+[PostCSS] plugin to parse CSS and add vendor prefixes using values
+from [Can I Use].
+
+This is core package to build Autoprefixer plugin for some environment
+(like [grunt‑autoprefixer]). For end-user documentation, features
+and plugins list visit [main Autoprefixer] project.
+
+<a href="https://evilmartians.com/?utm_source=autoprefixer-core">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+[grunt‑autoprefixer]: https://github.com/nDmitry/grunt-autoprefixer
+[main Autoprefixer]:  https://github.com/postcss/autoprefixer
+[Can I Use]:          http://caniuse.com/
+[PostCSS]:            https://github.com/postcss/postcss
+
+## Quick Example
+
+Write your CSS rules without vendor prefixes (in fact, forget about them
+entirely):
+
+```css
+:fullscreen a {
+    display: flex
+}
+```
+
+Process your CSS by Autoprefixer:
+
+```js
+var autoprefixer = require('autoprefixer-core');
+var prefixed = autoprefixer.process(css).css;
+```
+
+It will use the data based on current browser popularity and property support
+to apply prefixes for you:
+
+```css
+:-webkit-full-screen a {
+    display: -webkit-box;
+    display: -webkit-flex;
+    display: flex
+}
+:-moz-full-screen a {
+    display: flex
+}
+:-ms-fullscreen a {
+    display: -ms-flexbox;
+    display: flex
+}
+:fullscreen a {
+    display: -webkit-box;
+    display: -webkit-flex;
+    display: -ms-flexbox;
+    display: flex
+}
+```
+
+## Usage
+
+To process your CSS you need to make 2 steps:
+
+1. Build processor for your options and browsers supported in your project.
+2. Process CSS throw this processor.
+
+Function `autoprefixer(options)` returns new processor object:
+
+```js
+var processor = autoprefixer({ browsers: ['> 1%', 'IE 7'], cascade: false });
+```
+
+There are 2 options:
+
+* `browsers` (array): list of browsers, which are supported in your project.
+  You can directly specify browser version (like `iOS 7`) or use selections
+  (like `last 2 version` or `> 5%`). See [Browserslist docs] for available
+  queries and default value.
+* `cascade` (boolean): should Autoprefixer uses [Visual Cascade],
+  if CSS will be uncompressed.
+
+Processor object had:
+
+* `.process(css, opts)` method, which will add prefixes to `css`.
+* `.info()` method, which returns debug information: which browsers are selected
+  and which properties will be prefixed
+* `.postcss` property returns [PostCSS] processor to use in chain
+  with other [PostCSS processors].
+
+You can use processor object to process several CSS files
+to increase perfomance.
+
+There are `autoprefixer.process()`, `autoprefixer.info()`
+and `autoprefixer.postcss` shortcuts, which use default browsers and options.
+
+[PostCSS processors]: https://github.com/postcss/postcss#built-with-postcss
+[Browserslist docs]:  https://github.com/ai/browserslist
+[Visual Cascade]:     https://github.com/postcss/autoprefixer#visual-cascade
+[PostCSS]:            https://github.com/postcss/postcss
+
+## CSS Processing
+
+Method `process(css, opts)` from Autoprefixer processor is a PostCSS’s method.
+
+You must set `from` and `to` options with file names to generates corrects
+source maps and useful error messages.
+
+Options:
+
+* `from` (path): file path to origin CSS files.
+* `to` (path): file path to future CSS file, which will
+  contain processed CSS with prefixes.
+* `safe` (boolean): enables [Safe Mode] in PostCSS. By default `false`.
+* `map` contains options for source maps:
+
+  * `inline: false` to force save map to separated file, instead of inline it
+    to CSS in special comment by base64.
+  * `prev` (string or object): map content from previous processing step
+    (like Sass compilation).
+
+  If you set `map: false`, PostCSS will remove source map.
+
+You can read more about the source map options in [PostCSS documentation].
+
+[PostCSS documentation]: https://github.com/postcss/postcss#source-map-1
+[Safe Mode]:             https://github.com/postcss/postcss#safe-mode
+
+## PostCSS Chain
+
+You parse CSS only once and then process it through array of PostCSS processors.
+
+For example, you can use [gulp-postcss]:
+
+```js
+var postcss    = require('gulp-postcss');
+var sourcemaps = require('gulp-sourcemaps');
+
+gulp.task('css', function () {
+    var processors = [
+        require('autoprefixer')('last 1 version'),
+        require('css-mqpacker'),
+        require('csswring')
+     ];
+     return gulp.src('./src/style.css')
+        .pipe(sourcemaps.init())
+        .pipe(postcss(processors))
+        .pipe(sourcemaps.write('.'))
+        .pipe(gulp.dest('./dest'));
+});
+```
+
+[gulp-postcss]: https://github.com/w0rm/gulp-postcss
+
+## Safe Mode
+
+PostCSS has a special safe mode to parse broken CSS. If you set the `safe: true`
+option to the `process` method, it will  parse `a {` as `a {}`:
+
+```js
+autoprefixer.process('a {');                 // will throw “Unclosed block”
+autoprefixer.process('a {', { safe: true }); // will process as a closed block
+```
+
+It is useful for legacy code when using several hacks, or interactive
+tools with live input, like [Autoprefixer demo].
+
+[Autoprefixer demo]: http://simevidas.jsbin.com/gufoko/quiet
+
+## Cleaning
+
+By default, Autoprefixer not only add new prefixes, but also remove outdated.
+You can remove this behaviour by `remove: false` option:
+
+```js
+autoprefixer()
+  .process('a { -webkit-border-radius: 2px; border-radius: 2px }');
+// remove outdated -webkit-border-radius
+
+autoprefixer({ remove: false })
+  .process('a { -webkit-border-radius: 2px; border-radius: 2px }');
+// keeps -webkit-border-radius
+```
+
+## Debug
+
+You can check which browsers are selected and which properties will be prefixed:
+
+```js
+info = autoprefixer({ browsers: ['last 1 version'] }).info();
+console.log(info);
+```

node_modules/autoprefixer-core/data/prefixes.js

@@ -0,0 +1,433 @@
+(function() {
+  var add, crispedges, feature, flexbox, gradients, logicalProps, prefix, resolution, result, sort, textDecoration,
+    slice = [].slice;
+
+  sort = function(array) {
+    return array.sort(function(a, b) {
+      a = a.split(' ');
+      b = b.split(' ');
+      if (a[0] > b[0]) {
+        return 1;
+      } else if (a[0] < b[0]) {
+        return -1;
+      } else {
+        return parseFloat(a[1]) - parseFloat(b[1]);
+      }
+    });
+  };
+
+  feature = function(data, opts, callback) {
+    var browser, match, need, ref, ref1, support, version, versions;
+    if (!callback) {
+      ref = [opts, {}], callback = ref[0], opts = ref[1];
+    }
+    match = opts.match || /\sx($|\s)/;
+    need = [];
+    ref1 = data.stats;
+    for (browser in ref1) {
+      versions = ref1[browser];
+      for (version in versions) {
+        support = versions[version];
+        if (support.match(match)) {
+          need.push(browser + ' ' + version);
+        }
+      }
+    }
+    return callback(sort(need));
+  };
+
+  result = {};
+
+  prefix = function() {
+    var data, i, j, k, len, name, names, results;
+    names = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), data = arguments[j++];
+    results = [];
+    for (k = 0, len = names.length; k < len; k++) {
+      name = names[k];
+      result[name] = {};
+      results.push((function() {
+        var results1;
+        results1 = [];
+        for (i in data) {
+          results1.push(result[name][i] = data[i]);
+        }
+        return results1;
+      })());
+    }
+    return results;
+  };
+
+  add = function() {
+    var data, j, k, len, name, names, results;
+    names = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), data = arguments[j++];
+    results = [];
+    for (k = 0, len = names.length; k < len; k++) {
+      name = names[k];
+      results.push(result[name].browsers = sort(result[name].browsers.concat(data.browsers)));
+    }
+    return results;
+  };
+
+  module.exports = result;
+
+  feature(require('caniuse-db/features-json/border-radius'), function(browsers) {
+    return prefix('border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius', {
+      mistakes: ['-ms-', '-o-'],
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-boxshadow'), function(browsers) {
+    return prefix('box-shadow', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-animation'), function(browsers) {
+    return prefix('animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes', {
+      mistakes: ['-ms-'],
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-transitions'), function(browsers) {
+    return prefix('transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function', {
+      mistakes: ['-ms-'],
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/transforms2d'), function(browsers) {
+    return prefix('transform', 'transform-origin', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/transforms3d'), function(browsers) {
+    prefix('perspective', 'perspective-origin', {
+      transition: true,
+      browsers: browsers
+    });
+    return prefix('transform-style', 'backface-visibility', {
+      browsers: browsers
+    });
+  });
+
+  gradients = require('caniuse-db/features-json/css-gradients');
+
+  feature(gradients, {
+    match: /y\sx/
+  }, function(browsers) {
+    return prefix('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', {
+      props: ['background', 'background-image', 'border-image', 'list-style', 'list-style-image', 'content', 'mask-image', 'mask'],
+      mistakes: ['-ms-'],
+      browsers: browsers
+    });
+  });
+
+  feature(gradients, {
+    match: /a\sx/
+  }, function(browsers) {
+    browsers = browsers.map(function(i) {
+      if (/op/.test(i)) {
+        return i;
+      } else {
+        return i + " old";
+      }
+    });
+    return add('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css3-boxsizing'), function(browsers) {
+    return prefix('box-sizing', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-filters'), function(browsers) {
+    return prefix('filter', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/multicolumn'), function(browsers) {
+    prefix('columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', {
+      transition: true,
+      browsers: browsers
+    });
+    return prefix('column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/user-select-none'), function(browsers) {
+    return prefix('user-select', {
+      browsers: browsers
+    });
+  });
+
+  flexbox = require('caniuse-db/features-json/flexbox');
+
+  feature(flexbox, {
+    match: /a\sx/
+  }, function(browsers) {
+    browsers = browsers.map(function(i) {
+      if (/ie|firefox/.test(i)) {
+        return i;
+      } else {
+        return i + " 2009";
+      }
+    });
+    prefix('display-flex', 'inline-flex', {
+      props: ['display'],
+      browsers: browsers
+    });
+    prefix('flex', 'flex-grow', 'flex-shrink', 'flex-basis', {
+      transition: true,
+      browsers: browsers
+    });
+    return prefix('flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content', {
+      browsers: browsers
+    });
+  });
+
+  feature(flexbox, {
+    match: /y\sx/
+  }, function(browsers) {
+    add('display-flex', 'inline-flex', {
+      browsers: browsers
+    });
+    add('flex', 'flex-grow', 'flex-shrink', 'flex-basis', {
+      browsers: browsers
+    });
+    return add('flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/calc'), function(browsers) {
+    return prefix('calc', {
+      props: ['*'],
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/background-img-opts'), function(browsers) {
+    return prefix('background-clip', 'background-origin', 'background-size', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/font-feature'), function(browsers) {
+    return prefix('font-feature-settings', 'font-variant-ligatures', 'font-language-override', 'font-kerning', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/border-image'), function(browsers) {
+    return prefix('border-image', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-selection'), function(browsers) {
+    return prefix('::selection', {
+      selector: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-placeholder'), function(browsers) {
+    browsers = browsers.map(function(i) {
+      var name, ref, version;
+      ref = i.split(' '), name = ref[0], version = ref[1];
+      if (name === 'firefox' && parseFloat(version) <= 18) {
+        return i + ' old';
+      } else {
+        return i;
+      }
+    });
+    return prefix(':placeholder-shown', '::placeholder', {
+      selector: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-hyphens'), function(browsers) {
+    return prefix('hyphens', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/fullscreen'), function(browsers) {
+    return prefix(':fullscreen', {
+      selector: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css3-tabsize'), function(browsers) {
+    return prefix('tab-size', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/intrinsic-width'), function(browsers) {
+    return prefix('max-content', 'min-content', 'fit-content', 'fill-available', {
+      props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height'],
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css3-cursors-newer'), function(browsers) {
+    prefix('zoom-in', 'zoom-out', {
+      props: ['cursor'],
+      browsers: browsers.concat(['chrome 3'])
+    });
+    return prefix('grab', 'grabbing', {
+      props: ['cursor'],
+      browsers: browsers.concat(['firefox 24', 'firefox 25', 'firefox 26'])
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-sticky'), function(browsers) {
+    return prefix('sticky', {
+      props: ['position'],
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/pointer'), function(browsers) {
+    return prefix('touch-action', {
+      browsers: browsers
+    });
+  });
+
+  textDecoration = require('caniuse-db/features-json/text-decoration');
+
+  feature(textDecoration, function(browsers) {
+    return prefix('text-decoration-style', {
+      browsers: browsers
+    });
+  });
+
+  feature(textDecoration, {
+    match: /y\sx($|\s)/
+  }, function(browsers) {
+    return prefix('text-decoration-line', 'text-decoration-color', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/text-size-adjust'), function(browsers) {
+    return prefix('text-size-adjust', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-masks'), function(browsers) {
+    prefix('mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', {
+      browsers: browsers
+    });
+    return prefix('clip-path', 'mask', 'mask-position', 'mask-size', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-boxdecorationbreak'), function(brwsrs) {
+    return prefix('box-decoration-break', {
+      browsers: brwsrs
+    });
+  });
+
+  feature(require('caniuse-db/features-json/object-fit'), function(browsers) {
+    return prefix('object-fit', 'object-position', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-shapes'), function(browsers) {
+    return prefix('shape-margin', 'shape-outside', 'shape-image-threshold', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/text-overflow'), function(browsers) {
+    return prefix('text-overflow', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/text-emphasis'), function(browsers) {
+    return prefix('text-emphasis', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-deviceadaptation'), function(browsers) {
+    return prefix('@viewport', {
+      browsers: browsers
+    });
+  });
+
+  resolution = require('caniuse-db/features-json/css-media-resolution');
+
+  feature(resolution, {
+    match: /( x($| )|a #3)/
+  }, function(browsers) {
+    return prefix('@resolution', {
+      browsers: browsers
+    });
+  });
+
+  feature(require('caniuse-db/features-json/css-text-align-last'), function(browsers) {
+    return prefix('text-align-last', {
+      browsers: browsers
+    });
+  });
+
+  crispedges = require('caniuse-db/features-json/css-crisp-edges');
+
+  feature(crispedges, {
+    match: /y x/
+  }, function(browsers) {
+    return prefix('crisp-edges', {
+      props: ['image-rendering'],
+      browsers: browsers
+    });
+  });
+
+  feature(crispedges, {
+    match: /a x/
+  }, function(browsers) {
+    return prefix('image-rendering', {
+      browsers: browsers
+    });
+  });
+
+  logicalProps = require('caniuse-db/features-json/css-logical-props');
+
+  feature(logicalProps, function(browsers) {
+    return prefix('border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+  feature(logicalProps, {
+    match: /x\s#2/
+  }, function(browsers) {
+    return prefix('border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', {
+      transition: true,
+      browsers: browsers
+    });
+  });
+
+}).call(this);

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

@@ -0,0 +1,109 @@
+(function() {
+  var Autoprefixer, Browsers, Prefixes, autoprefixer, browserslist, infoCache, isPlainObject, postcss,
+    slice = [].slice,
+    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  browserslist = require('browserslist');
+
+  postcss = require('postcss');
+
+  Browsers = require('./browsers');
+
+  Prefixes = require('./prefixes');
+
+  infoCache = null;
+
+  isPlainObject = function(obj) {
+    return Object.prototype.toString.apply(obj) === '[object Object]';
+  };
+
+  autoprefixer = function() {
+    var options, 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();
+    }
+    if ((options != null ? options.browsers : void 0) != null) {
+      reqs = options.browsers;
+    }
+    return new Autoprefixer(autoprefixer.data, reqs, options);
+  };
+
+  autoprefixer.data = {
+    browsers: require('caniuse-db/data').agents,
+    prefixes: require('../data/prefixes')
+  };
+
+  Autoprefixer = (function() {
+    function Autoprefixer(data, reqs1, options1) {
+      this.data = data;
+      this.reqs = reqs1;
+      this.options = options1 != null ? options1 : {};
+      this.postcss = bind(this.postcss, this);
+    }
+
+    Autoprefixer.prototype.process = function(str, options) {
+      if (options == null) {
+        options = {};
+      }
+      return postcss(this.postcss).process(str, options);
+    };
+
+    Autoprefixer.prototype.postcss = function(css) {
+      var prefixes;
+      prefixes = this.prefixes({
+        from: css.source.input.file
+      });
+      if (this.options.remove !== false) {
+        prefixes.processor.remove(css);
+      }
+      return prefixes.processor.add(css);
+    };
+
+    Autoprefixer.prototype.prefixes = function(opts) {
+      var browsers;
+      browsers = new Browsers(autoprefixer.data.browsers, this.reqs, opts);
+      return new Prefixes(autoprefixer.data.prefixes, browsers, this.options);
+    };
+
+    Autoprefixer.prototype.info = function(opts) {
+      infoCache || (infoCache = require('./info'));
+      return infoCache(this.prefixes(opts));
+    };
+
+    return Autoprefixer;
+
+  })();
+
+  autoprefixer.defaults = browserslist.defaults;
+
+  autoprefixer.loadDefault = function() {
+    return this.defaultCache || (this.defaultCache = autoprefixer());
+  };
+
+  autoprefixer.process = function(str, options) {
+    if (options == null) {
+      options = {};
+    }
+    return this.loadDefault().process(str, options);
+  };
+
+  autoprefixer.postcss = function(css) {
+    return autoprefixer.loadDefault().postcss(css);
+  };
+
+  autoprefixer.info = function() {
+    return this.loadDefault().info();
+  };
+
+  module.exports = autoprefixer;
+
+}).call(this);

node_modules/autoprefixer-core/lib/browsers.js

@@ -0,0 +1,83 @@
+(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').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) {
+      this.data = data1;
+      this.options = options;
+      this.selected = this.parse(requirements);
+    }
+
+    Browsers.prototype.parse = function(requirements) {
+      var ref;
+      return browserslist(requirements, {
+        path: (ref = this.options) != null ? ref.from : 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-core/lib/declaration.js

@@ -0,0 +1,153 @@
+(function() {
+  var Browsers, Declaration, Prefixer, 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');
+
+  Browsers = require('./browsers');
+
+  vendor = require('postcss/lib/vendor');
+
+  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.style('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.style('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.style('before').split("\n");
+      min = lines[lines.length - 1];
+      this.all.group(decl).up(function(prefixed) {
+        var array, last;
+        array = prefixed.style('before').split("\n");
+        last = array[array.length - 1];
+        if (last.length < min.length) {
+          return min = last;
+        }
+      });
+      lines[lines.length - 1] = min;
+      return decl.before = lines.join("\n");
+    };
+
+    Declaration.prototype.insert = function(decl, prefix, prefixes) {
+      var cloned;
+      cloned = this.set(this.clone(decl), prefix);
+      if (!cloned) {
+        return;
+      }
+      if (this.needCascade(decl)) {
+        cloned.before = this.calcBefore(prefixes, decl, prefix);
+      }
+      return decl.parent.insertBefore(decl, cloned);
+    };
+
+    Declaration.prototype.add = function(decl, prefix, prefixes) {
+      var already, prefixed;
+      prefixed = this.prefixed(decl.prop, prefix);
+      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;
+      }));
+      if (already || 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.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-core/lib/hacks/align-content.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

node_modules/autoprefixer-core/lib/info.js

@@ -0,0 +1,122 @@
+(function() {
+  var capitalize, names, prefix;
+
+  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, transition, prefixes) {
+    var out;
+    out = '  ' + name + (transition ? '*' : '') + ': ';
+    out += prefixes.map(function(i) {
+      return i.replace(/^-(.*)-$/g, '$1');
+    }).join(', ');
+    out += "\n";
+    return out;
+  };
+
+  module.exports = function(prefixes) {
+    var atrules, browser, data, j, k, l, len, len1, len2, list, name, needTransition, out, props, ref, ref1, ref2, ref3, ref4, ref5, ref6, selector, selectors, string, transitionProp, useTransition, 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";
+    }
+    atrules = '';
+    ref2 = prefixes.add;
+    for (name in ref2) {
+      data = ref2[name];
+      if (name[0] === '@' && data.prefixes) {
+        atrules += prefix(name, false, 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, false, selector.prefixes);
+      }
+    }
+    if (selectors !== '') {
+      out += "\nSelectors:\n" + selectors;
+    }
+    values = '';
+    props = '';
+    useTransition = false;
+    needTransition = (ref4 = prefixes.add.transition) != null ? ref4.prefixes : void 0;
+    ref5 = prefixes.add;
+    for (name in ref5) {
+      data = ref5[name];
+      if (name[0] !== '@' && data.prefixes) {
+        transitionProp = needTransition && prefixes.data[name].transition;
+        if (transitionProp) {
+          useTransition = true;
+        }
+        props += prefix(name, transitionProp, data.prefixes);
+      }
+      if (!data.values) {
+        continue;
+      }
+      if (prefixes.transitionProps.some(function(i) {
+        return i === name;
+      })) {
+        continue;
+      }
+      ref6 = data.values;
+      for (l = 0, len2 = ref6.length; l < len2; l++) {
+        value = ref6[l];
+        string = prefix(value.name, false, value.prefixes);
+        if (values.indexOf(string) === -1) {
+          values += string;
+        }
+      }
+    }
+    if (useTransition) {
+      props += "  * - can be used in transition\n";
+    }
+    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-core/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-core/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-core/lib/prefixer.js

@@ -0,0 +1,119 @@
+(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;
+    if (typeof obj !== 'object') {
+      return obj;
+    }
+    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 (value instanceof Array) {
+        cloned[i] = value.map(function(i) {
+          return clone(i, cloned);
+        });
+      } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
+        cloned[i] = clone(value, cloned);
+      }
+    }
+    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 ? 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-core/lib/prefixes.js

@@ -0,0 +1,368 @@
+(function() {
+  var AtRule, Browsers, Declaration, Prefixes, Processor, Resolution, Selector, Supports, Value, declsCache, utils, vendor;
+
+  Declaration = require('./declaration');
+
+  Resolution = require('./resolution');
+
+  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/flex-flow'));
+
+  Declaration.hack(require('./hacks/flex-grow'));
+
+  Declaration.hack(require('./hacks/flex-wrap'));
+
+  Declaration.hack(require('./hacks/align-self'));
+
+  Declaration.hack(require('./hacks/flex-basis'));
+
+  Declaration.hack(require('./hacks/align-items'));
+
+  Declaration.hack(require('./hacks/flex-shrink'));
+
+  Declaration.hack(require('./hacks/break-inside'));
+
+  Declaration.hack(require('./hacks/border-image'));
+
+  Declaration.hack(require('./hacks/align-content'));
+
+  Declaration.hack(require('./hacks/border-radius'));
+
+  Declaration.hack(require('./hacks/block-logical'));
+
+  Declaration.hack(require('./hacks/inline-logical'));
+
+  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'));
+
+  Value.hack(require('./hacks/gradient'));
+
+  Value.hack(require('./hacks/crisp-edges'));
+
+  Value.hack(require('./hacks/flex-values'));
+
+  Value.hack(require('./hacks/display-flex'));
+
+  Value.hack(require('./hacks/filter-value'));
+
+  Value.hack(require('./hacks/fill-available'));
+
+  Value.hack(require('./hacks/transform-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.processor = new Processor(this);
+    }
+
+    Prefixes.prototype.transitionProps = ['transition', 'transition-property'];
+
+    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));
+        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 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, remove, selector, value, values;
+      add = {
+        selectors: [],
+        '@supports': new Supports(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].transition ? this.transitionProps : 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);
+            }
+          }
+          if (!this.data[name].props) {
+            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].transition ? this.transitionProps : 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);
+                }
+              }
+            }
+          }
+          if (!this.data[name].props) {
+            for (o = 0, len5 = prefixes.length; o < len5; o++) {
+              prefix = prefixes[o];
+              prop = vendor.unprefixed(name);
+              olds = this.decl(name).old(name, prefix);
+              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) {
+      prop = vendor.unprefixed(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-core/lib/processor.js

@@ -0,0 +1,213 @@
+(function() {
+  var Processor, Value, utils, vendor;
+
+  vendor = require('postcss/lib/vendor');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  Processor = (function() {
+    function Processor(prefixes) {
+      this.prefixes = prefixes;
+    }
+
+    Processor.prototype.add = function(css) {
+      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.eachAtRule((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.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.eachRule((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));
+          }
+          return results;
+        };
+      })(this));
+      css.eachDecl((function(_this) {
+        return function(decl) {
+          var prefix;
+          prefix = _this.prefixes.add[decl.prop];
+          if (prefix && prefix.prefixes) {
+            if (!_this.disabled(decl)) {
+              return prefix.process(decl);
+            }
+          }
+        };
+      })(this));
+      return css.eachDecl((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);
+          }
+          return Value.save(_this.prefixes, decl);
+        };
+      })(this));
+    };
+
+    Processor.prototype.remove = function(css) {
+      var checker, j, len, ref, resolution;
+      resolution = this.prefixes.remove['@resolution'];
+      css.eachAtRule((function(_this) {
+        return function(rule, i) {
+          if (_this.prefixes.remove['@' + rule.name]) {
+            if (!_this.disabled(rule)) {
+              return rule.parent.remove(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.eachRule((function(_this) {
+          return function(rule, i) {
+            if (checker.check(rule)) {
+              if (!_this.disabled(rule)) {
+                return rule.parent.remove(i);
+              }
+            }
+          };
+        })(this));
+      }
+      return css.eachDecl((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 ((ref1 = _this.prefixes.remove[decl.prop]) != null ? ref1.remove : void 0) {
+            notHack = _this.prefixes.group(decl).down(function(other) {
+              return other.prop === unprefixed;
+            });
+            if (notHack && !_this.withHackValue(decl)) {
+              if (decl.style('before').indexOf("\n") > -1) {
+                _this.reduceSpaces(decl);
+              }
+              rule.remove(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.remove(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 status;
+      if (node._autoprefixerDisabled != null) {
+        return node._autoprefixerDisabled;
+      } else if (node.nodes) {
+        status = void 0;
+        node.each(function(i) {
+          if (i.type !== 'comment') {
+            return;
+          }
+          if (i.text === 'autoprefixer: off') {
+            status = false;
+            return false;
+          } else if (i.text === 'autoprefixer: on') {
+            status = true;
+            return false;
+          }
+        });
+        return node._autoprefixerDisabled = status != null ? !status : node.parent ? this.disabled(node.parent) : false;
+      } else {
+        return node._autoprefixerDisabled = this.disabled(node.parent);
+      }
+    };
+
+    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.style('before').split("\n");
+      prevMin = parts[parts.length - 1].length;
+      diff = false;
+      return this.prefixes.group(decl).down(function(other) {
+        var last;
+        parts = other.style('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.before = parts.join("\n");
+        }
+      });
+    };
+
+    return Processor;
+
+  })();
+
+  module.exports = Processor;
+
+}).call(this);

node_modules/autoprefixer-core/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-core/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-core/lib/supports.js

@@ -0,0 +1,115 @@
+(function() {
+  var Prefixes, Supports, Value, findCondition, findDecl, list, postcss, split, utils;
+
+  Prefixes = require('./prefixes');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  postcss = require('postcss');
+
+  list = require('postcss/lib/list');
+
+  split = /\(\s*([^\(\):]+)\s*:([^\)]+)/;
+
+  findDecl = /\(\s*([^\(\):]+)\s*:\s*(.+)\s*\)/g;
+
+  findCondition = /(not\s*)?\(\s*([^\(\):]+)\s*:\s*(.+?(?!\s*or\s*).+?)\s*\)*\s*\)\s*or\s*/gi;
+
+  Supports = (function() {
+    function Supports(all1) {
+      this.all = all1;
+    }
+
+    Supports.prototype.virtual = function(prop, value) {
+      var rule;
+      rule = postcss.parse('a{}').first;
+      rule.append({
+        prop: prop,
+        value: value,
+        before: ''
+      });
+      return rule;
+    };
+
+    Supports.prototype.prefixed = function(prop, value) {
+      var decl, j, k, len, len1, prefixer, ref, ref1, rule;
+      rule = this.virtual(prop, value);
+      prefixer = this.all.add[prop];
+      if (prefixer != null) {
+        if (typeof prefixer.process === "function") {
+          prefixer.process(rule.first);
+        }
+      }
+      ref = rule.nodes;
+      for (j = 0, len = ref.length; j < len; j++) {
+        decl = ref[j];
+        ref1 = this.all.values('add', prop);
+        for (k = 0, len1 = ref1.length; k < len1; k++) {
+          value = ref1[k];
+          value.process(decl);
+        }
+        Value.save(this.all, decl);
+      }
+      return rule.nodes;
+    };
+
+    Supports.prototype.clean = function(params) {
+      return params.replace(findCondition, (function(_this) {
+        return function(all) {
+          var _, check, checker, j, len, prop, ref, ref1, ref2, unprefixed, value;
+          if (all.slice(0, 3).toLowerCase() === 'not') {
+            return all;
+          }
+          ref = all.match(split), _ = ref[0], prop = ref[1], value = ref[2];
+          unprefixed = _this.all.unprefixed(prop);
+          if ((ref1 = _this.all.cleaner().remove[prop]) != null ? ref1.remove : void 0) {
+            check = new RegExp('(\\(|\\s)' + utils.escapeRegexp(unprefixed) + ':');
+            if (check.test(params)) {
+              return '';
+            }
+          }
+          ref2 = _this.all.cleaner().values('remove', unprefixed);
+          for (j = 0, len = ref2.length; j < len; j++) {
+            checker = ref2[j];
+            if (checker.check(value)) {
+              return '';
+            }
+          }
+          return all;
+        };
+      })(this)).replace(/\(\s*\((.*)\)\s*\)/g, '($1)');
+    };
+
+    Supports.prototype.process = function(rule) {
+      rule.params = this.clean(rule.params);
+      return rule.params = rule.params.replace(findDecl, (function(_this) {
+        return function(all, prop, value) {
+          var i, stringed;
+          stringed = (function() {
+            var j, len, ref, results;
+            ref = this.prefixed(prop, value);
+            results = [];
+            for (j = 0, len = ref.length; j < len; j++) {
+              i = ref[j];
+              results.push("(" + i.prop + ": " + i.value + ")");
+            }
+            return results;
+          }).call(_this);
+          if (stringed.length === 1) {
+            return stringed[0];
+          } else {
+            return '(' + stringed.join(' or ') + ')';
+          }
+        };
+      })(this));
+    };
+
+    return Supports;
+
+  })();
+
+  module.exports = Supports;
+
+}).call(this);

node_modules/autoprefixer-core/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-core/lib/value.js

@@ -0,0 +1,103 @@
+(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, propPrefix, ref, results, rule, trimmed, value;
+      ref = decl._autoprefixerValues;
+      results = [];
+      for (prefix in ref) {
+        value = ref[prefix];
+        if (value === decl.value) {
+          continue;
+        }
+        propPrefix = vendor.prefix(decl.prop);
+        if (propPrefix === prefix) {
+          results.push(decl.value = value);
+        } else if (propPrefix === '-pie-') {
+          continue;
+        } else {
+          prefixed = prefixes.prefixed(decl.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) {
+              if (value.indexOf('-webkit-filter') !== -1 && (decl.prop === 'transition' || decl.prop === 'trasition-property')) {
+                results.push(decl.value = value);
+              } else {
+                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.add = function(decl, prefix) {
+      var ref, value;
+      decl._autoprefixerValues || (decl._autoprefixerValues = {});
+      value = decl._autoprefixerValues[prefix] || ((ref = decl._value) != null ? ref.raw : void 0) || decl.value;
+      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);

node_modules/autoprefixer-core/node_modules/browserslist/.npmignore

@@ -0,0 +1,8 @@
+.gitignore
+
+node_modules/
+
+test/
+.travis.yml
+
+gulpfile.js

node_modules/autoprefixer-core/node_modules/browserslist/ChangeLog.md

@@ -0,0 +1,15 @@
+## 0.2
+* Return Can I Use joined versions as `ios_saf 7.0-7.1`.
+
+## 0.1.3
+* Better work with Can I Use joined versions like `ios_saf 7.0-7.1`.
+* Browserslist now understands `ios_saf 7.0` or `ios_saf 7`.
+
+## 0.1.2
+* Do not create global `browserslist` var (by Maxime Thirouin).
+
+## 0.1.1
+* Sort browsers by name and version.
+
+## 0.1
+* Initial release.

node_modules/autoprefixer-core/node_modules/browserslist/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/autoprefixer-core/node_modules/browserslist/README.md

@@ -0,0 +1,100 @@
+# Browserslist [![Build Status](https://travis-ci.org/ai/browserslist.svg)](https://travis-ci.org/ai/browserslist)
+
+Get browser versions that match given criteria.
+Useful for tools like [Autoprefixer].
+
+You can select browsers by passing a string. This library will use Can I Use
+data to return the appropriate list of all matching versions.
+
+For example, the last version of each major browser and version,
+with a usage of over 5% in global usage statistics:
+
+```js
+browserslist('> 5%, last 1 version');
+//=> ['and_chr 40', 'chrome 40', 'chrome 39', 'firefox 35', 'firefox 34',
+//    'ie 11', 'ie_mob 11', 'ios_saf 8.1', 'opera 26', 'safari 8']
+```
+
+If you don't provide an argument, Browserslist will look for a `browserslist`
+config file in current or parent directories.
+
+If no config file is found, Browserslist will use the default list:
+`> 1%, last 2 versions, Firefox ESR, Opera 12.1`.
+
+<a href="https://evilmartians.com/?utm_source=browserslist">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+
+## Queries
+
+You can specify the browsers by queries (case insensitive):
+
+* `last 2 versions`: the last 2 versions for each major browser.
+* `last 2 Chrome versions`: the last 2 versions of Chrome browser.
+* `> 5%`: versions selected by global usage statistics.
+* `> 5% in US`: uses USA usage statistics. It accepts [two-letter country code].
+* `Firefox > 20`: versions of Firefox newer than 20.
+* `Firefox >= 20`: versions of Firefox newer than or equal to 20.
+* `Firefox < 20`: versions of Firefox less than 20.
+* `Firefox <= 20`: versions of Firefox less than or equal to 20.
+* `Firefox ESR`: the latest [Firefox ESR] version.
+* `iOS 7`: the iOS browser version 7 directly.
+
+Blackberry and Android WebView will not be used in `last n versions`.
+You should add them by name.
+
+[two-letter country codes]: http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements
+
+## Browsers
+
+Names are case insensitive:
+
+* `Android` for Android WebView.
+* `BlackBerry` or `bb` for Blackberry browser.
+* `Chrome` for Google Chrome.
+* `Firefox` or `ff` for Mozilla Firefox.
+* `Explorer` or `ie` for Internet Explorer.
+* `iOS` or `ios_saf` for iOS Safari.
+* `Opera` for Opera.
+* `Safari` for desktop Safari.
+* `OperaMobile` or `op_mob` for Opera Mobile.
+* `OperaMini` or `op_mini` for Opera Mini.
+* `ChromeAndroid` or `and_chr` for Chrome for Android
+  (mostly same as common `Chrome`).
+* `FirefoxAndroid` or `and_ff` for Firefox for Android.
+* `ExplorerMobile` or `ie_mob` for Internet Explorer Mobile.
+
+
+## Usage
+
+```js
+var browserslist = require('browserslist');
+
+// Your CSS/JS build tool code
+var process = function (css, opts) {
+    var browsers = browserslist(opts.browsers, { path: opts.file });
+    // Your code to add features for selected browsers
+}
+```
+
+If a list is missing, Browserslist will look for a config file.
+You can provide a `path` option (that can be a file) to find the config file
+relatively to it.
+
+Queries can be a string `"> 5%, last 1 version"`
+or and array `['> 5%', 'last 1 version']`.
+
+## Config File
+
+Browserslist’s config should be named `browserslist` and have browsers queries
+split by a new line. You can write a comment after `#`:
+
+```yaml
+# Browsers that we support
+
+> 1%
+Last 2 versions
+IE 8 # sorry
+```

node_modules/autoprefixer-core/node_modules/browserslist/index.js

@@ -0,0 +1,327 @@
+var caniuse = require('caniuse-db/data').agents;
+var path    = require('path');
+var fs      = require('fs');
+
+var uniq = function (array) {
+    var filtered = [];
+    for ( var i = 0; i < array.length; i++ ) {
+        if ( filtered.indexOf(array[i]) == -1 ) filtered.push(array[i]);
+    }
+    return filtered;
+};
+
+normalizeVersion = function (data, version) {
+    if ( data.versions.indexOf(version) != -1 ) {
+        return version;
+    } else {
+        var alias = browserslist.versionAliases[data.name][version];
+        if ( alias ) return alias;
+    }
+};
+
+// Return array of browsers by selection queries:
+//
+//   browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+var browserslist = function (selections, opts) {
+    if ( typeof(opts) == 'undefined' ) opts = { };
+
+    if ( typeof(selections) == 'undefined' || selections === null ) {
+        var config = browserslist.readConfig(opts.path);
+        if ( config === false ) {
+            selections = browserslist.defaults;
+        } else {
+            selections = config;
+        }
+    }
+
+    if ( typeof(selections) == 'string' ) {
+        selections = selections.split(/,\s*/);
+    }
+
+    var result = [];
+
+    var query, match, array, used;
+    selections.forEach(function (selection) {
+        if ( selection.trim() === '' ) return;
+        used = false;
+
+        for ( var i in browserslist.queries ) {
+            query = browserslist.queries[i];
+            match = selection.match(query.regexp);
+            if ( match ) {
+                array  = query.select.apply(browserslist, match.slice(1));
+                result = result.concat(array);
+                used   = true;
+                break;
+            }
+        }
+
+        if ( !used ) {
+            throw 'Unknown browser query `' + selection + '`';
+        }
+    });
+
+    return uniq(result).sort(function (name1, name2) {
+        name1 = name1.split(' ');
+        name2 = name2.split(' ');
+        if ( name1[0] == name2[0] ) {
+            return parseFloat(name2[1]) - parseFloat(name1[1]);
+        } else {
+            return name1[0].localeCompare(name2[0]);
+        }
+    });
+};
+
+// Will be filled by Can I Use data below
+browserslist.data  = { };
+browserslist.usage = {
+    global: { }
+};
+
+// Default browsers query
+browserslist.defaults = [
+    '> 1%',
+    'last 2 versions',
+    'Firefox ESR',
+    'Opera 12.1'
+];
+
+// What browsers will be used in `last n version` query
+browserslist.major = ['safari', 'opera', 'ios_saf', 'ie_mob', 'ie',
+                      'firefox', 'chrome'];
+
+// Browser names aliases
+browserslist.aliases = {
+    fx:             'firefox',
+    ff:             'firefox',
+    ios:            'ios_saf',
+    explorer:       'ie',
+    blackberry:     'bb',
+    explorermobile: 'ie_mob',
+    operamini:      'op_mini',
+    operamobile:    'op_mob',
+    chromeandroid:  'and_chr',
+    firefoxandroid: 'and_ff'
+};
+
+// Aliases ot work with joined versions like `ios_saf 7.0-7.1`
+browserslist.versionAliases = { };
+
+// Get browser data by alias or case insensitive name
+browserslist.byName = function (name) {
+    name = name.toLowerCase();
+    name = browserslist.aliases[name] || name;
+
+    var data = browserslist.data[name];
+    if ( !data ) throw 'Unknown browser ' + name;
+    return data;
+};
+
+// Find config, read file and parse it
+browserslist.readConfig = function (from) {
+    if ( from === false )   return false;
+    if ( !fs.readFileSync ) return false;
+    if ( typeof(from) == 'undefined' ) from = '.';
+
+    var dirs = path.resolve(from).split(path.sep);
+    var config, stat;
+    while ( dirs.length ) {
+        config = dirs.concat(['browserslist']).join(path.sep);
+
+        if ( fs.existsSync(config) && fs.lstatSync(config).isFile() ) {
+            return browserslist.parseConfig( fs.readFileSync(config) );
+        }
+
+        dirs.pop();
+    }
+
+    return false;
+};
+
+// Return array of queries from config content
+browserslist.parseConfig = function (string) {
+    return string.toString()
+                 .replace(/#[^\n]*/g, '')
+                 .split(/\n/)
+                 .map(function (i) {
+                    return i.trim();
+                 })
+                 .filter(function (i) {
+                    return i !== '';
+                 });
+};
+
+browserslist.queries = {
+
+    lastVersions: {
+        regexp: /^last (\d+) versions?$/i,
+        select: function (versions) {
+            var selected = [];
+            browserslist.major.forEach(function (name) {
+                var data  = browserslist.byName(name);
+                var array = data.released.slice(-versions);
+
+                array = array.map(function (v) {
+                    return data.name + ' ' + v;
+                });
+                selected = selected.concat(array);
+            });
+            return selected;
+        }
+    },
+
+    lastByBrowser: {
+        regexp: /^last (\d+) (\w+) versions?$/i,
+        select: function (versions, name) {
+            var data = browserslist.byName(name);
+            return data.released.slice(-versions).map(function (v) {
+                return data.name + ' ' + v;
+            });
+        }
+    },
+
+    globalStatistics: {
+        regexp: /^> (\d+\.?\d*)%$/,
+        select: function (popularity) {
+            popularity = parseFloat(popularity);
+            var result = [];
+
+            for ( var version in browserslist.usage.global ) {
+                if ( browserslist.usage.global[version] > popularity ) {
+                    result.push(version);
+                }
+            }
+
+            return result;
+        }
+    },
+
+    countryStatistics: {
+        regexp: /^> (\d+\.?\d*)% in (\w\w)$/,
+        select: function (popularity, country) {
+            popularity = parseFloat(popularity);
+            country    = country.toUpperCase();
+            var result = [];
+
+            var usage = browserslist.usage[country];
+            if ( !usage ) {
+                usage = { };
+                var data = require('caniuse-db/region-usage-json/' + country);
+                for ( var i in data.data ) {
+                    fillUsage(usage, i, data.data[i]);
+                }
+                browserslist.usage[country] = usage;
+            }
+
+            for ( var version in usage ) {
+                if ( usage[version] > popularity ) {
+                    result.push(version);
+                }
+            }
+
+            return result;
+        }
+    },
+
+    versions: {
+        regexp: /^(\w+) (>=?|<=?)\s*([\d\.]+)/,
+        select: function (name, sign, version) {
+            var data = browserslist.byName(name);
+            version  = parseFloat(version);
+
+            var filter;
+            if ( sign == '>' ) {
+                filter = function (v) {
+                    return parseFloat(v) > version;
+                };
+            } else if ( sign == '>=' ) {
+                filter = function (v) {
+                    return parseFloat(v) >= version;
+                };
+            } else if ( sign == '<' ) {
+                filter = function (v) {
+                    return parseFloat(v) < version;
+                };
+            } else if ( sign == '<=' ) {
+                filter = function (v) {
+                    return parseFloat(v) <= version;
+                };
+            }
+
+            return data.released.filter(filter).map(function (v) {
+                return data.name + ' ' + v;
+            });
+        }
+    },
+
+    esr: {
+        regexp: /^(firefox|ff|fx) esr$/i,
+        select: function (versions) {
+            return ['firefox 31'];
+        }
+    },
+
+    direct: {
+        regexp: /^(\w+) ([\d\.]+)$/,
+        select: function (name, version) {
+            var data  = browserslist.byName(name);
+            var alias = normalizeVersion(data, version);
+            if ( alias ) {
+                version = alias;
+            } else {
+                if ( version.indexOf('.') == -1 ) {
+                    alias = version + '.0';
+                } else if ( /\.0$/.test(version) ) {
+                    alias = version.replace(/\.0$/, '');
+                }
+                alias = normalizeVersion(data, alias);
+                if ( alias ) {
+                    version = alias;
+                } else {
+                    throw 'Unknown version ' + version + ' of ' + name;
+                }
+            }
+
+            return [data.name + ' ' + version];
+        }
+    }
+
+};
+
+// Get and convert Can I Use data
+
+var normalize = function (versions) {
+    return versions.filter(function (version) {
+        return typeof(version) == 'string';
+    });
+};
+
+var fillUsage = function (result, name, data) {
+    for ( var i in data ) {
+        result[name + ' ' + i] = data[i];
+    }
+};
+
+for ( var name in caniuse ) {
+    browserslist.data[name] = {
+        name:     name,
+        versions: normalize(caniuse[name].versions),
+        released: normalize(caniuse[name].versions.slice(0, -3))
+    };
+    fillUsage(browserslist.usage.global, name, caniuse[name].usage_global);
+
+    browserslist.versionAliases[name] = { };
+    for ( var i = 0; i < caniuse[name].versions.length; i++ ) {
+        if ( !caniuse[name].versions[i] ) continue;
+        var full = caniuse[name].versions[i];
+
+        if ( full.indexOf('-') != -1 ) {
+            var interval = full.split('-');
+            for ( var j = 0; j < interval.length; j++ ) {
+                browserslist.versionAliases[name][ interval[j] ] = full;
+            }
+        }
+    }
+}
+
+module.exports = browserslist;

node_modules/autoprefixer-core/node_modules/browserslist/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "browserslist",
+  "version": "0.2.0",
+  "description": "Get browsers versions that matches given criterias like in Autoprefixer",
+  "keywords": [
+    "caniuse",
+    "browsers"
+  ],
+  "author": {
+    "name": "Andrey Sitnik",
+    "email": "andrey@sitnik.ru"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai/browserslist.git"
+  },
+  "dependencies": {
+    "caniuse-db": "^1.0.30000054"
+  },
+  "devDependencies": {
+    "jshint-stylish": "1.0.0",
+    "gulp-jshint": "1.9.0",
+    "gulp-mocha": "2.0.0",
+    "mocha": "2.1.0",
+    "chai": "1.10.0",
+    "gulp": "3.8.10"
+  },
+  "scripts": {
+    "test": "gulp"
+  },
+  "gitHead": "c6b2e8770f7dace8e2ba0642bcd85aa5c923579e",
+  "bugs": {
+    "url": "https://github.com/ai/browserslist/issues"
+  },
+  "homepage": "https://github.com/ai/browserslist",
+  "_id": "browserslist@0.2.0",
+  "_shasum": "e5b7cf311cccb70772cd22d4f61c7bb80523ecd2",
+  "_from": "browserslist@~0.2.0",
+  "_npmVersion": "2.1.18",
+  "_nodeVersion": "0.10.33",
+  "_npmUser": {
+    "name": "ai",
+    "email": "andrey@sitnik.ru"
+  },
+  "maintainers": [
+    {
+      "name": "ai",
+      "email": "andrey@sitnik.ru"
+    }
+  ],
+  "dist": {
+    "shasum": "e5b7cf311cccb70772cd22d4f61c7bb80523ecd2",
+    "tarball": "http://registry.npmjs.org/browserslist/-/browserslist-0.2.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/browserslist/-/browserslist-0.2.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/.npmignore

@@ -0,0 +1,8 @@
+.gitignore
+.gitattributes
+
+.travis.yml
+validator/
+
+Contributing.md
+sample-data.json

node_modules/autoprefixer-core/node_modules/caniuse-db/CONTRIBUTING.md

@@ -0,0 +1,87 @@
+# Contributing to the caniuse data
+
+## Filing issues
+
+Issues can be filed on existing **caniuse support data** or on **site functionality**. If you'd like to propose a new web technology feature to be added, please submit/vote for the issue on [Google Moderator](http://www.google.com/moderator/#15/e=ae425&t=ae425.40) rather than submitting an issue. This way features can be added based on the popularity of the feature.
+
+## Caniuse data
+
+The `features-json` directory includes JSON files for every feature found on [the caniuse.com website](http://caniuse.com/).
+Maintaining these files on GitHub allows anyone to update or contribute to the support data on the site.
+
+**Note:** when submitting a patch, don’t modify the minified `data.json` file in the root — that is done automatically. Only modify the contents of the `features-json` directory.
+
+### How it works
+
+The data on the site is stored in a database.
+This data is periodically exported to the JSON files on GitHub.
+Once a change or new file here has been approved, it is integrated back into the database
+and the subsequent export files should be the same as the imported ones.
+Not too confusing, I hope. :)
+
+### Supported changes
+
+Currently the following feature information can be modified:
+* **title** — Feature name (used for the title of the table)
+* **description** — Brief description of feature
+* **spec** — Spec URL
+* **status** — Spec status, one of the following:
+	* `ls` - WHATWG Living Standard
+	* `rec` - W3C Recommendation
+	* `pr` - W3C Proposed Recommendation
+	* `cr` - W3C Candidate Recommendation
+	* `wd` - W3C Working Draft
+	* `other` - Non-W3C, but reputable
+	* `unoff` - Unofficial or W3C "Note"
+* **links** — Array of "link" objects consisting of URL and short description of link
+* **bugs** — Array of "bug" objects consisting of a bug description
+* **categories** — Array of categories, any of the following:
+	* `HTML5`
+	* `CSS`
+	* `CSS2`
+	* `CSS3`
+	* `SVG`
+	* `PNG`
+	* `JS API`
+	* `Canvas`
+	* `DOM`
+	* `Other`
+* **stats** — The collection of support data for a given set of browsers/versions. Only the support value strings can be modified. Values are space-separated characters with these meanings, and must answer the question "*Can I use* the feature by default?":
+	* `y` - (**Y**)es, supported by default
+	* `a` - (**A**)lmost supported (aka Partial support)
+	* `n` - (**N**)o support, or disabled by default
+	* `p` - No support, but has (**P**)olyfill
+	* `u` - Support (**u**)nknown
+	* `x` - Requires prefi(**x**) to work
+	* `d` - (**D**)isabled by default (need to enable flag or something)
+	* `#n` - Where n is a number, starting with 1, corresponds to the **notes_by_num** note.  For example: `"42":"y #1"` means version 42 is supported by default and see note 1.
+* **notes** — Notes on feature support, often to explain what partial support refers to
+* **notes_by_num** - Map of numbers corresponding to notes. Used in conjection with the #n notation under **stats**. Each key should be a number (no hash), the value is the related note. For example: `"1": "Foo"`
+* **ucprefix** — Prefix should start with an uppercase letter
+* **parent** — ID of parent feature
+* **keywords** — Comma separated words that will match the feature in a search
+* **ie_id** — Comma separated IDs used by [status.modern.ie](http://status.modern.ie) - Each ID is the string in the feature's URL 
+* **chrome_id** — Comma separated IDs used by [chromestatus.com](http://chromestatus.com) - Each ID is the number in the feature's URL 
+* **shown** — Whether or not feature is ready to be shown on the site. This can be left as false if the support data or information for other fields is still being collected
+
+### Adding a feature
+
+To add a feature, simply add another JSON file, following the [example](/sample-data.json), to the `features-json` directory with the base file name as the feature ID (only alphanumeric characters and hyphens please). If you want to submit a feature but don't have all information available for it yet, make sure you set the "shown" flag to false.
+
+### Unsupported changes
+
+Currently it is not possible to:
+* Add a new browser or browser version (this will be made possible later)
+* Add a test for any given feature (should also come later)
+* Add any object properties not already defined above
+* Modify the **usage\_perc\_y** or **usage\_perc\_a** values (these values are generated)
+
+### Testing
+Make sure you have NodeJS installed on your system.
+
+Run
+
+`node validator/validate-jsons.js`
+
+If something is wrong, it will throw an error.
+Everything is ok otherwise.

node_modules/autoprefixer-core/node_modules/caniuse-db/README.md

@@ -0,0 +1,13 @@
+This repo contains raw data from the caniuse.com support tables. It serves two purposes:
+
+1. The ability for anyone interested to update or add to the support data on the site. If you are interested in this, please read the [CONTRIBUTING file](CONTRIBUTING.md).
+
+2. Access to the site's data for other projects. For this use the [data.json](data.json) file which includes all support data.
+
+The data in this repo is available for use under a CC BY 3.0 license (http://creativecommons.org/licenses/by/3.0/). For attribution just mention somewhere that the source is caniuse.com. While usage of the data for alternative tools, visualizations, etc. is encouraged, it is not permitted to use it directly to create another browser support website. If you have any questions about using the data for your project please contact me here: http://a.deveria.com/contact
+
+Thanks,
+
+Alexis Deveria
+<br>http://caniuse.com
+<br>http://a.deveria.com

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/ambient-light.json

@@ -0,0 +1,222 @@
+{
+  "title":"Ambient Light API",
+  "description":"Defines events that provide information about the ambient light level, as measured by a device's light sensor.",
+  "spec":"http://www.w3.org/TR/ambient-light/",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://aurelio.audero.it/demo/ambient-light-api-demo.html",
+      "title":"Demo"
+    },
+    {
+      "url":"http://modernweb.com/2014/05/27/introduction-to-the-ambient-light-api/",
+      "title":"Article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"n",
+      "42":"n",
+      "43":"n",
+      "44":"n"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"n"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"n"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"Firefox desktop supports this API only on Mac OS X. [Support for Windows 7 is in progress](https://bugzilla.mozilla.org/show_bug.cgi?id=754199)",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":11.62,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"ambientlightevents",
+  "chrome_id":"5298357018820608",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/apng.json

@@ -0,0 +1,226 @@
+{
+  "title":"Animated PNG (APNG)",
+  "description":"Like animated GIFs, but allowing 24-bit colors and alpha transparency",
+  "spec":"https://wiki.mozilla.org/APNG_Specification",
+  "status":"unoff",
+  "links":[
+    {
+      "url":"http://en.wikipedia.org/wiki/APNG",
+      "title":"Wikipedia"
+    },
+    {
+      "url":"https://github.com/davidmz/apng-canvas",
+      "title":"Polyfill using canvas"
+    },
+    {
+      "url":"https://chrome.google.com/webstore/detail/ehkepjiconegkhpodgoaeamnpckdbblp",
+      "title":"Chrome extension providing support"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "PNG"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"y",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"n",
+      "42":"n",
+      "43":"n",
+      "44":"n"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"y",
+      "10.0-10.1":"y",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"n"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"Where support for APNG is missing, only the first frame is displayed",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":19.44,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/atob-btoa.json

@@ -0,0 +1,226 @@
+{
+  "title":"Base64 encoding and decoding",
+  "description":"Utility functions for of encoding and decoding strings to and from base 64: window.atob() and window.btoa().",
+  "spec":"https://html.spec.whatwg.org/multipage/webappapis.html#atob",
+  "status":"ls",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa",
+      "title":"MDN article on btoa()"
+    },
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/API/Window.atob",
+      "title":"MDN article on atob()"
+    },
+    {
+      "url":"https://github.com/davidchambers/Base64.js",
+      "title":"Polyfill"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"y",
+      "3":"y",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"y",
+      "3.2":"y",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"u",
+      "10.0-10.1":"u",
+      "10.5":"u",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"y"
+    },
+    "android":{
+      "2.1":"y",
+      "2.2":"y",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"u",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":92.18,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"atob,btoa",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/audio-api.json

@@ -0,0 +1,230 @@
+{
+  "title":"Web Audio API",
+  "description":"High-level JavaScript API for processing and synthesizing audio",
+  "spec":"http://www.w3.org/TR/webaudio/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://github.com/corbanbrook/audionode.js",
+      "title":"Polyfill to support Web Audio API in Firefox"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/apis/webaudio",
+      "title":"WebPlatform Docs"
+    },
+    {
+      "url":"http://www.doboism.com/projects/webaudio-compatibility/",
+      "title":"Additional browser compatibility tests for specific features"
+    },
+    {
+      "url":"https://github.com/g200kg/WAAPISim",
+      "title":"Polyfill to enable Web Audio API through Firefox Audio Data api or flash"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"y x",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"Firefox versions < 25 support an alternative, deprecated audio API.\r\n\r\nChrome support [went through some changes](http://updates.html5rocks.com/2014/07/Web-Audio-Changes-in-m36) as of version 36.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":67.15,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"web-audio",
+  "ie_id":"webaudioapi",
+  "chrome_id":"6261718720184320",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/audio.json

@@ -0,0 +1,248 @@
+{
+  "title":"Audio element",
+  "description":"Method of playing sound on webpages (without requiring a plug-in).",
+  "spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#the-audio-element",
+  "status":"ls",
+  "links":[
+    {
+      "url":"http://html5doctor.com/native-audio-in-the-browser/",
+      "title":"HTML5 Doctor article"
+    },
+    {
+      "url":"https://dev.opera.com/articles/view/everything-you-need-to-know-about-html5-video-and-audio/",
+      "title":"Detailed article on video/audio elements"
+    },
+    {
+      "url":"http://www.jplayer.org/latest/demos/",
+      "title":"Demos of audio player that uses the audio element"
+    },
+    {
+      "url":"http://24ways.org/2010/the-state-of-html5-audio",
+      "title":"Detailed article on support"
+    },
+    {
+      "url":"http://textopia.org/androidsoundformats.html",
+      "title":"File format test page"
+    },
+    {
+      "url":"http://www.phoboslab.org/log/2011/03/the-state-of-html5-audio",
+      "title":"The State of HTML5 Audio"
+    },
+    {
+      "url":"https://raw.github.com/phiggins42/has.js/master/detect/audio.js#audio",
+      "title":"has.js test"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/html/elements/audio",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Volume is read-only on iOS."
+    }
+  ],
+  "categories":[
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"a",
+      "10.0-10.1":"a",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":91.12,
+  "usage_perc_a":0.03,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"<audio>",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/autofocus.json

@@ -0,0 +1,218 @@
+{
+  "title":"Autofocus attribute",
+  "description":"Allows a form field to be immediately focused on page load.",
+  "spec":"https://html.spec.whatwg.org/multipage/forms.html#autofocusing-a-form-control:-the-autofocus-attribute",
+  "status":"ls",
+  "links":[
+    {
+      "url":"http://davidwalsh.name/autofocus",
+      "title":"Article on autofocus"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"y",
+      "10.0-10.1":"y",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"While not supported in iOS Safari, it does work in iOS WebViews.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":77.94,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/background-attachment.json

@@ -0,0 +1,219 @@
+{
+  "title":"CSS background-attachment",
+  "description":"Method of defining how a background image is attached to a scrollable element. Values include `scroll` (default), `fixed` and `local`.",
+  "spec":"http://www.w3.org/TR/css3-background/#the-background-attachment",
+  "status":"cr",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/background-attachment",
+      "title":"MDN article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"a #1",
+      "6":"a #1",
+      "7":"a #1",
+      "8":"a #1",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"a #1",
+      "3":"a #1",
+      "3.5":"a #1",
+      "3.6":"a #1",
+      "4":"a #1",
+      "5":"a #1",
+      "6":"a #1",
+      "7":"a #1",
+      "8":"a #1",
+      "9":"a #1",
+      "10":"a #1",
+      "11":"a #1",
+      "12":"a #1",
+      "13":"a #1",
+      "14":"a #1",
+      "15":"a #1",
+      "16":"a #1",
+      "17":"a #1",
+      "18":"a #1",
+      "19":"a #1",
+      "20":"a #1",
+      "21":"a #1",
+      "22":"a #1",
+      "23":"a #1",
+      "24":"a #1",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"a #1",
+      "3.2":"a #1",
+      "4":"a #1",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"a #1",
+      "9.5-9.6":"a #1",
+      "10.0-10.1":"a #1",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"a #2",
+      "6.0-6.1":"a #2",
+      "7.0-7.1":"a #2",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"a #1",
+      "4.2-4.3":"a #1",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"a #2",
+      "10":"a #2"
+    },
+    "op_mob":{
+      "10":"u",
+      "11":"u",
+      "11.1":"u",
+      "11.5":"u",
+      "12":"u",
+      "12.1":"y",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"a #2"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"a #1"
+    }
+  },
+  "notes":"Most mobile devices have a delay in updating the background position after scrolling a page with `fixed` backgrounds.",
+  "notes_by_num":{
+    "1":"Partial support refers to supporting `fixed` but not `local`",
+    "2":"Partial support refers to supporting `local` but not `fixed`"
+  },
+  "usage_perc_y":67.77,
+  "usage_perc_a":22.47,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/background-img-opts.json

@@ -0,0 +1,233 @@
+{
+  "title":"CSS3 Background-image options",
+  "description":"New properties to affect background images, including background-clip, background-origin and background-size",
+  "spec":"http://www.w3.org/TR/css3-background/#backgrounds",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://www.standardista.com/css3/css3-background-properties",
+      "title":"Detailed compatibility tables and demos"
+    },
+    {
+      "url":"http://www.css3files.com/background/",
+      "title":"Information page"
+    },
+    {
+      "url":"https://github.com/louisremi/background-size-polyfill",
+      "title":"Polyfill for IE7-8"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"iOS Safari has buggy behavior with `background-size: cover;` on a page's body."
+    },
+    {
+      "description":"iOS Safari has buggy behavior with `background-size: cover;` + `background-attachment: fixed;`"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"a x",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"a #3",
+      "5":"a #3",
+      "6":"a #3",
+      "7":"a #3",
+      "8":"a #3",
+      "9":"a #3",
+      "10":"a #3",
+      "11":"a #3",
+      "12":"a #3",
+      "13":"a #3",
+      "14":"a #3",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"a #2 #3",
+      "3.2":"a #2 #3",
+      "4":"a #2 #3",
+      "5":"a #2 #3",
+      "5.1":"a #2 #3",
+      "6":"a #2 #3",
+      "6.1":"a #2 #3",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"a x",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"a",
+      "4.0-4.1":"a",
+      "4.2-4.3":"a",
+      "5.0-5.1":"a #3",
+      "6.0-6.1":"a",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"a #1"
+    },
+    "android":{
+      "2.1":"a x",
+      "2.2":"a x #3",
+      "2.3":"a x #3",
+      "3":"a #3",
+      "4":"a #3",
+      "4.1":"a #3",
+      "4.2-4.3":"a #3",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"Partial support in Opera Mini refers to not supporting background sizing or background attachments. However Opera Mini 7.5 supports background sizing (including cover and contain values).",
+    "2":"Partial support in Safari 6 refers to not supporting background sizing offset from edges syntax.",
+    "3":"Does not support `background-size` values in the `background` shorthand"
+  },
+  "usage_perc_y":87.16,
+  "usage_perc_a":6.81,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/battery-status.json

@@ -0,0 +1,222 @@
+{
+  "title":"Battery Status API",
+  "description":"Method to provide information about the battery status of the hosting device.",
+  "spec":"http://www.w3.org/TR/battery-status/",
+  "status":"cr",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/WebAPI/Battery_Status",
+      "title":"MDN Docs"
+    },
+    {
+      "url":"http://www.smartjava.org/examples/webapi-battery/",
+      "title":"Simple demo"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"a x #1",
+      "11":"a x #1",
+      "12":"a x #1",
+      "13":"a x #1",
+      "14":"a x #1",
+      "15":"a x #1",
+      "16":"a #1",
+      "17":"a #1",
+      "18":"a #1",
+      "19":"a #1",
+      "20":"a #1",
+      "21":"a #1",
+      "22":"a #1",
+      "23":"a #1",
+      "24":"a #1",
+      "25":"a #1",
+      "26":"a #1",
+      "27":"a #1",
+      "28":"a #1",
+      "29":"a #1",
+      "30":"a #1",
+      "31":"a #1",
+      "32":"a #1",
+      "33":"a #1",
+      "34":"a #1",
+      "35":"a #1",
+      "36":"a #1",
+      "37":"a #1",
+      "38":"a #1",
+      "39":"a #1"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n d",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"n"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"a #1"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"a #1"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"Partial support refers to support for the older specification's `navigator.battery` rather than `navigator.getBattery()` to access the `BatteryManager`."
+  },
+  "usage_perc_y":41.66,
+  "usage_perc_a":15.88,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"navigator.battery,navigator.getbattery,batterymanager",
+  "ie_id":"batterystatusapi",
+  "chrome_id":"4537134732017664",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/blobbuilder.json

@@ -0,0 +1,222 @@
+{
+  "title":"Blob constructing",
+  "description":"Construct Blobs (binary large objects) either using the BlobBuilder API (deprecated) or the Blob constructor.",
+  "spec":"http://www.w3.org/TR/file-writer-api/#the-blobbuilder-interface",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en/DOM/BlobBuilder",
+      "title":"MDN article on BlobBuilder"
+    },
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/DOM/Blob",
+      "title":"MDN article on Blobs"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"a x",
+      "7":"a x",
+      "8":"a x",
+      "9":"a x",
+      "10":"a x",
+      "11":"a x",
+      "12":"a x",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"a x",
+      "9":"a x",
+      "10":"a x",
+      "11":"a x",
+      "12":"a x",
+      "13":"a x",
+      "14":"a x",
+      "15":"a x",
+      "16":"a x",
+      "17":"a x",
+      "18":"a x",
+      "19":"a x",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"a x",
+      "4":"a x",
+      "4.1":"a x",
+      "4.2-4.3":"a x",
+      "4.4":"a x",
+      "4.4.3-4.4.4":"a x",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"a x"
+    }
+  },
+  "notes":"Partial support refers to only supporting the now deprecated BlobBuilder to create blobs.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":77.73,
+  "usage_perc_a":10.51,
+  "ucprefix":true,
+  "parent":"fileapi",
+  "keywords":"",
+  "ie_id":"blob",
+  "chrome_id":"5328783104016384",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/bloburls.json

@@ -0,0 +1,218 @@
+{
+  "title":"Blob URLs",
+  "description":"Method of creating URL handles to the specified File or Blob object.",
+  "spec":"http://www.w3.org/TR/FileAPI/#url",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en/DOM/window.URL.createObjectURL",
+      "title":"MDN article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"y x",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"y x",
+      "4.1":"y x",
+      "4.2-4.3":"y x",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":87.8,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"fileapi",
+  "keywords":"createobjecturl",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/border-image.json

@@ -0,0 +1,222 @@
+{
+  "title":"CSS3 Border images",
+  "description":"Method of using images for borders",
+  "spec":"http://www.w3.org/TR/css3-background/#the-border-image",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://www.css3files.com/border/",
+      "title":"Information page"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/properties/border-image",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"a x",
+      "3.6":"a x",
+      "4":"a x",
+      "5":"a x",
+      "6":"a x",
+      "7":"a x",
+      "8":"a x",
+      "9":"a x",
+      "10":"a x",
+      "11":"a x",
+      "12":"a x",
+      "13":"a x",
+      "14":"a x",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"a x",
+      "5":"a x",
+      "6":"a x",
+      "7":"a x",
+      "8":"a x",
+      "9":"a x",
+      "10":"a x",
+      "11":"a x",
+      "12":"a x",
+      "13":"a x",
+      "14":"a x",
+      "15":"y x",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"a x",
+      "3.2":"a x",
+      "4":"a x",
+      "5":"a x",
+      "5.1":"a x",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"a",
+      "10.6":"a",
+      "11":"a x",
+      "11.1":"a x",
+      "11.5":"a x",
+      "11.6":"a x",
+      "12":"a x",
+      "12.1":"a x",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"a x",
+      "4.0-4.1":"a x",
+      "4.2-4.3":"a x",
+      "5.0-5.1":"a x",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"a x"
+    },
+    "android":{
+      "2.1":"a x",
+      "2.2":"a x",
+      "2.3":"a x",
+      "3":"a x",
+      "4":"a x",
+      "4.1":"a x",
+      "4.2-4.3":"a x",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"a x",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"a x",
+      "11.1":"a x",
+      "11.5":"a x",
+      "12":"a x",
+      "12.1":"a x",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"Note that both the border-style and border-width must be specified for border-images to work according to spec, though older implementations may not have this requirement. Partial support refers to supporting the shorthand syntax, but not the individual properties (border-image-source, border-image-slice, etc). ",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":83.44,
+  "usage_perc_a":7.04,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/border-radius.json

@@ -0,0 +1,245 @@
+{
+  "title":"CSS3 Border-radius (rounded corners)",
+  "description":"Method of making the border corners round",
+  "spec":"http://www.w3.org/TR/css3-background/#the-border-radius",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://border-radius.com",
+      "title":"Border-radius CSS Generator"
+    },
+    {
+      "url":"http://muddledramblings.com/table-of-css3-border-radius-compliance",
+      "title":"Detailed compliance table"
+    },
+    {
+      "url":"http://www.css3files.com/border/#borderradius",
+      "title":"Information page"
+    },
+    {
+      "url":"http://css3pie.com/",
+      "title":"Polyfill which includes border-radius"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/properties/border-radius",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Safari does not apply `border-radius` correctly to image borders: http://stackoverflow.com/q/17202128"
+    },
+    {
+      "description":"Android Browser 2.3 does not support % value for `border-radius`."
+    },
+    {
+      "description":"Border-radius does not work on fieldset elements in IE9."
+    },
+    {
+      "description":"The stock browser on the Samsung Galaxy S4 with Android 4.2 does not support the `border-radius` shorthand property but does support the long-hand properties for each corner like `border-top-left-radius`."
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"a x",
+      "3":"y x",
+      "3.5":"y x",
+      "3.6":"y x",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"y x",
+      "3.2":"y x",
+      "4":"y x",
+      "5":"y",
+      "5.1":"y #1",
+      "6":"y #1",
+      "6.1":"y #1",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y x",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"y x",
+      "2.2":"y",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"Safari 6.1 and earlier did not apply `border-radius` correctly to image borders: http://stackoverflow.com/q/17202128"
+  },
+  "usage_perc_y":91.17,
+  "usage_perc_a":0.01,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"roundedcorners, border radius,-moz-border-radius",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/broadcastchannel.json

@@ -0,0 +1,218 @@
+{
+  "title":"BroadcastChannel",
+  "description":"BroadcastChannel allows scripts from the same origin but other browsing contexts (windows, workers) to send each other messages.",
+  "spec":"https://html.spec.whatwg.org/multipage/comms.html#broadcasting-to-other-browsing-contexts",
+  "status":"ls",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel",
+      "title":"MDN article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"n",
+      "42":"n",
+      "43":"n",
+      "44":"n"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"n"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"n"
+    },
+    "and_ff":{
+      "36":"n"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":0,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"broadcast,channel,messaging",
+  "ie_id":"",
+  "chrome_id":"4585496197988352",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/calc.json

@@ -0,0 +1,228 @@
+{
+  "title":"calc() as CSS unit value",
+  "description":"Method of allowing calculated values for length units, i.e. `width: calc(100% - 3em)`",
+  "spec":"http://www.w3.org/TR/css3-values/#calc",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://hacks.mozilla.org/2010/06/css3-calc/",
+      "title":"Mozilla Hacks article"
+    },
+    {
+      "url":"https://developer.mozilla.org/en/CSS/-moz-calc",
+      "title":"MDN article"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/functions/calc",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"IE10 crashes when a div with a property using `calc()` has a child with [same property with inherit](http://stackoverflow.com/questions/19423384/css-less-calc-method-is-crashing-my-ie10)."
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"a",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"y x",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"a",
+      "4.4.3-4.4.4":"a",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"Support can be somewhat emulated in older versions of IE using the non-standard `expression()` syntax. Partial support in IE9 refers to the browser crashing when used as a `background-position` value. Partial support in Android Browser 4.4 refers to the browser lacking the ability to multiply and divide values.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":77.73,
+  "usage_perc_a":5.56,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"csscalc",
+  "chrome_id":"5765241438732288",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/canvas-blending.json

@@ -0,0 +1,218 @@
+{
+  "title":"Canvas blend modes",
+  "description":"Method of defining the effect resulting from overlaying two layers on a Canvas element. ",
+  "spec":"http://www.w3.org/TR/compositing-1/#blending",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://blogs.adobe.com/webplatform/2013/01/28/blending-features-in-canvas/",
+      "title":"Blog post"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "Canvas"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":70.11,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"canvas",
+  "keywords":"",
+  "ie_id":"compositingandblendingincanvas2d",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/canvas-text.json

@@ -0,0 +1,231 @@
+{
+  "title":"Text API for Canvas",
+  "description":"Method of displaying text on Canvas elements",
+  "spec":"https://html.spec.whatwg.org/multipage/scripting.html#drawing-text-to-the-bitmap",
+  "status":"ls",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en/Drawing_text_using_a_canvas#Additional_examples",
+      "title":"Examples by Mozilla"
+    },
+    {
+      "url":"http://code.google.com/p/canvas-text/",
+      "title":"Support library"
+    },
+    {
+      "url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#canvas-text",
+      "title":"has.js test"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/apis/canvas/CanvasRenderingContext2D/fillText",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "Canvas",
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"p",
+      "3":"p",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"p",
+      "3.2":"p",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"p",
+      "9.5-9.6":"p",
+      "10.0-10.1":"p",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"y",
+      "2.2":"y",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"p",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":91.12,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"canvas",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/canvas.json

@@ -0,0 +1,241 @@
+{
+  "title":"Canvas (basic support)",
+  "description":"Method of generating fast, dynamic graphics using JavaScript.",
+  "spec":"https://html.spec.whatwg.org/multipage/scripting.html#the-canvas-element",
+  "status":"ls",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en/Canvas_tutorial",
+      "title":"Tutorial by Mozilla"
+    },
+    {
+      "url":"http://www.canvasdemos.com/",
+      "title":"Showcase site"
+    },
+    {
+      "url":"http://glimr.rubyforge.org/cake/canvas.html",
+      "title":"Animation kit "
+    },
+    {
+      "url":"http://diveintohtml5.info/canvas.html",
+      "title":"Another tutorial"
+    },
+    {
+      "url":"http://explorercanvas.googlecode.com/",
+      "title":"Implementation for Internet Explorer"
+    },
+    {
+      "url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#canvas",
+      "title":"has.js test"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"The Android browser does not support clipping on HTML5 canvas. See the bug filed here: http://code.google.com/p/android/issues/detail?id=21099"
+    }
+  ],
+  "categories":[
+    "Canvas",
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"y",
+      "3":"y",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"y",
+      "3.2":"y",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"y",
+      "9.5-9.6":"y",
+      "10.0-10.1":"y",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"a"
+    },
+    "android":{
+      "2.1":"a",
+      "2.2":"a",
+      "2.3":"a",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"Opera Mini supports the canvas element, but is unable to play animations or run other more complex applications. Android 2.x supports canvas except the toDataURL() function. See http://code.google.com/p/android/issues/detail?id=7901 Some (slow) workarounds are described here: http://stackoverflow.com/q/10488033/841830",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":91.1,
+  "usage_perc_a":2.95,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"canvas",
+  "chrome_id":"5100084685438976",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/channel-messaging.json

@@ -0,0 +1,218 @@
+{
+  "title":"Channel messaging",
+  "description":"Method for having two-way communication between browsing contexts (using MessageChannel)",
+  "spec":"http://www.w3.org/TR/webmessaging/#channel-messaging",
+  "status":"cr",
+  "links":[
+    {
+      "url":"https://dev.opera.com/articles/view/window-postmessage-messagechannel/#channel",
+      "title":"An Introduction to HTML5 web messaging"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n d #1",
+      "27":"n d #1",
+      "28":"n d #1",
+      "29":"n d #1",
+      "30":"n d #1",
+      "31":"n d #1",
+      "32":"n d #1",
+      "33":"n d #1",
+      "34":"n d #1",
+      "35":"n d #1",
+      "36":"n d #1",
+      "37":"n d #1",
+      "38":"n d #1",
+      "39":"n d #1"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"u",
+      "10.0-10.1":"u",
+      "10.5":"u",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"u",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"n"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"Supported in Firefox behind the `dom.messageChannel.enabled` flag. Reported to not work in web workers."
+  },
+  "usage_perc_y":74.4,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"x-doc-messaging",
+  "keywords":"",
+  "ie_id":"messagechannels",
+  "chrome_id":"6710044586409984",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/classlist.json

@@ -0,0 +1,241 @@
+{
+  "title":"classList (DOMTokenList )",
+  "description":"Method of easily manipulating classes on elements, using the DOMTokenList object.",
+  "spec":"http://www.w3.org/TR/dom/#dom-element-classlist",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://hacks.mozilla.org/2010/01/classlist-in-firefox-3-6/",
+      "title":"Mozilla Hacks article"
+    },
+    {
+      "url":"https://github.com/eligrey/classList.js",
+      "title":"Polyfill script"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/dom/Element/classList",
+      "title":"WebPlatform Docs"
+    },
+    {
+      "url":"http://www.sitepoint.com/exploring-classlist-api/",
+      "title":"SitePoint article"
+    },
+    {
+      "url":"http://aurelio.audero.it/demo/classlist-api-demo.html",
+      "title":"Demo using classList"
+    },
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/API/Element.classList",
+      "title":"MDN article"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"[Internet Explorer 11 doesn't support multiple tokens passed to the `add` function](https://connect.microsoft.com/IE/Feedback/Details/920755); only the first is used."
+    }
+  ],
+  "categories":[
+    "DOM",
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"p",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"p",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"p",
+      "3":"p",
+      "3.5":"p",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"p",
+      "5":"p",
+      "6":"p",
+      "7":"p",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"p",
+      "3.2":"p",
+      "4":"p",
+      "5":"p",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"p",
+      "9.5-9.6":"p",
+      "10.0-10.1":"p",
+      "10.5":"p",
+      "10.6":"p",
+      "11":"p",
+      "11.1":"p",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"p",
+      "4.0-4.1":"p",
+      "4.2-4.3":"p",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"p"
+    },
+    "android":{
+      "2.1":"p",
+      "2.2":"p",
+      "2.3":"p",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"p",
+      "11":"p",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":88.9,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/clipboard.json

@@ -0,0 +1,222 @@
+{
+  "title":"Clipboard API",
+  "description":"API to provide copy, cut and paste functionality using the OS clipboard.",
+  "spec":"http://www.w3.org/TR/clipboard-apis/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent",
+      "title":"MDN page on ClipboardEvent"
+    },
+    {
+      "url":"http://www.deluxeblogtips.com/2010/06/javascript-copy-to-clipboard.html",
+      "title":"Blog post on cross-browser usage"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"a #1",
+      "6":"a #1",
+      "7":"a #1",
+      "8":"a #1",
+      "9":"a #1",
+      "10":"a #1",
+      "11":"a #1",
+      "TP":"a #1"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"a",
+      "14":"a",
+      "15":"a",
+      "16":"a",
+      "17":"a",
+      "18":"a",
+      "19":"a",
+      "20":"a",
+      "21":"a",
+      "22":"a",
+      "23":"a",
+      "24":"a",
+      "25":"a",
+      "26":"a",
+      "27":"a",
+      "28":"a",
+      "29":"a",
+      "30":"a",
+      "31":"a",
+      "32":"a",
+      "33":"a",
+      "34":"a",
+      "35":"a",
+      "36":"a",
+      "37":"a",
+      "38":"a",
+      "39":"a",
+      "40":"a",
+      "41":"a",
+      "42":"a",
+      "43":"a",
+      "44":"a"
+    },
+    "safari":{
+      "3.1":"u",
+      "3.2":"u",
+      "4":"a",
+      "5":"a",
+      "5.1":"a",
+      "6":"a",
+      "6.1":"a",
+      "7":"a",
+      "7.1":"a",
+      "8":"a"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"a",
+      "17":"a",
+      "18":"a",
+      "19":"a",
+      "20":"a",
+      "21":"a",
+      "22":"a",
+      "23":"a",
+      "24":"a",
+      "25":"a",
+      "26":"a",
+      "27":"a",
+      "28":"a",
+      "29":"a"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"a",
+      "6.0-6.1":"a",
+      "7.0-7.1":"a",
+      "8":"a",
+      "8.1":"a"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"a",
+      "4.4.3-4.4.4":"a",
+      "37":"a"
+    },
+    "bb":{
+      "7":"n",
+      "10":"a"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"a"
+    },
+    "and_chr":{
+      "41":"a"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"Partial support in IE refers using [a non-standard method](http://msdn.microsoft.com/en-us/library/ie/ms535220%28v=vs.85%29.aspx) of interacting with the clipboard. For other browsers it refers to not supporting the ClipboardEvent constructor.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":11.62,
+  "usage_perc_a":74.26,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"cut,copy,paste,clipboarddata",
+  "ie_id":"clipboardapi",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/contenteditable.json

@@ -0,0 +1,238 @@
+{
+  "title":"contenteditable attribute (basic support)",
+  "description":"Method of making any HTML element editable.",
+  "spec":"https://html.spec.whatwg.org/multipage/interaction.html#contenteditable",
+  "status":"ls",
+  "links":[
+    {
+      "url":"http://html5demos.com/contenteditable",
+      "title":"Demo page"
+    },
+    {
+      "url":"https://blog.whatwg.org/the-road-to-html-5-contenteditable",
+      "title":"WHATWG blog post"
+    },
+    {
+      "url":"http://accessgarage.wordpress.com/2009/05/08/how-to-hack-your-app-to-make-contenteditable-work/",
+      "title":"Blog post on usage problems"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/html/attributes/contentEditable",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"In Chromium/Chrome contenteditable cannot be edited when nested into draggable (https://code.google.com/p/chromium/issues/detail?id=170139). Still not fixed in Chrome version 26.0.1384.2."
+    },
+    {
+      "description":"In Firefox when clicking on contenteditable nested into draggable, cursor is always positioned to the start of editable text. Still not fixed in version 18.0.1."
+    },
+    {
+      "description":"In Internet Explorer contenteditable cannot be applied to the TABLE, COL, COLGROUP, TBODY, TD, TFOOT, TH, THEAD, and TR elements directly, a content editable SPAN, or DIV element can be placed inside the individual table cells (See http://msdn.microsoft.com/en-us/library/ie/ms533690(v=vs.85).aspx)."
+    }
+  ],
+  "categories":[
+    "HTML5"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"a",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"y",
+      "3.2":"y",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"y",
+      "9.5-9.6":"y",
+      "10.0-10.1":"y",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"This support only refers to very basic editing capability, implementations vary significantly on how certain elements can be edited.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":94.18,
+  "usage_perc_a":0.04,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/contentsecuritypolicy.json

@@ -0,0 +1,231 @@
+{
+  "title":"Content Security Policy 1.0",
+  "description":"Mitigate cross-site scripting attacks by whitelisting allowed sources of script, style, and other resources.",
+  "spec":"http://www.w3.org/TR/CSP/",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://html5rocks.com/en/tutorials/security/content-security-policy/",
+      "title":"HTML5Rocks article"
+    },
+    {
+      "url":"http://content-security-policy.com/",
+      "title":"CSP Examples & Quick Reference"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Partial support in Internet Explorer 10-11 refers to the browser only supporting the 'sandbox' directive by using the `X-Content-Security-Policy` header."
+    },
+    {
+      "description":"Partial support in iOS Safari 5.0-5.1 refers to the browser recognizing the `X-Webkit-CSP` header but failing to handle complex cases correctly, often resulting in broken pages."
+    },
+    {
+      "description":"Chrome for iOS fails to render pages without a [connect-src 'self'](https://code.google.com/p/chromium/issues/detail?id=322497) policy."
+    }
+  ],
+  "categories":[
+    "Other"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"a #1",
+      "11":"a #1",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"y #1",
+      "5":"y #1",
+      "6":"y #1",
+      "7":"y #1",
+      "8":"y #1",
+      "9":"y #1",
+      "10":"y #1",
+      "11":"y #1",
+      "12":"y #1",
+      "13":"y #1",
+      "14":"y #1",
+      "15":"y #1",
+      "16":"y #1",
+      "17":"y #1",
+      "18":"y #1",
+      "19":"y #1",
+      "20":"y #1",
+      "21":"y #1",
+      "22":"y #1",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"y #2",
+      "15":"y #2",
+      "16":"y #2",
+      "17":"y #2",
+      "18":"y #2",
+      "19":"y #2",
+      "20":"y #2",
+      "21":"y #2",
+      "22":"y #2",
+      "23":"y #2",
+      "24":"y #2",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"a #2",
+      "6":"y #2",
+      "6.1":"y #2",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"a #2",
+      "6.0-6.1":"y #2",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y #2"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"a #1",
+      "11":"a #1"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"The standard HTTP header is `Content-Security-Policy` which is used unless otherwise noted.",
+  "notes_by_num":{
+    "1":"Supported through the `X-Content-Security-Policy` header",
+    "2":"Supported through the `X-Webkit-CSP` header"
+  },
+  "usage_perc_y":75.25,
+  "usage_perc_a":10.57,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"csp,security,header",
+  "ie_id":"contentsecuritypolicy",
+  "chrome_id":"5205088045891584",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/cors.json

@@ -0,0 +1,238 @@
+{
+  "title":"Cross-Origin Resource Sharing",
+  "description":"Method of performing XMLHttpRequests across domains",
+  "spec":"http://www.w3.org/TR/cors/",
+  "status":"rec",
+  "links":[
+    {
+      "url":"http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/",
+      "title":"Mozilla Hacks blog post"
+    },
+    {
+      "url":"http://msdn.microsoft.com/en-us/library/cc288060(VS.85).aspx",
+      "title":"Alternative implementation by IE8"
+    },
+    {
+      "url":"https://dev.opera.com/articles/view/dom-access-control-using-cross-origin-resource-sharing/",
+      "title":"DOM access using CORS"
+    },
+    {
+      "url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-cors-xhr",
+      "title":"has.js test"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"IE10+ does not send cookies when withCredential=true ([IE Bug #759587](https://connect.microsoft.com/IE/feedback/details/759587/ie10-doesnt-support-cookies-on-cross-origin-xmlhttprequest-withcredentials-true))"
+    },
+    {
+      "description":"IE10+ does not make a CORS request if port is the only difference ([IE Bug #781303](http://connect.microsoft.com/IE/feedback/details/781303))"
+    },
+    {
+      "description":"Android and some old versions of WebKit (that may be found in various webview implementations) do not support Access-Control-Expose-Headers: https://code.google.com/p/android/issues/detail?id=56726"
+    }
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"a",
+      "9":"a",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"y",
+      "2.2":"y",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"Supported somewhat in IE8 and IE9 using the XDomainRequest object (but has [limitations]( http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx))",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":89.24,
+  "usage_perc_a":4.72,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/cryptography.json

@@ -0,0 +1,229 @@
+{
+  "title":"Web Cryptography",
+  "description":"JavaScript API for performing basic cryptographic operations in web applications",
+  "spec":"http://www.w3.org/TR/WebCryptoAPI/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://www.slideshare.net/Channy/the-history-and-status-of-web-crypto-api",
+      "title":"The History and Status of Web Crypto API"
+    },
+    {
+      "url":"http://research.microsoft.com/en-us/projects/msrjscrypto/",
+      "title":"Microsoft Research JavaScript Cryptography Library"
+    },
+    {
+      "url":"http://bitwiseshiftleft.github.io/sjcl/",
+      "title":"Cross-browser cryptography library"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "JS API"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"p",
+      "10":"p",
+      "11":"a x #1",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"p",
+      "3":"p",
+      "3.5":"p",
+      "3.6":"p",
+      "4":"p",
+      "5":"p",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"p",
+      "10":"p",
+      "11":"p",
+      "12":"p",
+      "13":"p",
+      "14":"p",
+      "15":"p",
+      "16":"p",
+      "17":"p",
+      "18":"p",
+      "19":"p",
+      "20":"p",
+      "21":"p",
+      "22":"p",
+      "23":"p",
+      "24":"p",
+      "25":"p",
+      "26":"p",
+      "27":"p",
+      "28":"p",
+      "29":"p",
+      "30":"p",
+      "31":"p",
+      "32":"n d #2",
+      "33":"n d #2",
+      "34":"a #4",
+      "35":"a #4",
+      "36":"a #4",
+      "37":"a #4",
+      "38":"a #4",
+      "39":"a #4"
+    },
+    "chrome":{
+      "4":"p",
+      "5":"p",
+      "6":"p",
+      "7":"p",
+      "8":"p",
+      "9":"p",
+      "10":"p",
+      "11":"p",
+      "12":"p",
+      "13":"p",
+      "14":"p",
+      "15":"p",
+      "16":"p",
+      "17":"p",
+      "18":"p",
+      "19":"p",
+      "20":"p",
+      "21":"p",
+      "22":"p",
+      "23":"p",
+      "24":"p",
+      "25":"p",
+      "26":"p",
+      "27":"p",
+      "28":"p",
+      "29":"p",
+      "30":"p",
+      "31":"p",
+      "32":"p",
+      "33":"p",
+      "34":"p",
+      "35":"p",
+      "36":"p",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"p",
+      "3.2":"p",
+      "4":"p",
+      "5":"p",
+      "5.1":"p",
+      "6":"p",
+      "6.1":"p",
+      "7":"p",
+      "7.1":"y x #3",
+      "8":"y x #3"
+    },
+    "opera":{
+      "9":"p",
+      "9.5-9.6":"p",
+      "10.0-10.1":"p",
+      "10.5":"p",
+      "10.6":"p",
+      "11":"p",
+      "11.1":"p",
+      "11.5":"p",
+      "11.6":"p",
+      "12":"p",
+      "12.1":"p",
+      "15":"p",
+      "16":"p",
+      "17":"p",
+      "18":"p",
+      "19":"p",
+      "20":"p",
+      "21":"p",
+      "22":"p",
+      "23":"p",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"p",
+      "4.0-4.1":"p",
+      "4.2-4.3":"p",
+      "5.0-5.1":"p",
+      "6.0-6.1":"p",
+      "7.0-7.1":"p",
+      "8":"y x #3",
+      "8.1":"y x #3"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"p",
+      "2.2":"p",
+      "2.3":"p",
+      "3":"p",
+      "4":"p",
+      "4.1":"p",
+      "4.2-4.3":"p",
+      "4.4":"p",
+      "4.4.3-4.4.4":"p",
+      "37":"y"
+    },
+    "bb":{
+      "7":"p",
+      "10":"p"
+    },
+    "op_mob":{
+      "10":"p",
+      "11":"p",
+      "11.1":"p",
+      "11.5":"p",
+      "12":"p",
+      "12.1":"p",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"p"
+    },
+    "ie_mob":{
+      "10":"p",
+      "11":"a x #1"
+    },
+    "and_uc":{
+      "9.9":"p"
+    }
+  },
+  "notes":"Many browsers support the `[crypto.getRandomValues()](#feat=getrandomvalues)` method, but not actual cryptography functionality under `crypto.subtle`. \r\n\r\nFirefox also has support for [unofficial features](https://developer.mozilla.org/en-US/docs/JavaScript_crypto). \r\n\r\nIn Chrome the API is only usable over secure connections. ([corresponding bug](https://code.google.com/p/chromium/issues/detail?id=373032))",
+  "notes_by_num":{
+    "1":"Support in IE11 is based an older version of the specification. ",
+    "2":"Supported in Firefox behind the `dom.webcrypto.enabled` flag. ",
+    "3":"Supported in Safari using the `crypto.webkitSubtle` prefix",
+    "4":"Partial support in Firefox is [described here](https://docs.google.com/spreadsheet/ccc?key=0AiAcidBZRLxndE9LWEs2R1oxZ0xidUVoU3FQbFFobkE#gid=1)"
+  },
+  "usage_perc_y":49.85,
+  "usage_perc_a":18.49,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"subtle,subtlecrypto",
+  "ie_id":"webcryptoapi",
+  "chrome_id":"5030265697075200",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-animation.json

@@ -0,0 +1,234 @@
+{
+  "title":"CSS3 Animation",
+  "description":"Complex method of animating certain properties of an element",
+  "spec":"http://www.w3.org/TR/css3-animations/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://robertnyman.com/2010/05/06/css3-animations/",
+      "title":"Blog post on usage"
+    },
+    {
+      "url":"http://www.css3files.com/animation/",
+      "title":"Information page"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/properties/animations",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"'animation-fill-mode' property is not supported in Android browser below 2.3."
+    },
+    {
+      "description":"iOS 6.1 and below do not support animation on pseudo-elements."
+    },
+    {
+      "description":"@keyframes not supported in an inline or scoped stylesheet in Firefox (bug 830056)"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x",
+      "40":"y x",
+      "41":"y x",
+      "42":"y x",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"y x",
+      "5":"y x",
+      "5.1":"y x",
+      "6":"y x",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"y x",
+      "12.1":"y",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x"
+    },
+    "ios_saf":{
+      "3.2":"y x",
+      "4.0-4.1":"y x",
+      "4.2-4.3":"y x",
+      "5.0-5.1":"y x",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"a x",
+      "2.2":"a x",
+      "2.3":"a x",
+      "3":"a x",
+      "4":"y x",
+      "4.1":"y x",
+      "4.2-4.3":"y x",
+      "4.4":"y x",
+      "4.4.3-4.4.4":"y x",
+      "37":"y x"
+    },
+    "bb":{
+      "7":"y x",
+      "10":"y x"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"y",
+      "24":"y x"
+    },
+    "and_chr":{
+      "41":"y x"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"Partial support in Android browser refers to buggy behavior in different scenarios.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":88.99,
+  "usage_perc_a":0.12,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"animations,css-animations,keyframe,keyframes",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-appearance.json

@@ -0,0 +1,218 @@
+{
+  "title":"CSS Appearance",
+  "description":"The `appearance` property defines how elements (particularly form controls) appear by default. By setting the value to `none` the default appearance can be entirely redefined using other CSS properties.",
+  "spec":"http://wiki.csswg.org/spec/css4-ui#appearance",
+  "status":"unoff",
+  "links":[
+    {
+      "url":"http://css-tricks.com/almanac/properties/a/appearance/",
+      "title":"CSS Tricks article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"y x",
+      "3":"y x",
+      "3.5":"y x",
+      "3.6":"y x",
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x",
+      "40":"y x",
+      "41":"y x",
+      "42":"y x",
+      "43":"y x",
+      "44":"y x"
+    },
+    "safari":{
+      "3.1":"y x",
+      "3.2":"y x",
+      "4":"y x",
+      "5":"y x",
+      "5.1":"y x",
+      "6":"y x",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x"
+    },
+    "ios_saf":{
+      "3.2":"y x",
+      "4.0-4.1":"y x",
+      "4.2-4.3":"y x",
+      "5.0-5.1":"y x",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"y x",
+      "2.2":"y x",
+      "2.3":"y x",
+      "3":"y x",
+      "4":"y x",
+      "4.1":"y x",
+      "4.2-4.3":"y x",
+      "4.4":"y x",
+      "4.4.3-4.4.4":"y x",
+      "37":"y x"
+    },
+    "bb":{
+      "7":"y x",
+      "10":"y x"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y x"
+    },
+    "and_chr":{
+      "41":"y x"
+    },
+    "and_ff":{
+      "36":"y x"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"a #1"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"The `appearance` property currently does not appear in any CSS specification so there is no specifically correct usage.",
+  "notes_by_num":{
+    "1":"`-webkit-appearance` with value `none` is supported on IE11 Mobile for phones with \"[Windows Phone 8.1 Update](http://blogs.msdn.com/b/ie/archive/2014/07/31/the-mobile-web-should-just-work-for-everyone.aspx)\""
+  },
+  "usage_perc_y":78.87,
+  "usage_perc_a":0.48,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-at-counter-style.json

@@ -0,0 +1,224 @@
+{
+  "title":"CSS Counter Styles",
+  "description":"The @counter-style CSS at-rule allows the author to define their own counter styles. The earlier versions of CSS defined a set of useful counter styles based on usage patterns. While the later versions attempted to add more styles to the list to support the needs of world wide typography, it still wasn't adequate. The @counter-style at-rule addresses this shortcoming in an open-ended manner, by allowing authors to define their own counter styles when the pre-defined styles aren't fitting their needs. A @counter-style rule defines how to convert a counter value into a string representation.",
+  "spec":"http://dev.w3.org/csswg/css-counter-styles/",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://slides.upsuper.org/files/APgTVbyRhasM0QgF.pdf",
+      "title":"Slides(Chinese)"
+    },
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/@counter-style",
+      "title":"MDN article"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"https://bugzilla.mozilla.org/show_bug.cgi?id=843718"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"a",
+      "34":"a",
+      "35":"a",
+      "36":"a",
+      "37":"a",
+      "38":"a",
+      "39":"a"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"n",
+      "42":"n",
+      "43":"n",
+      "44":"n"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"n"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"n"
+    },
+    "and_ff":{
+      "36":"a"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":0,
+  "usage_perc_a":10.3,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"css @counter-style, list-style",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":false
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-background-offsets.json

@@ -0,0 +1,224 @@
+{
+  "title":"CSS background-position edge offsets",
+  "description":"Allows CSS background images to be positioned relative to the specified edge using the 3 to 4 value syntax. For example: `background-position: right 5px bottom 5px;` for positioning 5px from the bottom-right corner.",
+  "spec":"http://www.w3.org/TR/css3-background/#background-position",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/background-position",
+      "title":"MDN article on background-position"
+    },
+    {
+      "url":"http://briantree.se/quick-tip-06-use-four-value-syntax-properly-position-background-images/",
+      "title":"Basic information"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Safari 8 [has a bug](https://discussions.apple.com/thread/6679022) with bottom-positioned values `background-attachment: fixed;`"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"y"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":85.49,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"4 value syntax",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-backgroundblendmode.json

@@ -0,0 +1,226 @@
+{
+  "title":"CSS background-blend-mode",
+  "description":"Allows blending between CSS background images, gradients, and colors.",
+  "spec":"http://www.w3.org/TR/compositing-1/#background-blend-mode",
+  "status":"cr",
+  "links":[
+    {
+      "url":"http://codepen.io/bennettfeely/pen/rxoAc",
+      "title":"codepen example"
+    },
+    {
+      "url":"https://medium.com/web-design-technique/6b51bf53743a",
+      "title":"Blog post"
+    },
+    {
+      "url":"http://bennettfeely.com/gradients",
+      "title":"Demo"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":62.06,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"css blend modes,css blending modes,blending,multiply,screen,background",
+  "ie_id":"",
+  "chrome_id":"5768037999312896",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-boxdecorationbreak.json

@@ -0,0 +1,222 @@
+{
+  "title":"CSS box-decoration-break",
+  "description":"Controls whether the box's margins, borders, padding, and other decorations wrap the broken edges of the box fragments (when the box is split by a break (page/column/region/line).",
+  "spec":"http://www.w3.org/TR/css3-break/#break-decoration",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/box-decoration-break",
+      "title":"MDN article"
+    },
+    {
+      "url":"http://jsbin.com/xojoro/edit?css,output",
+      "title":"Demo of effect on box border"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x",
+      "40":"y x",
+      "41":"y x",
+      "42":"y x",
+      "43":"y x",
+      "44":"y x"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"u",
+      "9.5-9.6":"u",
+      "10.0-10.1":"u",
+      "10.5":"u",
+      "10.6":"u",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"y"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y x",
+      "4.4.3-4.4.4":"y x",
+      "37":"y x"
+    },
+    "bb":{
+      "7":"u",
+      "10":"y x"
+    },
+    "op_mob":{
+      "10":"u",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y x"
+    },
+    "and_chr":{
+      "41":"y x"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":72.56,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"box-decoration,box decoration,break",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-boxshadow.json

@@ -0,0 +1,236 @@
+{
+  "title":"CSS3 Box-shadow",
+  "description":"Method of displaying an inner or outer shadow effect to elements",
+  "spec":"http://www.w3.org/TR/css3-background/#box-shadow",
+  "status":"cr",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/En/CSS/-moz-box-shadow",
+      "title":"MDN article"
+    },
+    {
+      "url":"http://westciv.com/tools/boxshadows/index.html",
+      "title":"Live editor"
+    },
+    {
+      "url":"http://tests.themasta.com/blogstuff/boxshadowdemo.html",
+      "title":"Demo of various effects"
+    },
+    {
+      "url":"http://www.css3files.com/shadow/",
+      "title":"Information page"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/properties/box-shadow",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Safari 6, iOS 6 and Android 2.3 default browser don't work with a 0px value for \"blur-radius\".\r\ne.g. `-webkit-box-shadow: 5px 1px 0px 1px #f04e29;`\r\ndoesn't work, but\r\n`-webkit-box-shadow: 5px 1px 1px 1px #f04e29`\r\ndoes."
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"y x",
+      "3.6":"y x",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"a x",
+      "3.2":"a x",
+      "4":"a x",
+      "5":"y x",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"a x",
+      "4.0-4.1":"y x",
+      "4.2-4.3":"y x",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"a x",
+      "2.2":"a x",
+      "2.3":"a x",
+      "3":"a x",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y x",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"Can be partially emulated in older IE versions using the non-standard \"shadow\" filter. Partial support in Safari, iOS Safari and Android Browser refers to missing \"inset\" and blur radius value support.",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":90.94,
+  "usage_perc_a":0.19,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"box-shadows,boxshadows,box shadow,shaow",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-canvas.json

@@ -0,0 +1,218 @@
+{
+  "title":"CSS Canvas Drawings",
+  "description":"Method of using HTML5 Canvas as a background image. Not currently part of any specification.",
+  "spec":"http://webkit.org/blog/176/css-canvas-drawing/",
+  "status":"unoff",
+  "links":[
+    {
+      "url":"http://webkit.org/blog/176/css-canvas-drawing/",
+      "title":"Webkit blog post"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"u",
+      "38":"u",
+      "39":"u"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x",
+      "40":"y x",
+      "41":"y x",
+      "42":"y x",
+      "43":"y x",
+      "44":"y x"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"y x",
+      "5":"y x",
+      "5.1":"y x",
+      "6":"y x",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x"
+    },
+    "ios_saf":{
+      "3.2":"y x",
+      "4.0-4.1":"y x",
+      "4.2-4.3":"y x",
+      "5.0-5.1":"y x",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"y x",
+      "2.2":"y x",
+      "2.3":"y x",
+      "3":"y x",
+      "4":"y x",
+      "4.1":"y x",
+      "4.2-4.3":"y x",
+      "4.4":"y x",
+      "4.4.3-4.4.4":"y x",
+      "37":"y x"
+    },
+    "bb":{
+      "7":"y x",
+      "10":"y x"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y x"
+    },
+    "and_chr":{
+      "41":"y x"
+    },
+    "and_ff":{
+      "36":"n"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"A similar effect can be achieved in Firefox 4+ using the -moz-element() background property",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":66.53,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-clip-path.json

@@ -0,0 +1,221 @@
+{
+  "title":"CSS clip-path property",
+  "description":"Method of defining the visible region of an element using SVG or a shape definition.",
+  "spec":"http://www.w3.org/TR/css-masking-1/#the-clip-path",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://css-tricks.com/almanac/properties/c/clip/",
+      "title":"CSS Tricks article"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Chrome has an issue with [clip-paths and backface-visibility with 3D transforms](https://code.google.com/p/chromium/issues/detail?id=350724)"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"a #1",
+      "3.6":"a #1",
+      "4":"a #1",
+      "5":"a #1",
+      "6":"a #1",
+      "7":"a #1",
+      "8":"a #1",
+      "9":"a #1",
+      "10":"a #1",
+      "11":"a #1",
+      "12":"a #1",
+      "13":"a #1",
+      "14":"a #1",
+      "15":"a #1",
+      "16":"a #1",
+      "17":"a #1",
+      "18":"a #1",
+      "19":"a #1",
+      "20":"a #1",
+      "21":"a #1",
+      "22":"a #1",
+      "23":"a #1",
+      "24":"a #1",
+      "25":"a #1",
+      "26":"a #1",
+      "27":"a #1",
+      "28":"a #1",
+      "29":"a #1",
+      "30":"a #1",
+      "31":"a #1",
+      "32":"a #1",
+      "33":"a #1",
+      "34":"a #1",
+      "35":"a #1",
+      "36":"a #1",
+      "37":"a #1",
+      "38":"a #1",
+      "39":"a #1"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"a x #2",
+      "25":"a x #2",
+      "26":"a x #2",
+      "27":"a x #2",
+      "28":"a x #2",
+      "29":"a x #2",
+      "30":"a x #2",
+      "31":"a x #2",
+      "32":"a x #2",
+      "33":"a x #2",
+      "34":"a x #2",
+      "35":"a x #2",
+      "36":"a x #2",
+      "37":"a x #2",
+      "38":"a x #2",
+      "39":"a x #2",
+      "40":"a x #2",
+      "41":"a x #2",
+      "42":"a x #2",
+      "43":"a x #2",
+      "44":"a x #2"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"a x #2",
+      "7.1":"a x #2",
+      "8":"a x #2"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"a x #2",
+      "16":"a x #2",
+      "17":"a x #2",
+      "18":"a x #2",
+      "19":"a x #2",
+      "20":"a x #2",
+      "21":"a x #2",
+      "22":"a x #2",
+      "23":"a x #2",
+      "24":"a x #2",
+      "25":"a x #2",
+      "26":"a x #2",
+      "27":"a x #2",
+      "28":"a x #2",
+      "29":"a x #2"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"a x #2",
+      "8":"a x #2",
+      "8.1":"a x #2"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"a x #2",
+      "4.4.3-4.4.4":"a x #2",
+      "37":"a x #2"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"a x #2"
+    },
+    "and_chr":{
+      "41":"a x #2"
+    },
+    "and_ff":{
+      "36":"a #1"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"Partial support refers to only supporting the `url()` syntax.",
+    "2":"Partial support refers to supporting shapes and the `url(#foo)` syntax for inline SVG, but not shapes in external SVGs."
+  },
+  "usage_perc_y":0,
+  "usage_perc_a":70.75,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-counters.json

@@ -0,0 +1,226 @@
+{
+  "title":"CSS Counters",
+  "description":"Method of controlling number values in generated content, using the counter-reset and counter-increment properties.",
+  "spec":"http://www.w3.org/TR/CSS21/generate.html#counters",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://onwebdev.blogspot.com/2012/02/css-counters-tutorial.html",
+      "title":"Tutorial and information"
+    },
+    {
+      "url":"https://developer.mozilla.org/en/CSS_Counters",
+      "title":"MDN article"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/properties/counter-reset",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS2"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"y",
+      "3":"y",
+      "3.5":"y",
+      "3.6":"y",
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"y",
+      "5":"y",
+      "6":"y",
+      "7":"y",
+      "8":"y",
+      "9":"y",
+      "10":"y",
+      "11":"y",
+      "12":"y",
+      "13":"y",
+      "14":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"y",
+      "3.2":"y",
+      "4":"y",
+      "5":"y",
+      "5.1":"y",
+      "6":"y",
+      "6.1":"y",
+      "7":"y",
+      "7.1":"y",
+      "8":"y"
+    },
+    "opera":{
+      "9":"y",
+      "9.5-9.6":"y",
+      "10.0-10.1":"y",
+      "10.5":"y",
+      "10.6":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "11.6":"y",
+      "12":"y",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"y",
+      "4.0-4.1":"y",
+      "4.2-4.3":"y",
+      "5.0-5.1":"y",
+      "6.0-6.1":"y",
+      "7.0-7.1":"y",
+      "8":"y",
+      "8.1":"y"
+    },
+    "op_mini":{
+      "5.0-8.0":"y"
+    },
+    "android":{
+      "2.1":"y",
+      "2.2":"y",
+      "2.3":"y",
+      "3":"y",
+      "4":"y",
+      "4.1":"y",
+      "4.2-4.3":"y",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"y",
+      "10":"y"
+    },
+    "op_mob":{
+      "10":"y",
+      "11":"y",
+      "11.1":"y",
+      "11.5":"y",
+      "12":"y",
+      "12.1":"y",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"y",
+      "11":"y"
+    },
+    "and_uc":{
+      "9.9":"y"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":96.95,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-crisp-edges.json

@@ -0,0 +1,228 @@
+{
+  "title":"Crisp edges/pixelated images",
+  "description":"Forces images to be scaled with an algorithm that preserves contrast and edges in the image, without smoothing colors or introduce blur. This is intended for images such as pixel art. Official values that accomplish this for the `image-rendering` property are `crisp-edges` and `pixelated`.",
+  "spec":"http://dev.w3.org/csswg/css-images-3/#valdef-image-rendering-crisp-edges",
+  "status":"unoff",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering",
+      "title":"MDN article"
+    },
+    {
+      "url":"http://updates.html5rocks.com/2015/01/pixelated",
+      "title":"HTML5Rocks article"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"`image-rendering:-webkit-optimize-contrast;` and `-ms-interpolation-mode:nearest-neighbor` do not affect CSS images."
+    }
+  ],
+  "categories":[
+    "CSS",
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"a x #2",
+      "8":"a x #2",
+      "9":"a x #2",
+      "10":"a x #2",
+      "11":"a x #2",
+      "TP":"a x #2"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"y x #3",
+      "4":"y x #3",
+      "5":"y x #3",
+      "6":"y x #3",
+      "7":"y x #3",
+      "8":"y x #3",
+      "9":"y x #3",
+      "10":"y x #3",
+      "11":"y x #3",
+      "12":"y x #3",
+      "13":"y x #3",
+      "14":"y x #3",
+      "15":"y x #3",
+      "16":"y x #3",
+      "17":"y x #3",
+      "18":"y x #3",
+      "19":"y x #3",
+      "20":"y x #3",
+      "21":"y x #3",
+      "22":"y x #3",
+      "23":"y x #3",
+      "24":"y x #3",
+      "25":"y x #3",
+      "26":"y x #3",
+      "27":"y x #3",
+      "28":"y x #3",
+      "29":"y x #3",
+      "30":"y x #3",
+      "31":"y x #3",
+      "32":"y x #3",
+      "33":"y x #3",
+      "34":"y x #3",
+      "35":"y x #3",
+      "36":"y x #3",
+      "37":"y x #3",
+      "38":"y x #3",
+      "39":"y x #3"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"y #4",
+      "42":"y #4",
+      "43":"y #4",
+      "44":"y #4"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"a x #1",
+      "6.1":"y x #3",
+      "7":"y x #3",
+      "7.1":"y x #3",
+      "8":"y x #3"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"y x #3",
+      "12":"y x #3",
+      "12.1":"y x #3",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"y #4",
+      "29":"y #4"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"a x #1",
+      "6.0-6.1":"a x #1",
+      "7.0-7.1":"y x #3",
+      "8":"y x #3",
+      "8.1":"y x #3"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"a x #1"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"y x #3",
+      "12.1":"y x #3",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"y #4"
+    },
+    "and_ff":{
+      "36":"y x #3"
+    },
+    "ie_mob":{
+      "10":"a x #2",
+      "11":"a x #2"
+    },
+    "and_uc":{
+      "9.9":"a x #1"
+    }
+  },
+  "notes":"Note that prefixes apply to the value (e.g. `-moz-crisp-edges`), not the `image-rendering` property.",
+  "notes_by_num":{
+    "1":"Supported using the non-standard value `-webkit-optimize-contrast`",
+    "2":"Internet Explorer accomplishes support using the non-standard declaration `-ms-interpolation-mode: nearest-neighbor`",
+    "3":"Supports the `crisp-edges` value, but not `pixelated`.",
+    "4":"Supports the `pixelated` value, but not `crisp-edges`."
+  },
+  "usage_perc_y":33.02,
+  "usage_perc_a":19.1,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"image-rendering,crisp-edges",
+  "ie_id":"",
+  "chrome_id":"5118058116939776",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-deviceadaptation.json

@@ -0,0 +1,223 @@
+{
+  "title":"CSS Device Adaptation",
+  "description":"A standard way to override the size of viewport in web page, standardizing and replacing Apple's own popular <meta> viewport implementation.",
+  "spec":"http://www.w3.org/TR/css-device-adapt/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"https://dev.opera.com/articles/view/an-introduction-to-meta-viewport-and-viewport/",
+      "title":"Introduction to meta viewport and @viewport in Opera Mobile"
+    },
+    {
+      "url":"http://msdn.microsoft.com/en-us/library/ie/hh708740(v=vs.85).aspx",
+      "title":"Device adaptation in Internet Explorer 10"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"a x #1",
+      "11":"a x #1",
+      "TP":"a x #1"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n",
+      "30":"n",
+      "31":"n",
+      "32":"n",
+      "33":"n",
+      "34":"n",
+      "35":"n",
+      "36":"n",
+      "37":"n",
+      "38":"n",
+      "39":"n",
+      "40":"n",
+      "41":"n",
+      "42":"n",
+      "43":"n",
+      "44":"n"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"u",
+      "7":"u",
+      "7.1":"u",
+      "8":"u"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"n",
+      "29":"n"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"a x #2"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"n",
+      "4.4.3-4.4.4":"n",
+      "37":"n"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"a x #2",
+      "11.1":"a x #2",
+      "11.5":"a x #2",
+      "12":"a x #2",
+      "12.1":"a x #2",
+      "24":"n"
+    },
+    "and_chr":{
+      "41":"n"
+    },
+    "and_ff":{
+      "36":"n"
+    },
+    "ie_mob":{
+      "10":"a x #1",
+      "11":"a x #1"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"",
+  "notes_by_num":{
+    "1":"IE only supports the 'width' and 'height' properties.",
+    "2":"Opera Mobile and Opera Mini only support the 'orientation' property."
+  },
+  "usage_perc_y":0,
+  "usage_perc_a":13.02,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"viewport",
+  "ie_id":"",
+  "chrome_id":"",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-featurequeries.json

@@ -0,0 +1,232 @@
+{
+  "title":"CSS Feature Queries",
+  "description":"CSS Feature Queries allow authors to condition rules based on whether particular property declarations are supported in CSS using the @supports at rule.",
+  "spec":"http://www.w3.org/TR/css3-conditional/#at-supports",
+  "status":"cr",
+  "links":[
+    {
+      "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/@supports",
+      "title":"MDN Article"
+    },
+    {
+      "url":"http://mcc.id.au/blog/2012/08/supports",
+      "title":"@supports in Firefox"
+    },
+    {
+      "url":"http://dabblet.com/gist/3895764",
+      "title":"Test case"
+    },
+    {
+      "url":"http://docs.webplatform.org/wiki/css/atrules/@supports",
+      "title":"WebPlatform Docs"
+    }
+  ],
+  "bugs":[
+    {
+      "description":"Using @supports on Chrome 28-29 and Opera 15-16 breaks following :not selectors. [crbug.com/257695](http://crbug.com/257695)"
+    }
+  ],
+  "categories":[
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"y"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"n",
+      "19":"n",
+      "20":"n",
+      "21":"n",
+      "22":"n",
+      "23":"n",
+      "24":"n",
+      "25":"n",
+      "26":"n",
+      "27":"n",
+      "28":"y",
+      "29":"y",
+      "30":"y",
+      "31":"y",
+      "32":"y",
+      "33":"y",
+      "34":"y",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y",
+      "40":"y",
+      "41":"y",
+      "42":"y",
+      "43":"y",
+      "44":"y"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"n",
+      "6.1":"n",
+      "7":"n",
+      "7.1":"n",
+      "8":"n"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"y",
+      "15":"y",
+      "16":"y",
+      "17":"y",
+      "18":"y",
+      "19":"y",
+      "20":"y",
+      "21":"y",
+      "22":"y",
+      "23":"y",
+      "24":"y",
+      "25":"y",
+      "26":"y",
+      "27":"y",
+      "28":"y",
+      "29":"y"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"n",
+      "7.0-7.1":"n",
+      "8":"n",
+      "8.1":"n"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y",
+      "4.4.3-4.4.4":"y",
+      "37":"y"
+    },
+    "bb":{
+      "7":"n",
+      "10":"n"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y"
+    },
+    "and_chr":{
+      "41":"y"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"n"
+    }
+  },
+  "notes":"See also the [CSS.supports() DOM API](#feat=css-supports-api)",
+  "notes_by_num":{
+    
+  },
+  "usage_perc_y":60.81,
+  "usage_perc_a":0,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"supports,conditional",
+  "ie_id":"conditionalrules",
+  "chrome_id":"4993981813358592",
+  "shown":true
+}

node_modules/autoprefixer-core/node_modules/caniuse-db/features-json/css-filters.json

@@ -0,0 +1,231 @@
+{
+  "title":"CSS Filter Effects",
+  "description":"Method of applying filter effects (like blur, grayscale, brightness, contrast and hue) to elements, previously only possible by using SVG.",
+  "spec":"http://www.w3.org/TR/filter-effects/",
+  "status":"wd",
+  "links":[
+    {
+      "url":"http://html5-demos.appspot.com/static/css/filters/index.html",
+      "title":"Demo file for WebKit browsers"
+    },
+    {
+      "url":"http://www.html5rocks.com/en/tutorials/filters/understanding-css/",
+      "title":"HTML5Rocks article"
+    },
+    {
+      "url":"http://dl.dropbox.com/u/3260327/angular/CSS3ImageManipulation.html",
+      "title":"Filter editor"
+    },
+    {
+      "url":"http://bennettfeely.com/filters/",
+      "title":"Filter Playground"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS",
+    "CSS3"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "TP":"n"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"a",
+      "4":"a",
+      "5":"a",
+      "6":"a",
+      "7":"a",
+      "8":"a",
+      "9":"a",
+      "10":"a",
+      "11":"a",
+      "12":"a",
+      "13":"a",
+      "14":"a",
+      "15":"a",
+      "16":"a",
+      "17":"a",
+      "18":"a",
+      "19":"a",
+      "20":"a",
+      "21":"a",
+      "22":"a",
+      "23":"a",
+      "24":"a",
+      "25":"a",
+      "26":"a",
+      "27":"a",
+      "28":"a",
+      "29":"a",
+      "30":"a",
+      "31":"a",
+      "32":"a",
+      "33":"a",
+      "34":"a d #1",
+      "35":"y",
+      "36":"y",
+      "37":"y",
+      "38":"y",
+      "39":"y"
+    },
+    "chrome":{
+      "4":"n",
+      "5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"n",
+      "11":"n",
+      "12":"n",
+      "13":"n",
+      "14":"n",
+      "15":"n",
+      "16":"n",
+      "17":"n",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x",
+      "33":"y x",
+      "34":"y x",
+      "35":"y x",
+      "36":"y x",
+      "37":"y x",
+      "38":"y x",
+      "39":"y x",
+      "40":"y x",
+      "41":"y x",
+      "42":"y x",
+      "43":"y x",
+      "44":"y x"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"n",
+      "5.1":"n",
+      "6":"y x",
+      "6.1":"y x",
+      "7":"y x",
+      "7.1":"y x",
+      "8":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"n",
+      "5.0-5.1":"n",
+      "6.0-6.1":"y x",
+      "7.0-7.1":"y x",
+      "8":"y x",
+      "8.1":"y x"
+    },
+    "op_mini":{
+      "5.0-8.0":"n"
+    },
+    "android":{
+      "2.1":"n",
+      "2.2":"n",
+      "2.3":"n",
+      "3":"n",
+      "4":"n",
+      "4.1":"n",
+      "4.2-4.3":"n",
+      "4.4":"y x",
+      "4.4.3-4.4.4":"y x",
+      "37":"y x"
+    },
+    "bb":{
+      "7":"n",
+      "10":"y x"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "24":"y x"
+    },
+    "and_chr":{
+      "41":"y x"
+    },
+    "and_ff":{
+      "36":"y"
+    },
+    "ie_mob":{
+      "10":"n",
+      "11":"n"
+    },
+    "and_uc":{
+      "9.9":"y x"
+    }
+  },
+  "notes":"Note that this property is significantly different from and incompatible with Microsoft's [older \"filter\" property](http://msdn.microsoft.com/en-us/library/ie/ms530752%28v=vs.85%29.aspx).\r\n\r\nPartial support in Firefox before version 34 [only implemented the url() function of the filter property](https://developer.mozilla.org/en-US/docs/Web/CSS/filter#Browser_compatibility)",
+  "notes_by_num":{
+    "1":"Supported in Firefox under the `layout.css.filters.enabled` flag."
+  },
+  "usage_perc_y":72.81,
+  "usage_perc_a":2.46,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"sepia,hue-rotate,invert,saturate",
+  "ie_id":"filters",
+  "chrome_id":"5822463824887808",
+  "shown":true
+}