From 15820391935170f9f7110a1d2d135044c95f722b Mon Sep 17 00:00:00 2001 From: Heinrich Fenkart Date: Mon, 3 Nov 2014 14:32:38 +0100 Subject: Use autoprefixer for Customizer builds --- docs/assets/js/src/customizer.js | 41 +- docs/assets/js/vendor/autoprefixer.js | 16015 ++++++++++++++++++++++++++++++++ 2 files changed, 16045 insertions(+), 11 deletions(-) create mode 100644 docs/assets/js/vendor/autoprefixer.js (limited to 'docs/assets') diff --git a/docs/assets/js/src/customizer.js b/docs/assets/js/src/customizer.js index b2f15dfa03..b0fefb0f03 100644 --- a/docs/assets/js/src/customizer.js +++ b/docs/assets/js/src/customizer.js @@ -6,7 +6,7 @@ * details, see http://creativecommons.org/licenses/by/3.0/. */ -/* global JSZip, less, saveAs, UglifyJS, __configBridge, __js, __less, __fonts */ +/* global JSZip, less, autoprefixer, saveAs, UglifyJS, __configBridge, __js, __less, __fonts */ window.onload = function () { // wait for load in a dumb way because B-0 'use strict'; @@ -251,6 +251,7 @@ window.onload = function () { // wait for load in a dumb way because B-0 } function compileLESS(lessSource, baseFilename, intoResult) { + var promise = $.Deferred() var parser = new less.Parser({ paths: ['variables.less', 'mixins.less'], optimization: 0, @@ -259,14 +260,18 @@ window.onload = function () { // wait for load in a dumb way because B-0 parser.parse(lessSource, function (err, tree) { if (err) { - return showError('Ruh roh! Could not parse less files.', err) + return promise.reject(err) } intoResult[baseFilename + '.css'] = cw + tree.toCSS() intoResult[baseFilename + '.min.css'] = cw + tree.toCSS({ compress: true }) + promise.resolve() }) + + return promise.promise() } function generateCSS(preamble) { + var promise = $.Deferred() var oneChecked = false var lessFileIncludes = {} $('#less-section input').each(function () { @@ -290,14 +295,22 @@ window.onload = function () { // wait for load in a dumb way because B-0 var bsLessSource = preamble + generateLESS('bootstrap.less', lessFileIncludes, vars) var themeLessSource = preamble + generateLESS('theme.less', lessFileIncludes, vars) - try { - compileLESS(bsLessSource, 'bootstrap', result) + var prefixer = autoprefixer({ browsers: __configBridge.autoprefixerBrowsers }) + + $.when( + compileLESS(bsLessSource, 'bootstrap', result), compileLESS(themeLessSource, 'bootstrap-theme', result) - } catch (err) { - return showError('Ruh roh! Could not parse less files.', err) - } + ).done(function () { + for (var key in result) { + result[key] = prefixer.process(result[key]).css + } + promise.resolve(result) + }).fail(function (err) { + showError('Ruh roh! Could not parse less files.', err) + promise.reject() + }) - return result + return promise.promise() } function uglify(js) { @@ -453,9 +466,15 @@ window.onload = function () { // wait for load in a dumb way because B-0 ' * Config saved to config.json and ' + gistUrl + '\n' + ' */\n' - generateZip(generateCSS(preamble), generateJS(preamble), generateFonts(), configJson, function (blob) { - $compileBtn.removeAttr('disabled') - setTimeout(function () { saveAs(blob, 'bootstrap.zip') }, 0) + $.when( + generateCSS(preamble), + generateJS(preamble), + generateFonts() + ).done(function (css, js, fonts) { + generateZip(css, js, fonts, configJson, function (blob) { + $compileBtn.removeAttr('disabled') + setTimeout(function () { saveAs(blob, 'bootstrap.zip') }, 0) + }) }) }) }); diff --git a/docs/assets/js/vendor/autoprefixer.js b/docs/assets/js/vendor/autoprefixer.js new file mode 100644 index 0000000000..0aead7c3b8 --- /dev/null +++ b/docs/assets/js/vendor/autoprefixer.js @@ -0,0 +1,16015 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.autoprefixer=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1%', 'last 2 versions', 'Firefox ESR', 'Opera 12.1']; + + autoprefixer.loadDefault = function() { + return this.defaultCache || (this.defaultCache = autoprefixer({ + browsers: this["default"] + })); + }; + + 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); + +},{"../data/browsers":2,"../data/prefixes":3,"./browsers":4,"./info":33,"./prefixes":38,"postcss":89}],2:[function(require,module,exports){ +(function() { + var convert, data, intervals, major, name, names, normalize, _ref; + + names = ['firefox', 'chrome', 'safari', 'ios_saf', 'opera', 'ie', 'bb', 'android']; + + major = ['firefox', 'chrome', 'safari', 'ios_saf', 'opera', 'android', 'ie', 'ie_mob']; + + normalize = function(array) { + return array.reverse().filter(function(i) { + return i; + }); + }; + + intervals = function(array) { + var i, interval, result, splited, sub, _i, _len; + result = []; + for (_i = 0, _len = array.length; _i < _len; _i++) { + interval = array[_i]; + splited = interval.split('-'); + splited = splited.sort().reverse(); + sub = (function() { + var _j, _len1, _results; + _results = []; + for (_j = 0, _len1 = splited.length; _j < _len1; _j++) { + i = splited[_j]; + _results.push([i, interval, splited.length]); + } + return _results; + })(); + result = result.concat(sub); + } + return result; + }; + + convert = function(name, data) { + var future, result, versions; + future = normalize(data.versions.slice(-3)); + versions = intervals(normalize(data.versions.slice(0, -3))); + result = {}; + result.prefix = name === 'opera' ? '-o-' : "-" + data.prefix + "-"; + if (major.indexOf(name) === -1) { + result.minor = true; + } + if (future.length) { + result.future = future; + } + result.versions = versions.map(function(i) { + return i[0]; + }); + result.popularity = versions.map(function(i) { + return data.usage_global[i[1]] / i[2]; + }); + return result; + }; + + module.exports = {}; + + _ref = require('caniuse-db/data').agents; + for (name in _ref) { + data = _ref[name]; + module.exports[name] = convert(name, data); + } + +}).call(this); + +},{"caniuse-db/data":51}],3:[function(require,module,exports){ +(function() { + var browsers, feature, map, prefix, textDecoration, + __slice = [].slice; + + browsers = require('./browsers'); + + feature = function(data, opts, callback) { + var browser, interval, match, need, sorted, support, version, versions, _i, _len, _ref, _ref1, _ref2; + if (!callback) { + _ref = [opts, {}], callback = _ref[0], opts = _ref[1]; + } + match = opts.full ? /y\sx($|\s)/ : /\sx($|\s)/; + need = []; + _ref1 = data.stats; + for (browser in _ref1) { + versions = _ref1[browser]; + for (interval in versions) { + support = versions[interval]; + _ref2 = interval.split('-'); + for (_i = 0, _len = _ref2.length; _i < _len; _i++) { + version = _ref2[_i]; + if (browsers[browser] && support.match(match)) { + version = version.replace(/\.0$/, ''); + need.push(browser + ' ' + version); + } + } + } + } + sorted = need.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]); + } + }); + return callback(sorted); + }; + + map = function(browsers, callback) { + var browser, name, version, _i, _len, _ref, _results; + _results = []; + for (_i = 0, _len = browsers.length; _i < _len; _i++) { + browser = browsers[_i]; + _ref = browser.split(' '), name = _ref[0], version = _ref[1]; + version = parseFloat(version); + _results.push(callback(browser, name, version)); + } + return _results; + }; + + prefix = function() { + var data, name, names, _i, _j, _len, _results; + names = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), data = arguments[_i++]; + _results = []; + for (_j = 0, _len = names.length; _j < _len; _j++) { + name = names[_j]; + _results.push(module.exports[name] = data); + } + return _results; + }; + + module.exports = {}; + + 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-'], + browsers: browsers, + transition: true + }); + }); + + feature(require('caniuse-db/features-json/css-boxshadow'), function(browsers) { + return prefix('box-shadow', { + browsers: browsers, + transition: true + }); + }); + + 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', { + 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', { + browsers: browsers, + transition: true + }); + }); + + feature(require('caniuse-db/features-json/transforms3d'), function(browsers) { + prefix('perspective', 'perspective-origin', { + browsers: browsers, + transition: true + }); + return prefix('transform-style', 'backface-visibility', { + browsers: browsers + }); + }); + + feature(require('caniuse-db/features-json/css-gradients'), function(browsers) { + browsers = map(browsers, function(browser, name, version) { + if (name === 'android' && version < 4 || name === 'ios_saf' && version < 5 || name === 'safari' && version < 5.1) { + return browser + ' old'; + } else { + return browser; + } + }); + return prefix('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', { + props: ['background', 'background-image', 'border-image'], + mistakes: ['-ms-'], + 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', { + browsers: browsers, + transition: true + }); + }); + + feature(require('caniuse-db/features-json/multicolumn'), function(browsers) { + prefix('columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', { + browsers: browsers, + transition: true + }); + 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 + }); + }); + + feature(require('caniuse-db/features-json/flexbox'), function(browsers) { + browsers = map(browsers, function(browser, name, version) { + if (name === 'safari' && version < 6.1) { + return browser + ' 2009'; + } else if (name === 'ios_saf' && version < 7) { + return browser + ' 2009'; + } else if (name === 'chrome' && version < 21) { + return browser + ' 2009'; + } else if (name === 'android' && version < 4.4) { + return browser + ' 2009'; + } else { + return browser; + } + }); + 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(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 = map(browsers, function(browser, name, version) { + if (name === 'firefox' && version <= 18) { + return browser + ' old'; + } else { + return browser; + } + }); + return prefix('::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, { + full: true + }, 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) { + return prefix('clip-path', 'mask', 'mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-position', 'mask-repeat', 'mask-size', { + browsers: browsers + }); + }); + +}).call(this); + +},{"./browsers":2,"caniuse-db/features-json/background-img-opts":52,"caniuse-db/features-json/border-image":53,"caniuse-db/features-json/border-radius":54,"caniuse-db/features-json/calc":55,"caniuse-db/features-json/css-animation":56,"caniuse-db/features-json/css-boxshadow":57,"caniuse-db/features-json/css-filters":58,"caniuse-db/features-json/css-gradients":59,"caniuse-db/features-json/css-hyphens":60,"caniuse-db/features-json/css-masks":61,"caniuse-db/features-json/css-placeholder":62,"caniuse-db/features-json/css-selection":63,"caniuse-db/features-json/css-sticky":64,"caniuse-db/features-json/css-transitions":65,"caniuse-db/features-json/css3-boxsizing":66,"caniuse-db/features-json/css3-cursors-newer":67,"caniuse-db/features-json/css3-tabsize":68,"caniuse-db/features-json/flexbox":69,"caniuse-db/features-json/font-feature":70,"caniuse-db/features-json/fullscreen":71,"caniuse-db/features-json/intrinsic-width":72,"caniuse-db/features-json/multicolumn":73,"caniuse-db/features-json/pointer":74,"caniuse-db/features-json/text-decoration":75,"caniuse-db/features-json/text-size-adjust":76,"caniuse-db/features-json/transforms2d":77,"caniuse-db/features-json/transforms3d":78,"caniuse-db/features-json/user-select-none":79}],4:[function(require,module,exports){ +(function() { + var Browsers, utils; + + utils = require('./utils'); + + Browsers = (function() { + Browsers.prefixes = function() { + var data, i, name; + if (this.prefixesCache) { + return this.prefixesCache; + } + data = require('../data/browsers'); + 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(data, requirements) { + this.data = data; + this.selected = this.parse(requirements); + } + + Browsers.prototype.parse = function(requirements) { + var selected; + if (!(requirements instanceof Array)) { + requirements = [requirements]; + } + selected = []; + requirements.map((function(_this) { + return function(req) { + var i, match, name, _ref; + _ref = _this.requirements; + for (name in _ref) { + i = _ref[name]; + if (match = req.match(i.regexp)) { + selected = selected.concat(i.select.apply(_this, match.slice(1))); + return; + } + } + return utils.error("Unknown browser requirement `" + req + "`"); + }; + })(this)); + return utils.uniq(selected); + }; + + Browsers.prototype.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' + }; + + Browsers.prototype.requirements = { + none: { + regexp: /^none$/i, + select: function() { + if (typeof console !== "undefined" && console !== null) { + console.warn("autoprefixer(\'none\') is deprecated and will be " + 'removed in 3.1. ' + 'Use autoprefixer({ browsers: [] })'); + } + return []; + } + }, + lastVersions: { + regexp: /^last (\d+) versions?$/i, + select: function(versions) { + return this.browsers(function(data) { + if (data.minor) { + return []; + } else { + return data.versions.slice(0, versions); + } + }); + } + }, + lastByBrowser: { + regexp: /^last (\d+) (\w+) versions?$/i, + select: function(versions, browser) { + var data; + data = this.byName(browser); + return data.versions.slice(0, versions).map(function(v) { + return "" + data.name + " " + v; + }); + } + }, + globalStatistics: { + regexp: /^> (\d+(\.\d+)?)%$/, + select: function(popularity) { + return this.browsers(function(data) { + if (data.minor) { + return []; + } else { + return data.versions.filter(function(version, i) { + return data.popularity[i] > popularity; + }); + } + }); + } + }, + newerThan: { + regexp: /^(\w+) (>=?)\s*([\d\.]+)/, + select: function(browser, sign, version) { + var data, filter; + data = this.byName(browser); + version = parseFloat(version); + if (sign === '>') { + filter = function(v) { + return v > version; + }; + } else if (sign === '>=') { + filter = function(v) { + return v >= version; + }; + } + return data.versions.filter(filter).map(function(v) { + return "" + data.name + " " + v; + }); + } + }, + olderThan: { + regexp: /^(\w+) (<=?)\s*([\d\.]+)/, + select: function(browser, sign, version) { + var data, filter; + data = this.byName(browser); + version = parseFloat(version); + if (sign === '<') { + filter = function(v) { + return v < version; + }; + } else if (sign === '<=') { + filter = function(v) { + return v <= version; + }; + } + return data.versions.filter(filter).map(function(v) { + return "" + data.name + " " + v; + }); + } + }, + esr: { + regexp: /^(firefox|ff|fx) esr$/i, + select: function() { + return ['firefox 31']; + } + }, + direct: { + regexp: /^(\w+) ([\d\.]+)$/, + select: function(browser, version) { + var data, first, last; + data = this.byName(browser); + version = parseFloat(version); + last = data.future ? data.future[0] : data.versions[0]; + first = data.versions[data.versions.length - 1]; + if (version > last) { + version = last; + } else if (version < first) { + version = first; + } + return ["" + data.name + " " + version]; + } + } + }; + + Browsers.prototype.browsers = function(criteria) { + var browser, data, selected, versions, _ref; + 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 name, version, _ref; + _ref = browser.split(' '), name = _ref[0], version = _ref[1]; + if (name === 'opera' && parseFloat(version) >= 15) { + return '-webkit-'; + } else { + return this.data[name].prefix; + } + }; + + Browsers.prototype.isSelected = function(browser) { + return this.selected.indexOf(browser) !== -1; + }; + + Browsers.prototype.byName = function(name) { + var data; + name = name.toLowerCase(); + name = this.aliases[name] || name; + data = this.data[name]; + if (!data) { + utils.error("Unknown browser " + browser); + } + data.name = name; + return data; + }; + + return Browsers; + + })(); + + module.exports = Browsers; + +}).call(this); + +},{"../data/browsers":2,"./utils":42}],5:[function(require,module,exports){ +(function() { + var Browsers, Declaration, Prefixer, utils, vendor, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Prefixer = require('./prefixer'); + + Browsers = require('./browsers'); + + vendor = require('postcss/lib/vendor'); + + utils = require('./utils'); + + Declaration = (function(_super) { + __extends(Declaration, _super); + + 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 other, _i, _len, _ref; + _ref = Browsers.prefixes(); + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + other = _ref[_i]; + 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.before.indexOf("\n") !== -1); + }; + + Declaration.prototype.maxPrefixed = function(prefixes, decl) { + var max, prefix, _i, _len; + if (decl._autoprefixerMax) { + return decl._autoprefixerMax; + } + max = 0; + for (_i = 0, _len = prefixes.length; _i < _len; _i++) { + prefix = prefixes[_i]; + 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, max, _i; + if (prefix == null) { + prefix = ''; + } + before = decl.before; + max = this.maxPrefixed(prefixes, decl); + diff = max - utils.removeNote(prefix).length; + for (i = _i = 0; 0 <= diff ? _i < diff : _i > diff; i = 0 <= diff ? ++_i : --_i) { + before += ' '; + } + return before; + }; + + Declaration.prototype.restoreBefore = function(decl) { + var lines, min; + lines = decl.before.split("\n"); + min = lines[lines.length - 1]; + this.all.group(decl).up(function(prefixed) { + var array, last; + array = prefixed.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); + +},{"./browsers":4,"./prefixer":37,"./utils":42,"postcss/lib/vendor":94}],6:[function(require,module,exports){ +(function() { + var AlignContent, Declaration, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + AlignContent = (function(_super) { + __extends(AlignContent, _super); + + 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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],7:[function(require,module,exports){ +(function() { + var AlignItems, Declaration, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + AlignItems = (function(_super) { + __extends(AlignItems, _super); + + 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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],8:[function(require,module,exports){ +(function() { + var AlignSelf, Declaration, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + AlignSelf = (function(_super) { + __extends(AlignSelf, _super); + + 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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],9:[function(require,module,exports){ +(function() { + var BackgroundSize, Declaration, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + BackgroundSize = (function(_super) { + __extends(BackgroundSize, _super); + + 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); + +},{"../declaration":5}],10:[function(require,module,exports){ +(function() { + var BorderImage, Declaration, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + BorderImage = (function(_super) { + __extends(BorderImage, _super); + + 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); + +},{"../declaration":5}],11:[function(require,module,exports){ +(function() { + var BorderRadius, Declaration, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + BorderRadius = (function(_super) { + var hor, mozilla, normal, ver, _i, _j, _len, _len1, _ref, _ref1; + + __extends(BorderRadius, _super); + + 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); + +},{"../declaration":5}],12:[function(require,module,exports){ +(function() { + var BreakInside, Declaration, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + BreakInside = (function(_super) { + __extends(BreakInside, _super); + + 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); + +},{"../declaration":5}],13:[function(require,module,exports){ +(function() { + var DisplayFlex, OldDisplayFlex, OldValue, Value, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + OldValue = require('../old-value'); + + Value = require('../value'); + + OldDisplayFlex = (function(_super) { + __extends(OldDisplayFlex, _super); + + function OldDisplayFlex(name) { + this.name = name; + } + + OldDisplayFlex.prototype.check = function(value) { + return value === this.name; + }; + + return OldDisplayFlex; + + })(OldValue); + + DisplayFlex = (function(_super) { + __extends(DisplayFlex, _super); + + 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 spec, _ref; + _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(prefixed); + } + }; + + return DisplayFlex; + + })(Value); + + module.exports = DisplayFlex; + +}).call(this); + +},{"../old-value":36,"../value":43,"./flex-spec":22}],14:[function(require,module,exports){ +(function() { + var FillAvailable, OldValue, Value, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + OldValue = require('../old-value'); + + Value = require('../value'); + + FillAvailable = (function(_super) { + __extends(FillAvailable, _super); + + 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('-moz-available'); + } else { + return FillAvailable.__super__.old.apply(this, arguments); + } + }; + + return FillAvailable; + + })(Value); + + module.exports = FillAvailable; + +}).call(this); + +},{"../old-value":36,"../value":43}],15:[function(require,module,exports){ +(function() { + var FilterValue, Value, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Value = require('../value'); + + FilterValue = (function(_super) { + __extends(FilterValue, _super); + + 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); + } + }; + + return FilterValue; + + })(Value); + + module.exports = FilterValue; + +}).call(this); + +},{"../value":43}],16:[function(require,module,exports){ +(function() { + var Declaration, Filter, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + Filter = (function(_super) { + __extends(Filter, _super); + + 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); + +},{"../declaration":5}],17:[function(require,module,exports){ +(function() { + var Declaration, FlexBasis, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + FlexBasis = (function(_super) { + __extends(FlexBasis, _super); + + 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 spec, _ref; + _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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],18:[function(require,module,exports){ +(function() { + var Declaration, FlexDirection, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + FlexDirection = (function(_super) { + __extends(FlexDirection, _super); + + 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, spec, value, _ref; + _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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],19:[function(require,module,exports){ +(function() { + var Declaration, FlexFlow, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + FlexFlow = (function(_super) { + __extends(FlexFlow, _super); + + function FlexFlow() { + return FlexFlow.__super__.constructor.apply(this, arguments); + } + + FlexFlow.names = ['flex-flow']; + + FlexFlow.prototype.set = function(decl, prefix) { + var spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],20:[function(require,module,exports){ +(function() { + var Declaration, Flex, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + Flex = (function(_super) { + __extends(Flex, _super); + + 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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],21:[function(require,module,exports){ +(function() { + var Declaration, FlexShrink, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + FlexShrink = (function(_super) { + __extends(FlexShrink, _super); + + 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 spec, _ref; + _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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],22:[function(require,module,exports){ +(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); + +},{}],23:[function(require,module,exports){ +(function() { + var Declaration, FlexWrap, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + FlexWrap = (function(_super) { + __extends(FlexWrap, _super); + + 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); + +},{"../declaration":5,"./flex-spec":22}],24:[function(require,module,exports){ +(function() { + var Declaration, Flex, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + Flex = (function(_super) { + __extends(Flex, _super); + + 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 spec, _ref; + _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 = decl.value.split(' ')[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); + +},{"../declaration":5,"./flex-spec":22}],25:[function(require,module,exports){ +(function() { + var Fullscreen, Selector, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Selector = require('../selector'); + + Fullscreen = (function(_super) { + __extends(Fullscreen, _super); + + 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); + +},{"../selector":40}],26:[function(require,module,exports){ +(function() { + var Gradient, OldValue, Value, isDirection, list, utils, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + OldValue = require('../old-value'); + + Value = require('../value'); + + utils = require('../utils'); + + list = require('postcss/lib/list'); + + isDirection = /top|left|right|bottom/gi; + + Gradient = (function(_super) { + __extends(Gradient, _super); + + 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 _i, _len, _results; + _results = []; + for (_i = 0, _len = first.length; _i < _len; _i++) { + value = first[_i]; + _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 (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 _i, _len, _results; + _results = []; + for (_i = 0, _len = param.length; _i < _len; _i++) { + value = param[_i]; + _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(prefix + this.name, string, regexp); + } else { + return Gradient.__super__.old.apply(this, arguments); + } + }; + + return Gradient; + + })(Value); + + module.exports = Gradient; + +}).call(this); + +},{"../old-value":36,"../utils":42,"../value":43,"postcss/lib/list":85}],27:[function(require,module,exports){ +(function() { + var Declaration, JustifyContent, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + JustifyContent = (function(_super) { + __extends(JustifyContent, _super); + + 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 spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],28:[function(require,module,exports){ +(function() { + var Declaration, Order, flexSpec, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + flexSpec = require('./flex-spec'); + + Declaration = require('../declaration'); + + Order = (function(_super) { + __extends(Order, _super); + + function Order() { + return Order.__super__.constructor.apply(this, arguments); + } + + Order.names = ['order', 'flex-order', 'box-ordinal-group']; + + Order.prototype.prefixed = function(prop, prefix) { + var spec, _ref; + _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); + +},{"../declaration":5,"./flex-spec":22}],29:[function(require,module,exports){ +(function() { + var Placeholder, Selector, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Selector = require('../selector'); + + Placeholder = (function(_super) { + __extends(Placeholder, _super); + + function Placeholder() { + return Placeholder.__super__.constructor.apply(this, arguments); + } + + Placeholder.names = ['::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); + +},{"../selector":40}],30:[function(require,module,exports){ +(function() { + var Declaration, TransformDecl, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Declaration = require('../declaration'); + + TransformDecl = (function(_super) { + __extends(TransformDecl, _super); + + 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); + +},{"../declaration":5}],31:[function(require,module,exports){ +(function() { + var TransformValue, Value, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Value = require('../value'); + + TransformValue = (function(_super) { + __extends(TransformValue, _super); + + 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); + +},{"../value":43}],32:[function(require,module,exports){ +(function() { + var OldValue, Transition, Value, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + OldValue = require('../old-value'); + + Value = require('../value'); + + Transition = (function(_super) { + __extends(Transition, _super); + + function Transition() { + return Transition.__super__.constructor.apply(this, arguments); + } + + Transition.names = ['flex', 'flex-grow', 'flex-shrink', 'flex-basis']; + + Transition.prototype.prefixed = function(prefix) { + return this.all.prefixed(this.name, prefix); + }; + + Transition.prototype.replace = function(string, prefix) { + return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3'); + }; + + Transition.prototype.old = function(prefix) { + return new OldValue(this.prefixed(prefix)); + }; + + return Transition; + + })(Value); + + module.exports = Transition; + +}).call(this); + +},{"../old-value":36,"../value":43}],33:[function(require,module,exports){ +(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' + }; + + 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, list, name, needTransition, out, props, selector, selectors, string, transitionProp, useTransition, value, values, version, versions, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6; + if (prefixes.browsers.selected.length === 0) { + return "No browsers selected"; + } + versions = []; + _ref = prefixes.browsers.selected; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + browser = _ref[_i]; + _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 (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) { + selector = _ref3[_j]; + 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 (_k = 0, _len2 = _ref6.length; _k < _len2; _k++) { + value = _ref6[_k]; + 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); + +},{}],34:[function(require,module,exports){ +(function() { + var Keyframes, Prefixer, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Prefixer = require('./prefixer'); + + Keyframes = (function(_super) { + __extends(Keyframes, _super); + + function Keyframes() { + return Keyframes.__super__.constructor.apply(this, arguments); + } + + Keyframes.prototype.add = function(atRule, prefix) { + var already, cloned, prefixed; + prefixed = prefix + atRule.name; + already = atRule.parent.some(function(i) { + return i.name === prefixed && i.params === atRule.params; + }); + if (already) { + return; + } + cloned = this.clone(atRule, { + name: prefixed + }); + return atRule.parent.insertBefore(atRule, cloned); + }; + + Keyframes.prototype.process = function(node) { + var parent, prefix, _i, _len, _ref, _results; + parent = this.parentPrefix(node); + _ref = this.prefixes; + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + prefix = _ref[_i]; + if (parent && parent !== prefix) { + continue; + } + _results.push(this.add(node, prefix)); + } + return _results; + }; + + return Keyframes; + + })(Prefixer); + + module.exports = Keyframes; + +}).call(this); + +},{"./prefixer":37}],35:[function(require,module,exports){ +(function() { + var OldSelector; + + OldSelector = (function() { + function OldSelector(selector, prefix) { + var _i, _len, _ref; + this.prefix = prefix; + 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, index, regexp, rules, some, string, _i, _len, _ref, _ref1; + index = rule.parent.index(rule) + 1; + rules = rule.parent.rules; + 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); + +},{}],36:[function(require,module,exports){ +(function() { + var OldValue, utils; + + utils = require('./utils'); + + OldValue = (function() { + function OldValue(name, string, regexp) { + this.name = name; + this.string = string; + this.regexp = regexp; + this.regexp || (this.regexp = utils.regexp(this.name)); + this.string || (this.string = this.name); + } + + 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); + +},{"./utils":42}],37:[function(require,module,exports){ +(function() { + var Browsers, Prefixer, utils, vendor; + + Browsers = require('./browsers'); + + vendor = require('postcss/lib/vendor'); + + utils = require('./utils'); + + Prefixer = (function() { + Prefixer.hack = function(klass) { + var name, _i, _len, _ref, _results; + this.hacks || (this.hacks = {}); + _ref = klass.names; + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + name = _ref[_i]; + _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; + cloned = node.clone(overrides); + if (node.type === 'decl') { + cloned.between = node.between; + } + delete cloned._autoprefixerPrefix; + delete cloned._autoprefixerValues; + return cloned; + }; + + function Prefixer(name, prefixes, all) { + this.name = name; + this.prefixes = prefixes; + this.all = all; + } + + 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, parent, prefix, prefixes, _i, _j, _len, _len1, _ref; + if (!this.check(node)) { + return; + } + parent = this.parentPrefix(node); + prefixes = []; + _ref = this.prefixes; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + prefix = _ref[_i]; + if (parent && parent !== utils.removeNote(prefix)) { + continue; + } + prefixes.push(prefix); + } + added = []; + for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) { + prefix = prefixes[_j]; + 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); + +},{"./browsers":4,"./utils":42,"postcss/lib/vendor":94}],38:[function(require,module,exports){ +(function() { + var Browsers, Declaration, Keyframes, Prefixes, Processor, Selector, Supports, Value, declsCache, utils, vendor; + + utils = require('./utils'); + + vendor = require('postcss/lib/vendor'); + + Declaration = require('./declaration'); + + Processor = require('./processor'); + + Keyframes = require('./keyframes'); + + Supports = require('./supports'); + + Browsers = require('./browsers'); + + Selector = require('./selector'); + + Value = require('./value'); + + 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/transform-decl')); + + Declaration.hack(require('./hacks/flex-direction')); + + Declaration.hack(require('./hacks/justify-content')); + + Declaration.hack(require('./hacks/background-size')); + + Value.hack(require('./hacks/gradient')); + + Value.hack(require('./hacks/transition')); + + 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(data, browsers, options) { + var _ref; + this.data = data; + 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, name, old, olds, prefix, prefixed, prefixes, prop, props, remove, selector, value, values, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _len5, _len6, _m, _n, _o, _ref, _ref1, _ref2; + add = { + selectors: [], + '@supports': new Supports(this) + }; + _ref = selected.add; + for (name in _ref) { + prefixes = _ref[name]; + if (name === '@keyframes') { + add[name] = new Keyframes(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 (_i = 0, _len = props.length; _i < _len; _i++) { + prop = props[_i]; + 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 (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) { + prefix = prefixes[_j]; + remove.selectors.push(selector.old(prefix)); + } + } else if (name[0] === '@') { + for (_k = 0, _len2 = prefixes.length; _k < _len2; _k++) { + prefix = prefixes[_k]; + prefixed = '@' + prefix + name.slice(1); + remove[prefixed] = { + remove: true + }; + } + } else { + props = this.data[name].transition ? this.transitionProps : this.data[name].props; + if (props) { + value = Value.load(name, [], this); + for (_l = 0, _len3 = prefixes.length; _l < _len3; _l++) { + prefix = prefixes[_l]; + old = value.old(prefix); + if (old) { + for (_m = 0, _len4 = props.length; _m < _len4; _m++) { + prop = props[_m]; + if (!remove[prop]) { + remove[prop] = {}; + } + if (!remove[prop].values) { + remove[prop].values = []; + } + remove[prop].values.push(old); + } + } + } + } + if (!this.data[name].props) { + for (_n = 0, _len5 = prefixes.length; _n < _len5; _n++) { + prefix = prefixes[_n]; + prop = vendor.unprefixed(name); + olds = this.decl(name).old(name, prefix); + for (_o = 0, _len6 = olds.length; _o < _len6; _o++) { + prefixed = olds[_o]; + 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, values, _ref, _ref1; + 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.decls.length; + unprefixed = this.unprefixed(decl.prop); + checker = (function(_this) { + return function(step, callback) { + var other; + index += step; + while (index >= 0 && index < length) { + other = rule.decls[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); + +},{"./browsers":4,"./declaration":5,"./hacks/align-content":6,"./hacks/align-items":7,"./hacks/align-self":8,"./hacks/background-size":9,"./hacks/border-image":10,"./hacks/border-radius":11,"./hacks/break-inside":12,"./hacks/display-flex":13,"./hacks/fill-available":14,"./hacks/filter":16,"./hacks/filter-value":15,"./hacks/flex":24,"./hacks/flex-basis":17,"./hacks/flex-direction":18,"./hacks/flex-flow":19,"./hacks/flex-grow":20,"./hacks/flex-shrink":21,"./hacks/flex-wrap":23,"./hacks/fullscreen":25,"./hacks/gradient":26,"./hacks/justify-content":27,"./hacks/order":28,"./hacks/placeholder":29,"./hacks/transform-decl":30,"./hacks/transform-value":31,"./hacks/transition":32,"./keyframes":34,"./processor":39,"./selector":40,"./supports":41,"./utils":42,"./value":43,"postcss/lib/vendor":94}],39:[function(require,module,exports){ +(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, supports; + keyframes = this.prefixes.add['@keyframes']; + 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 === 'supports') { + if (!_this.disabled(rule)) { + return supports.process(rule); + } + } + }; + })(this)); + css.eachRule((function(_this) { + return function(rule) { + var selector, _i, _len, _ref, _results; + if (_this.disabled(rule)) { + return; + } + _ref = _this.prefixes.add.selectors; + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + selector = _ref[_i]; + _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 unprefixed, value, _i, _len, _ref; + if (_this.disabled(decl)) { + return; + } + unprefixed = _this.prefixes.unprefixed(decl.prop); + _ref = _this.prefixes.values('add', unprefixed); + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + value = _ref[_i]; + value.process(decl); + } + return Value.save(_this.prefixes, decl); + }; + })(this)); + }; + + Processor.prototype.remove = function(css) { + var checker, _i, _len, _ref; + css.eachAtRule((function(_this) { + return function(rule, i) { + if (_this.prefixes.remove['@' + rule.name]) { + if (!_this.disabled(rule)) { + return rule.parent.remove(i); + } + } + }; + })(this)); + _ref = this.prefixes.remove.selectors; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + checker = _ref[_i]; + 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 notHack, rule, unprefixed, _j, _len1, _ref1, _ref2; + 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) { + if (decl.before.indexOf("\n") > -1) { + _this.reduceSpaces(decl); + } + rule.remove(i); + return; + } + } + _ref2 = _this.prefixes.values('remove', unprefixed); + for (_j = 0, _len1 = _ref2.length; _j < _len1; _j++) { + checker = _ref2[_j]; + if (checker.check(decl.value)) { + rule.remove(i); + return; + } + } + }; + })(this)); + }; + + Processor.prototype.disabled = function(node) { + var status; + if (node._autoprefixerDisabled != null) { + return node._autoprefixerDisabled; + } else if (node.decls || node.rules) { + 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.before.split("\n"); + prevMin = parts[parts.length - 1].length; + diff = false; + return this.prefixes.group(decl).down(function(other) { + var last; + parts = other.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); + +},{"./utils":42,"./value":43,"postcss/lib/vendor":94}],40:[function(require,module,exports){ +(function() { + var Browsers, OldSelector, Prefixer, Selector, utils, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + OldSelector = require('./old-selector'); + + Prefixer = require('./prefixer'); + + Browsers = require('./browsers'); + + utils = require('./utils'); + + Selector = (function(_super) { + __extends(Selector, _super); + + function Selector(name, prefixes, all) { + this.name = name; + 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 prefix, prefixeds, _i, _len, _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.rules[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); + +},{"./browsers":4,"./old-selector":35,"./prefixer":37,"./utils":42}],41:[function(require,module,exports){ +(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*\)\s*or\s*/gi; + + Supports = (function() { + function Supports(all) { + this.all = all; + } + + 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, prefixer, rule, _i, _j, _len, _len1, _ref, _ref1; + rule = this.virtual(prop, value); + prefixer = this.all.add[prop]; + if (prefixer != null) { + if (typeof prefixer.process === "function") { + prefixer.process(rule.first); + } + } + _ref = rule.decls; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + decl = _ref[_i]; + _ref1 = this.all.values('add', prop); + for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) { + value = _ref1[_j]; + value.process(decl); + } + Value.save(this.all, decl); + } + return rule.decls; + }; + + Supports.prototype.clean = function(params) { + return params.replace(findCondition, (function(_this) { + return function(all) { + var check, checker, prop, unprefixed, value, _, _i, _len, _ref, _ref1, _ref2; + 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 (_i = 0, _len = _ref2.length; _i < _len; _i++) { + checker = _ref2[_i]; + 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 _i, _len, _ref, _results; + _ref = this.prefixed(prop, value); + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + i = _ref[_i]; + _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); + +},{"./prefixes":38,"./utils":42,"./value":43,"postcss":89,"postcss/lib/list":85}],42:[function(require,module,exports){ +(function() { + module.exports = { + error: function(text) { + var err; + err = new Error(text); + err.autoprefixer = true; + throw err; + }, + uniq: function(array) { + var filtered, i, _i, _len; + filtered = []; + for (_i = 0, _len = array.length; _i < _len; _i++) { + i = array[_i]; + 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"); + } + }; + +}).call(this); + +},{}],43:[function(require,module,exports){ +(function() { + var OldValue, Prefixer, Value, utils, vendor, + __hasProp = {}.hasOwnProperty, + __extends = 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; }; + + Prefixer = require('./prefixer'); + + OldValue = require('./old-value'); + + utils = require('./utils'); + + vendor = require('postcss/lib/vendor'); + + Value = (function(_super) { + __extends(Value, _super); + + function Value() { + return Value.__super__.constructor.apply(this, arguments); + } + + Value.save = function(prefixes, decl) { + var already, cloned, prefix, prefixed, propPrefix, rule, trimmed, value, _ref, _results; + _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) { + 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 value, _ref; + 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(prefix + this.name); + }; + + return Value; + + })(Prefixer); + + module.exports = Value; + +}).call(this); + +},{"./old-value":36,"./prefixer":37,"./utils":42,"postcss/lib/vendor":94}],44:[function(require,module,exports){ + +},{}],45:[function(require,module,exports){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('is-array') + +exports.Buffer = Buffer +exports.SlowBuffer = Buffer +exports.INSPECT_MAX_BYTES = 50 +Buffer.poolSize = 8192 // not used by this implementation + +var kMaxLength = 0x3fffffff + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Note: + * + * - Implementation must support adding new properties to `Uint8Array` instances. + * Firefox 4-29 lacked support, fixed in Firefox 30+. + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + * + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will + * get the Object implementation, which is slower but will work correctly. + */ +Buffer.TYPED_ARRAY_SUPPORT = (function () { + try { + var buf = new ArrayBuffer(0) + var arr = new Uint8Array(buf) + arr.foo = function () { return 42 } + return 42 === arr.foo() && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } +})() + +/** + * Class: Buffer + * ============= + * + * The Buffer constructor returns instances of `Uint8Array` that are augmented + * with function properties for all the node `Buffer` API functions. We use + * `Uint8Array` so that square bracket notation works as expected -- it returns + * a single octet. + * + * By augmenting the instances, we can avoid modifying the `Uint8Array` + * prototype. + */ +function Buffer (subject, encoding, noZero) { + if (!(this instanceof Buffer)) + return new Buffer(subject, encoding, noZero) + + var type = typeof subject + + // Find the length + var length + if (type === 'number') + length = subject > 0 ? subject >>> 0 : 0 + else if (type === 'string') { + if (encoding === 'base64') + subject = base64clean(subject) + length = Buffer.byteLength(subject, encoding) + } else if (type === 'object' && subject !== null) { // assume object is array-like + if (subject.type === 'Buffer' && isArray(subject.data)) + subject = subject.data + length = +subject.length > 0 ? Math.floor(+subject.length) : 0 + } else + throw new TypeError('must start with number, buffer, array or string') + + if (this.length > kMaxLength) + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength.toString(16) + ' bytes') + + var buf + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Preferred: Return an augmented `Uint8Array` instance for best performance + buf = Buffer._augment(new Uint8Array(length)) + } else { + // Fallback: Return THIS instance of Buffer (created by `new`) + buf = this + buf.length = length + buf._isBuffer = true + } + + var i + if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') { + // Speed optimization -- use set if we're copying from a typed array + buf._set(subject) + } else if (isArrayish(subject)) { + // Treat array-ish objects as a byte array + if (Buffer.isBuffer(subject)) { + for (i = 0; i < length; i++) + buf[i] = subject.readUInt8(i) + } else { + for (i = 0; i < length; i++) + buf[i] = ((subject[i] % 256) + 256) % 256 + } + } else if (type === 'string') { + buf.write(subject, 0, encoding) + } else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) { + for (i = 0; i < length; i++) { + buf[i] = 0 + } + } + + return buf +} + +Buffer.isBuffer = function (b) { + return !!(b != null && b._isBuffer) +} + +Buffer.compare = function (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) + throw new TypeError('Arguments must be Buffers') + + var x = a.length + var y = b.length + for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {} + if (i !== len) { + x = a[i] + y = b[i] + } + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'binary': + case 'base64': + case 'raw': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function (list, totalLength) { + if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])') + + if (list.length === 0) { + return new Buffer(0) + } else if (list.length === 1) { + return list[0] + } + + var i + if (totalLength === undefined) { + totalLength = 0 + for (i = 0; i < list.length; i++) { + totalLength += list[i].length + } + } + + var buf = new Buffer(totalLength) + var pos = 0 + for (i = 0; i < list.length; i++) { + var item = list[i] + item.copy(buf, pos) + pos += item.length + } + return buf +} + +Buffer.byteLength = function (str, encoding) { + var ret + str = str + '' + switch (encoding || 'utf8') { + case 'ascii': + case 'binary': + case 'raw': + ret = str.length + break + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + ret = str.length * 2 + break + case 'hex': + ret = str.length >>> 1 + break + case 'utf8': + case 'utf-8': + ret = utf8ToBytes(str).length + break + case 'base64': + ret = base64ToBytes(str).length + break + default: + ret = str.length + } + return ret +} + +// pre-set for values that may exist in the future +Buffer.prototype.length = undefined +Buffer.prototype.parent = undefined + +// toString(encoding, start=0, end=buffer.length) +Buffer.prototype.toString = function (encoding, start, end) { + var loweredCase = false + + start = start >>> 0 + end = end === undefined || end === Infinity ? this.length : end >>> 0 + + if (!encoding) encoding = 'utf8' + if (start < 0) start = 0 + if (end > this.length) end = this.length + if (end <= start) return '' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'binary': + return binarySlice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) + throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.equals = function (b) { + if(!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) + str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + return Buffer.compare(this, b) +} + +// `get` will be removed in Node 0.13+ +Buffer.prototype.get = function (offset) { + console.log('.get() is deprecated. Access using array indexes instead.') + return this.readUInt8(offset) +} + +// `set` will be removed in Node 0.13+ +Buffer.prototype.set = function (v, offset) { + console.log('.set() is deprecated. Access using array indexes instead.') + return this.writeUInt8(v, offset) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new Error('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; i++) { + var byte = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(byte)) throw new Error('Invalid hex string') + buf[offset + i] = byte + } + return i +} + +function utf8Write (buf, string, offset, length) { + var charsWritten = blitBuffer(utf8ToBytes(string), buf, offset, length) + return charsWritten +} + +function asciiWrite (buf, string, offset, length) { + var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length) + return charsWritten +} + +function binaryWrite (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length) + return charsWritten +} + +function utf16leWrite (buf, string, offset, length) { + var charsWritten = blitBuffer(utf16leToBytes(string), buf, offset, length) + return charsWritten +} + +Buffer.prototype.write = function (string, offset, length, encoding) { + // Support both (string, offset, length, encoding) + // and the legacy (string, encoding, offset, length) + if (isFinite(offset)) { + if (!isFinite(length)) { + encoding = length + length = undefined + } + } else { // legacy + var swap = encoding + encoding = offset + offset = length + length = swap + } + + offset = Number(offset) || 0 + var remaining = this.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + encoding = String(encoding || 'utf8').toLowerCase() + + var ret + switch (encoding) { + case 'hex': + ret = hexWrite(this, string, offset, length) + break + case 'utf8': + case 'utf-8': + ret = utf8Write(this, string, offset, length) + break + case 'ascii': + ret = asciiWrite(this, string, offset, length) + break + case 'binary': + ret = binaryWrite(this, string, offset, length) + break + case 'base64': + ret = base64Write(this, string, offset, length) + break + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + ret = utf16leWrite(this, string, offset, length) + break + default: + throw new TypeError('Unknown encoding: ' + encoding) + } + return ret +} + +Buffer.prototype.toJSON = function () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + var res = '' + var tmp = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; i++) { + if (buf[i] <= 0x7F) { + res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]) + tmp = '' + } else { + tmp += '%' + buf[i].toString(16) + } + } + + return res + decodeUtf8Char(tmp) +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; i++) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function binarySlice (buf, start, end) { + return asciiSlice(buf, start, end) +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; i++) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) + } + return res +} + +Buffer.prototype.slice = function (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len; + if (start < 0) + start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) + end = 0 + } else if (end > len) { + end = len + } + + if (end < start) + end = start + + if (Buffer.TYPED_ARRAY_SUPPORT) { + return Buffer._augment(this.subarray(start, end)) + } else { + var sliceLen = end - start + var newBuf = new Buffer(sliceLen, undefined, true) + for (var i = 0; i < sliceLen; i++) { + newBuf[i] = this[i + start] + } + return newBuf + } +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) + throw new RangeError('offset is not uint') + if (offset + ext > length) + throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUInt8 = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readInt8 = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) + return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function (offset, noAssert) { + if (!noAssert) + checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') + if (value > max || value < min) throw new TypeError('value is out of bounds') + if (offset + ext > buf.length) throw new TypeError('index out of range') +} + +Buffer.prototype.writeUInt8 = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 1, 0xff, 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = value + return offset + 1 +} + +function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } +} + +Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + } else objectWriteUInt16(this, value, offset, true) + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = value + } else objectWriteUInt16(this, value, offset, false) + return offset + 2 +} + +function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } +} + +Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = value + } else objectWriteUInt32(this, value, offset, true) + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = value + } else objectWriteUInt32(this, value, offset, false) + return offset + 4 +} + +Buffer.prototype.writeInt8 = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 1, 0x7f, -0x80) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + if (value < 0) value = 0xff + value + 1 + this[offset] = value + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + } else objectWriteUInt16(this, value, offset, true) + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = value + } else objectWriteUInt16(this, value, offset, false) + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else objectWriteUInt32(this, value, offset, true) + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) + checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = value + } else objectWriteUInt32(this, value, offset, false) + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (value > max || value < min) throw new TypeError('value is out of bounds') + if (offset + ext > buf.length) throw new TypeError('index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function (target, target_start, start, end) { + var source = this + + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (!target_start) target_start = 0 + + // Copy 0 bytes; we're done + if (end === start) return + if (target.length === 0 || source.length === 0) return + + // Fatal error conditions + if (end < start) throw new TypeError('sourceEnd < sourceStart') + if (target_start < 0 || target_start >= target.length) + throw new TypeError('targetStart out of bounds') + if (start < 0 || start >= source.length) throw new TypeError('sourceStart out of bounds') + if (end < 0 || end > source.length) throw new TypeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) + end = this.length + if (target.length - target_start < end - start) + end = target.length - target_start + start + + var len = end - start + + if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < len; i++) { + target[i + target_start] = this[i + start] + } + } else { + target._set(this.subarray(start, start + len), target_start) + } +} + +// fill(value, start=0, end=buffer.length) +Buffer.prototype.fill = function (value, start, end) { + if (!value) value = 0 + if (!start) start = 0 + if (!end) end = this.length + + if (end < start) throw new TypeError('end < start') + + // Fill 0 bytes; we're done + if (end === start) return + if (this.length === 0) return + + if (start < 0 || start >= this.length) throw new TypeError('start out of bounds') + if (end < 0 || end > this.length) throw new TypeError('end out of bounds') + + var i + if (typeof value === 'number') { + for (i = start; i < end; i++) { + this[i] = value + } + } else { + var bytes = utf8ToBytes(value.toString()) + var len = bytes.length + for (i = start; i < end; i++) { + this[i] = bytes[i % len] + } + } + + return this +} + +/** + * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. + * Added in Node 0.12. Only available in browsers that support ArrayBuffer. + */ +Buffer.prototype.toArrayBuffer = function () { + if (typeof Uint8Array !== 'undefined') { + if (Buffer.TYPED_ARRAY_SUPPORT) { + return (new Buffer(this)).buffer + } else { + var buf = new Uint8Array(this.length) + for (var i = 0, len = buf.length; i < len; i += 1) { + buf[i] = this[i] + } + return buf.buffer + } + } else { + throw new TypeError('Buffer.toArrayBuffer not supported in this browser') + } +} + +// HELPER FUNCTIONS +// ================ + +var BP = Buffer.prototype + +/** + * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods + */ +Buffer._augment = function (arr) { + arr.constructor = Buffer + arr._isBuffer = true + + // save reference to original Uint8Array get/set methods before overwriting + arr._get = arr.get + arr._set = arr.set + + // deprecated, will be removed in node 0.13+ + arr.get = BP.get + arr.set = BP.set + + arr.write = BP.write + arr.toString = BP.toString + arr.toLocaleString = BP.toString + arr.toJSON = BP.toJSON + arr.equals = BP.equals + arr.compare = BP.compare + arr.copy = BP.copy + arr.slice = BP.slice + arr.readUInt8 = BP.readUInt8 + arr.readUInt16LE = BP.readUInt16LE + arr.readUInt16BE = BP.readUInt16BE + arr.readUInt32LE = BP.readUInt32LE + arr.readUInt32BE = BP.readUInt32BE + arr.readInt8 = BP.readInt8 + arr.readInt16LE = BP.readInt16LE + arr.readInt16BE = BP.readInt16BE + arr.readInt32LE = BP.readInt32LE + arr.readInt32BE = BP.readInt32BE + arr.readFloatLE = BP.readFloatLE + arr.readFloatBE = BP.readFloatBE + arr.readDoubleLE = BP.readDoubleLE + arr.readDoubleBE = BP.readDoubleBE + arr.writeUInt8 = BP.writeUInt8 + arr.writeUInt16LE = BP.writeUInt16LE + arr.writeUInt16BE = BP.writeUInt16BE + arr.writeUInt32LE = BP.writeUInt32LE + arr.writeUInt32BE = BP.writeUInt32BE + arr.writeInt8 = BP.writeInt8 + arr.writeInt16LE = BP.writeInt16LE + arr.writeInt16BE = BP.writeInt16BE + arr.writeInt32LE = BP.writeInt32LE + arr.writeInt32BE = BP.writeInt32BE + arr.writeFloatLE = BP.writeFloatLE + arr.writeFloatBE = BP.writeFloatBE + arr.writeDoubleLE = BP.writeDoubleLE + arr.writeDoubleBE = BP.writeDoubleBE + arr.fill = BP.fill + arr.inspect = BP.inspect + arr.toArrayBuffer = BP.toArrayBuffer + + return arr +} + +var INVALID_BASE64_RE = /[^+\/0-9A-z]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, '') + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') +} + +function isArrayish (subject) { + return isArray(subject) || Buffer.isBuffer(subject) || + subject && typeof subject === 'object' && + typeof subject.length === 'number' +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; i++) { + var b = str.charCodeAt(i) + if (b <= 0x7F) { + byteArray.push(b) + } else { + var start = i + if (b >= 0xD800 && b <= 0xDFFF) i++ + var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%') + for (var j = 0; j < h.length; j++) { + byteArray.push(parseInt(h[j], 16)) + } + } + } + return byteArray +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; i++) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; i++) { + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(str) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; i++) { + if ((i + offset >= dst.length) || (i >= src.length)) + break + dst[i + offset] = src[i] + } + return i +} + +function decodeUtf8Char (str) { + try { + return decodeURIComponent(str) + } catch (err) { + return String.fromCharCode(0xFFFD) // UTF 8 invalid char + } +} + +},{"base64-js":46,"ieee754":47,"is-array":48}],46:[function(require,module,exports){ +var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + +;(function (exports) { + 'use strict'; + + var Arr = (typeof Uint8Array !== 'undefined') + ? Uint8Array + : Array + + var PLUS = '+'.charCodeAt(0) + var SLASH = '/'.charCodeAt(0) + var NUMBER = '0'.charCodeAt(0) + var LOWER = 'a'.charCodeAt(0) + var UPPER = 'A'.charCodeAt(0) + + function decode (elt) { + var code = elt.charCodeAt(0) + if (code === PLUS) + return 62 // '+' + if (code === SLASH) + return 63 // '/' + if (code < NUMBER) + return -1 //no match + if (code < NUMBER + 10) + return code - NUMBER + 26 + 26 + if (code < UPPER + 26) + return code - UPPER + if (code < LOWER + 26) + return code - LOWER + 26 + } + + function b64ToByteArray (b64) { + var i, j, l, tmp, placeHolders, arr + + if (b64.length % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + var len = b64.length + placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 + + // base64 is 4/3 + up to two characters of the original data + arr = new Arr(b64.length * 3 / 4 - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? b64.length - 4 : b64.length + + var L = 0 + + function push (v) { + arr[L++] = v + } + + for (i = 0, j = 0; i < l; i += 4, j += 3) { + tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) + push((tmp & 0xFF0000) >> 16) + push((tmp & 0xFF00) >> 8) + push(tmp & 0xFF) + } + + if (placeHolders === 2) { + tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) + push(tmp & 0xFF) + } else if (placeHolders === 1) { + tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) + push((tmp >> 8) & 0xFF) + push(tmp & 0xFF) + } + + return arr + } + + function uint8ToBase64 (uint8) { + var i, + extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes + output = "", + temp, length + + function encode (num) { + return lookup.charAt(num) + } + + function tripletToBase64 (num) { + return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) + } + + // go through the array every three bytes, we'll deal with trailing stuff later + for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { + temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output += tripletToBase64(temp) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + switch (extraBytes) { + case 1: + temp = uint8[uint8.length - 1] + output += encode(temp >> 2) + output += encode((temp << 4) & 0x3F) + output += '==' + break + case 2: + temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) + output += encode(temp >> 10) + output += encode((temp >> 4) & 0x3F) + output += encode((temp << 2) & 0x3F) + output += '=' + break + } + + return output + } + + exports.toByteArray = b64ToByteArray + exports.fromByteArray = uint8ToBase64 +}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) + +},{}],47:[function(require,module,exports){ +exports.read = function(buffer, offset, isLE, mLen, nBytes) { + var e, m, + eLen = nBytes * 8 - mLen - 1, + eMax = (1 << eLen) - 1, + eBias = eMax >> 1, + nBits = -7, + i = isLE ? (nBytes - 1) : 0, + d = isLE ? -1 : 1, + s = buffer[offset + i]; + + i += d; + + e = s & ((1 << (-nBits)) - 1); + s >>= (-nBits); + nBits += eLen; + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8); + + m = e & ((1 << (-nBits)) - 1); + e >>= (-nBits); + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8); + + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity); + } else { + m = m + Math.pow(2, mLen); + e = e - eBias; + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); +}; + +exports.write = function(buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c, + eLen = nBytes * 8 - mLen - 1, + eMax = (1 << eLen) - 1, + eBias = eMax >> 1, + rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0), + i = isLE ? 0 : (nBytes - 1), + d = isLE ? 1 : -1, + s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; + + value = Math.abs(value); + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e = e + eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8); + + e = (e << mLen) | m; + eLen += mLen; + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8); + + buffer[offset + i - d] |= s * 128; +}; + +},{}],48:[function(require,module,exports){ + +/** + * isArray + */ + +var isArray = Array.isArray; + +/** + * toString + */ + +var str = Object.prototype.toString; + +/** + * Whether or not the given `val` + * is an array. + * + * example: + * + * isArray([]); + * // > true + * isArray(arguments); + * // > false + * isArray(''); + * // > false + * + * @param {mixed} val + * @return {bool} + */ + +module.exports = isArray || function (val) { + return !! val && '[object Array]' == str.call(val); +}; + +},{}],49:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// 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. + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; +var splitPath = function(filename) { + return splitPathRe.exec(filename).slice(1); +}; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { + var isAbsolute = exports.isAbsolute(path), + trailingSlash = substr(path, -1) === '/'; + + // Normalize the path + path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + +// posix version +exports.isAbsolute = function(path) { + return path.charAt(0) === '/'; +}; + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + if (typeof p !== 'string') { + throw new TypeError('Arguments to path.join must be strings'); + } + return p; + }).join('/')); +}; + + +// path.relative(from, to) +// posix version +exports.relative = function(from, to) { + from = exports.resolve(from).substr(1); + to = exports.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +}; + +exports.sep = '/'; +exports.delimiter = ':'; + +exports.dirname = function(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +}; + + +exports.basename = function(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPath(path)[3]; +}; + +function filter (xs, f) { + if (xs.filter) return xs.filter(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + if (f(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// String.prototype.substr - negative index don't work in IE8 +var substr = 'ab'.substr(-1) === 'b' + ? function (str, start, len) { return str.substr(start, len) } + : function (str, start, len) { + if (start < 0) start = str.length + start; + return str.substr(start, len); + } +; + +}).call(this,require('_process')) +},{"_process":50}],50:[function(require,module,exports){ +// shim for using process in browser + +var process = module.exports = {}; + +process.nextTick = (function () { + var canSetImmediate = typeof window !== 'undefined' + && window.setImmediate; + var canMutationObserver = typeof window !== 'undefined' + && window.MutationObserver; + var canPost = typeof window !== 'undefined' + && window.postMessage && window.addEventListener + ; + + if (canSetImmediate) { + return function (f) { return window.setImmediate(f) }; + } + + var queue = []; + + if (canMutationObserver) { + var hiddenDiv = document.createElement("div"); + var observer = new MutationObserver(function () { + var queueList = queue.slice(); + queue.length = 0; + queueList.forEach(function (fn) { + fn(); + }); + }); + + observer.observe(hiddenDiv, { attributes: true }); + + return function nextTick(fn) { + if (!queue.length) { + hiddenDiv.setAttribute('yes', 'no'); + } + queue.push(fn); + }; + } + + if (canPost) { + window.addEventListener('message', function (ev) { + var source = ev.source; + if ((source === window || source === null) && ev.data === 'process-tick') { + ev.stopPropagation(); + if (queue.length > 0) { + var fn = queue.shift(); + fn(); + } + } + }, true); + + return function nextTick(fn) { + queue.push(fn); + window.postMessage('process-tick', '*'); + }; + } + + return function nextTick(fn) { + setTimeout(fn, 0); + }; +})(); + +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +// TODO(shtylman) +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; + +},{}],51:[function(require,module,exports){ +module.exports={"eras":{"e-34":"34 versions back","e-33":"33 versions back","e-32":"32 versions back","e-31":"31 versions back","e-30":"30 versions back","e-29":"29 versions back","e-28":"28 versions back","e-27":"27 versions back","e-26":"26 versions back","e-25":"25 versions back","e-24":"24 versions back","e-23":"23 versions back","e-22":"22 versions back","e-21":"21 versions back","e-20":"20 versions back","e-19":"19 versions back","e-18":"18 versions back","e-17":"17 versions back","e-16":"16 versions back","e-15":"15 versions back","e-14":"14 versions back","e-13":"13 versions back","e-12":"12 versions back","e-11":"11 versions back","e-10":"10 versions back","e-9":"9 versions back","e-8":"8 versions back","e-7":"7 versions back","e-6":"6 versions back","e-5":"5 versions back","e-4":"4 versions back","e-3":"3 versions back","e-2":"2 versions back","e-1":"Previous version","e0":"Current","e1":"Near future","e2":"Farther future","e3":"3 versions ahead"},"agents":{"ie":{"browser":"IE","abbr":"IE","prefix":"ms","type":"desktop","usage_global":{"5.5":0.009298,"6":0.147553,"7":0.0772897,"8":3.18293,"9":2.12898,"10":2.01656,"11":7.39873},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"5.5","6","7","8","9","10","11",null,null,null]},"firefox":{"browser":"Firefox","abbr":"FF","prefix":"moz","type":"desktop","usage_global":{"2":0.013434,"3":0.053736,"3.5":0.013434,"3.6":0.094038,"4":0.026868,"5":0.013434,"6":0.013434,"7":0.013434,"8":0.040302,"9":0.020151,"10":0.033585,"11":0.033585,"12":0.073887,"13":0.026868,"14":0.033585,"15":0.047019,"16":0.060453,"17":0.047019,"18":0.040302,"19":0.033585,"20":0.040302,"21":0.047019,"22":0.040302,"23":0.053736,"24":0.13434,"25":0.073887,"26":0.080604,"27":0.120906,"28":0.080604,"29":0.13434,"30":0.288831,"31":0.577662,"32":8.23504,"33":1.79344,"34":0.120906,"35":0.006717,"36":0},"versions":[null,"2","3","3.5","3.6","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36"]},"chrome":{"browser":"Chrome","abbr":"Chr.","prefix":"webkit","type":"desktop","usage_global":{"4":0.013434,"5":0.013434,"6":0.020151,"7":0.013434,"8":0.013434,"9":0.006717,"10":0.020151,"11":0.107472,"12":0.033585,"13":0.026868,"14":0.020151,"15":0.026868,"16":0.020151,"17":0.013434,"18":0.033585,"19":0.020151,"20":0.020151,"21":0.167925,"22":0.094038,"23":0.033585,"24":0.053736,"25":0.040302,"26":0.06717,"27":0.087321,"28":0.080604,"29":0.20151,"30":0.161208,"31":0.698568,"32":0.221661,"33":0.651549,"34":0.476907,"35":0.926946,"36":1.27623,"37":15.7312,"38":12.3929,"39":0.13434,"40":0.120906,"41":0},"versions":["4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38","39","40","41"]},"safari":{"browser":"Safari","abbr":"Saf.","prefix":"webkit","type":"desktop","usage_global":{"3.1":0,"3.2":0.008692,"4":0.080604,"5":0.154491,"5.1":0.503775,"6":0.147774,"6.1":0.396303,"7":0.987399,"7.1":0.759021,"8":0.308982},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"3.1","3.2","4","5","5.1","6","6.1","7","7.1","8",null,null,null]},"opera":{"browser":"Opera","abbr":"Op.","prefix":"webkit","type":"desktop","usage_global":{"9.5-9.6":0.00685,"10.0-10.1":0.020151,"10.5":0.008392,"10.6":0.007296,"11":0.014996,"11.1":0.008219,"11.5":0.00685,"11.6":0.013434,"12":0.013434,"12.1":0.174642,"15":0.00685,"16":0.00685,"17":0.00685,"18":0.013434,"19":0.006717,"20":0.020151,"21":0.013434,"22":0.013434,"23":0.013434,"24":0.295548,"25":0.295548,"26":0,"27":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,"9.5-9.6","10.0-10.1","10.5","10.6","11","11.1","11.5","11.6","12","12.1","15","16","17","18","19","20","21","22","23","24","25","26","27",null],"prefix_exceptions":{"9.5-9.6":"o","10.0-10.1":"o","10.5":"o","10.6":"o","11":"o","11.1":"o","11.5":"o","11.6":"o","12":"o","12.1":"o"}},"ios_saf":{"browser":"iOS Safari","abbr":"iOS","prefix":"webkit","type":"mobile","usage_global":{"3.2":0,"4.0-4.1":0,"4.2-4.3":0,"5.0-5.1":0.0579149,"6.0-6.1":0.25979,"7.0-7.1":3.59321,"8":3.15802,"8.1":1.15499},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"3.2","4.0-4.1","4.2-4.3","5.0-5.1","6.0-6.1","7.0-7.1","8","8.1",null,null,null]},"op_mini":{"browser":"Opera Mini","abbr":"O.Mini","prefix":"o","type":"mobile","usage_global":{"5.0-8.0":2.81805},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"5.0-8.0",null,null,null]},"android":{"browser":"Android Browser","abbr":"And.","prefix":"webkit","type":"mobile","usage_global":{"2.1":0,"2.2":0.00831376,"2.3":0.191216,"3":0.00623532,"4":0.421923,"4.1":1.24152,"4.2-4.3":1.8602,"4.4":2.36873,"4.4.3-4.4.4":0.773179,"37":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"2.1","2.2","2.3","3","4","4.1","4.2-4.3","4.4","4.4.3-4.4.4","37",null,null]},"op_mob":{"browser":"Opera Mobile","abbr":"O.Mob","prefix":"o","type":"mobile","usage_global":{"10":0,"11.5":0,"12":0.00813289,"12.1":0.036598,"24":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"10",null,null,"11.5","12","12.1","24",null,null,null],"prefix_exceptions":{"24":"webkit"}},"bb":{"browser":"Blackberry Browser","abbr":"BB","prefix":"webkit","type":"mobile","usage_global":{"7":0.0878202,"10":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"7","10",null,null,null]},"and_chr":{"browser":"Chrome for Android","abbr":"Chr/And.","prefix":"webkit","type":"mobile","usage_global":{"38":9.5135},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"38",null,null,null]},"and_ff":{"browser":"Firefox for Android","abbr":"FF/And.","prefix":"moz","type":"mobile","usage_global":{"32":0.154301},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"32",null,null,null]},"ie_mob":{"browser":"IE Mobile","abbr":"IE.Mob","prefix":"ms","type":"mobile","usage_global":{"10":0.458602},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"10",null,null,null]},"and_uc":{"browser":"UC Browser for Android","abbr":"UC","prefix":"webkit","type":"mobile","usage_global":{"9.9":2.86934},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"9.9",null,null,null],"prefix_exceptions":{"9.9":"webkit"}}},"statuses":{"rec":"Recommendation","pr":"Proposed Recommendation","cr":"Candidate Recommendation","wd":"Working Draft","other":"Other","unoff":"Unofficial / Note"},"cats":{"CSS":["CSS","CSS2","CSS3"],"HTML5":["HTML5","Canvas"],"JS API":["JS API"],"Other":["Other","DOM","PNG"],"SVG":["SVG"]},"updated":1414898285,"data":{"png-alpha":{"title":"PNG alpha transparency","description":"Semi-transparent areas in PNG files","spec":"http://www.w3.org/TR/PNG/","status":"rec","links":[{"url":"http://en.wikipedia.org/wiki/Portable_Network_Graphics","title":"Wikipedia"},{"url":"http://dillerdesign.com/experiment/DD_belatedPNG/","title":"Workaround for IE6"}],"categories":["PNG"],"stats":{"ie":{"5.5":"n","6":"p","7":"y","8":"y","9":"y","10":"y","11":"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"},"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"},"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"},"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":{"38":"y"},"and_ff":{"32":"y"},"ie_mob":{"10":"y"},"and_uc":{"9.9":"y"}},"notes":"IE6 does support full transparency in 8-bit PNGs, which can sometimes be an alternative to 24-bit PNGs.","notes_by_num":{},"usage_perc_y":96.77,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"apng":{"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"}],"categories":["PNG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"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"},"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"},"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"},"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":{"38":"n"},"and_ff":{"32":"y"},"ie_mob":{"10":"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":17.64,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"video":{"title":"Video element","description":"Method of playing videos on webpages (without requiring a plug-in)","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#the-video-element","status":"cr","links":[{"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://webmproject.org","title":"WebM format information"},{"url":"http://camendesign.co.uk/code/video_for_everybody","title":"Video for Everybody"},{"url":"http://diveintohtml5.info/video.html","title":"Video on the Web - includes info on Android support"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/video.js#video","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/video","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"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"},"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"},"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":"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"},"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":"a","2.2":"a","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":{"38":"y"},"and_ff":{"32":"y"},"ie_mob":{"10":"y"},"and_uc":{"9.9":"y"}},"notes":"Different browsers have support for different video formats, see sub-features for details. \r\n\r\nThe Android browser (before 2.3) requires [specific handling](http://www.broken-links.com/2010/07/08/making-html5-video-work-on-android-phones/) to run the video element.","notes_by_num":{},"usage_perc_y":90.57,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"