diff options
Diffstat (limited to 'node_modules/autoprefixer/lib')
72 files changed, 8949 insertions, 0 deletions
diff --git a/node_modules/autoprefixer/lib/at-rule.js b/node_modules/autoprefixer/lib/at-rule.js new file mode 100644 index 0000000..3abf80b --- /dev/null +++ b/node_modules/autoprefixer/lib/at-rule.js @@ -0,0 +1,69 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +var Prefixer = require('./prefixer'); + +var AtRule = +/*#__PURE__*/ +function (_Prefixer) { + _inheritsLoose(AtRule, _Prefixer); + + function AtRule() { + return _Prefixer.apply(this, arguments) || this; + } + + var _proto = AtRule.prototype; + + /** + * Clone and add prefixes for at-rule + */ + _proto.add = function add(rule, prefix) { + var prefixed = prefix + rule.name; + var already = rule.parent.some(function (i) { + return i.name === prefixed && i.params === rule.params; + }); + + if (already) { + return undefined; + } + + var cloned = this.clone(rule, { + name: prefixed + }); + return rule.parent.insertBefore(rule, cloned); + } + /** + * Clone node with prefixes + */ + ; + + _proto.process = function process(node) { + var parent = this.parentPrefix(node); + + for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + + if (!parent || parent === prefix) { + this.add(node, prefix); + } + } + }; + + return AtRule; +}(Prefixer); + +module.exports = AtRule;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/autoprefixer.js b/node_modules/autoprefixer/lib/autoprefixer.js new file mode 100644 index 0000000..ce70740 --- /dev/null +++ b/node_modules/autoprefixer/lib/autoprefixer.js @@ -0,0 +1,157 @@ +"use strict"; + +var browserslist = require('browserslist'); + +var postcss = require('postcss'); + +var agents = require('caniuse-lite').agents; + +var chalk = require('chalk'); + +var Browsers = require('./browsers'); + +var Prefixes = require('./prefixes'); + +var data = require('../data/prefixes'); + +var info = require('./info'); + +var WARNING = '\n' + ' Replace Autoprefixer `browsers` option to Browserslist config.\n' + ' Use `browserslist` key in `package.json` or `.browserslistrc` file.\n' + '\n' + ' Using `browsers` option cause some error. Browserslist config \n' + ' can be used for Babel, Autoprefixer, postcss-normalize and other tools.\n' + '\n' + ' If you really need to use option, rename it to `overrideBrowserslist`.\n' + '\n' + ' Learn more at:\n' + ' https://github.com/browserslist/browserslist#readme\n' + ' https://twitter.com/browserslist\n' + '\n'; + +function isPlainObject(obj) { + return Object.prototype.toString.apply(obj) === '[object Object]'; +} + +var cache = {}; + +function timeCapsule(result, prefixes) { + if (prefixes.browsers.selected.length === 0) { + return; + } + + if (prefixes.add.selectors.length > 0) { + return; + } + + if (Object.keys(prefixes.add).length > 2) { + return; + } + /* istanbul ignore next */ + + + result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.'); +} + +module.exports = postcss.plugin('autoprefixer', function () { + for (var _len = arguments.length, reqs = new Array(_len), _key = 0; _key < _len; _key++) { + reqs[_key] = arguments[_key]; + } + + var options; + + if (reqs.length === 1 && isPlainObject(reqs[0])) { + options = reqs[0]; + reqs = undefined; + } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) { + reqs = undefined; + } else if (reqs.length <= 2 && (Array.isArray(reqs[0]) || !reqs[0])) { + options = reqs[1]; + reqs = reqs[0]; + } else if (typeof reqs[reqs.length - 1] === 'object') { + options = reqs.pop(); + } + + if (!options) { + options = {}; + } + + if (options.browser) { + throw new Error('Change `browser` option to `overrideBrowserslist` in Autoprefixer'); + } else if (options.browserslist) { + throw new Error('Change `browserslist` option to `overrideBrowserslist` in Autoprefixer'); + } + + if (options.overrideBrowserslist) { + reqs = options.overrideBrowserslist; + } else if (options.browsers) { + if (typeof console !== 'undefined' && console.warn) { + if (chalk && chalk.red) { + console.warn(chalk.red(WARNING.replace(/`[^`]+`/g, function (i) { + return chalk.yellow(i.slice(1, -1)); + }))); + } else { + console.warn(WARNING); + } + } + + reqs = options.browsers; + } + + if (typeof options.grid === 'undefined') { + options.grid = false; + } + + var brwlstOpts = { + ignoreUnknownVersions: options.ignoreUnknownVersions, + stats: options.stats + }; + + function loadPrefixes(opts) { + var d = module.exports.data; + var browsers = new Browsers(d.browsers, reqs, opts, brwlstOpts); + var key = browsers.selected.join(', ') + JSON.stringify(options); + + if (!cache[key]) { + cache[key] = new Prefixes(d.prefixes, browsers, options); + } + + return cache[key]; + } + + function plugin(css, result) { + var prefixes = loadPrefixes({ + from: css.source && css.source.input.file, + env: options.env + }); + timeCapsule(result, prefixes); + + if (options.remove !== false) { + prefixes.processor.remove(css, result); + } + + if (options.add !== false) { + prefixes.processor.add(css, result); + } + } + + plugin.options = options; + plugin.browsers = reqs; + + plugin.info = function (opts) { + opts = opts || {}; + opts.from = opts.from || process.cwd(); + return info(loadPrefixes(opts)); + }; + + return plugin; +}); +/** + * Autoprefixer data + */ + +module.exports.data = { + browsers: agents, + prefixes: data +}; +/** + * Autoprefixer default browsers + */ + +module.exports.defaults = browserslist.defaults; +/** + * Inspect with default Autoprefixer + */ + +module.exports.info = function () { + return module.exports().info(); +};
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/brackets.js b/node_modules/autoprefixer/lib/brackets.js new file mode 100644 index 0000000..c548609 --- /dev/null +++ b/node_modules/autoprefixer/lib/brackets.js @@ -0,0 +1,80 @@ +"use strict"; + +function last(array) { + return array[array.length - 1]; +} + +var brackets = { + /** + * Parse string to nodes tree + */ + parse: function parse(str) { + var current = ['']; + var stack = [current]; + + for (var _iterator = str, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var sym = _ref; + + if (sym === '(') { + current = ['']; + last(stack).push(current); + stack.push(current); + continue; + } + + if (sym === ')') { + stack.pop(); + current = last(stack); + current.push(''); + continue; + } + + current[current.length - 1] += sym; + } + + return stack[0]; + }, + + /** + * Generate output string by nodes tree + */ + stringify: function stringify(ast) { + var result = ''; + + for (var _iterator2 = ast, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var i = _ref2; + + if (typeof i === 'object') { + result += "(" + brackets.stringify(i) + ")"; + continue; + } + + result += i; + } + + return result; + } +}; +module.exports = brackets;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/browsers.js b/node_modules/autoprefixer/lib/browsers.js new file mode 100644 index 0000000..f2166f1 --- /dev/null +++ b/node_modules/autoprefixer/lib/browsers.js @@ -0,0 +1,99 @@ +"use strict"; + +var browserslist = require('browserslist'); + +var agents = require('caniuse-lite').agents; + +var utils = require('./utils'); + +var Browsers = +/*#__PURE__*/ +function () { + /** + * Return all prefixes for default browser data + */ + Browsers.prefixes = function prefixes() { + if (this.prefixesCache) { + return this.prefixesCache; + } + + this.prefixesCache = []; + + for (var name in agents) { + this.prefixesCache.push("-" + agents[name].prefix + "-"); + } + + this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) { + return b.length - a.length; + }); + return this.prefixesCache; + } + /** + * Check is value contain any possible prefix + */ + ; + + Browsers.withPrefix = function withPrefix(value) { + if (!this.prefixesRegexp) { + this.prefixesRegexp = new RegExp(this.prefixes().join('|')); + } + + return this.prefixesRegexp.test(value); + }; + + function Browsers(data, requirements, options, browserslistOpts) { + this.data = data; + this.options = options || {}; + this.browserslistOpts = browserslistOpts || {}; + this.selected = this.parse(requirements); + } + /** + * Return browsers selected by requirements + */ + + + var _proto = Browsers.prototype; + + _proto.parse = function parse(requirements) { + var opts = {}; + + for (var i in this.browserslistOpts) { + opts[i] = this.browserslistOpts[i]; + } + + opts.path = this.options.from; + opts.env = this.options.env; + return browserslist(requirements, opts); + } + /** + * Return prefix for selected browser + */ + ; + + _proto.prefix = function prefix(browser) { + var _browser$split = browser.split(' '), + name = _browser$split[0], + version = _browser$split[1]; + + var data = this.data[name]; + var prefix = data.prefix_exceptions && data.prefix_exceptions[version]; + + if (!prefix) { + prefix = data.prefix; + } + + return "-" + prefix + "-"; + } + /** + * Is browser is selected by requirements + */ + ; + + _proto.isSelected = function isSelected(browser) { + return this.selected.includes(browser); + }; + + return Browsers; +}(); + +module.exports = Browsers;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/declaration.js b/node_modules/autoprefixer/lib/declaration.js new file mode 100644 index 0000000..3674d2c --- /dev/null +++ b/node_modules/autoprefixer/lib/declaration.js @@ -0,0 +1,261 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +var Prefixer = require('./prefixer'); + +var Browsers = require('./browsers'); + +var utils = require('./utils'); + +var Declaration = +/*#__PURE__*/ +function (_Prefixer) { + _inheritsLoose(Declaration, _Prefixer); + + function Declaration() { + return _Prefixer.apply(this, arguments) || this; + } + + var _proto = Declaration.prototype; + + /** + * Always true, because we already get prefixer by property name + */ + _proto.check = function check() + /* decl */ + { + return true; + } + /** + * Return prefixed version of property + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + prop; + } + /** + * Return unprefixed version of property + */ + ; + + _proto.normalize = function normalize(prop) { + return prop; + } + /** + * Check `value`, that it contain other prefixes, rather than `prefix` + */ + ; + + _proto.otherPrefixes = function otherPrefixes(value, prefix) { + for (var _iterator = Browsers.prefixes(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var other = _ref; + + if (other === prefix) { + continue; + } + + if (value.includes(other)) { + return true; + } + } + + return false; + } + /** + * Set prefix to declaration + */ + ; + + _proto.set = function set(decl, prefix) { + decl.prop = this.prefixed(decl.prop, prefix); + return decl; + } + /** + * Should we use visual cascade for prefixes + */ + ; + + _proto.needCascade = function needCascade(decl) { + if (!decl._autoprefixerCascade) { + decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').includes('\n'); + } + + return decl._autoprefixerCascade; + } + /** + * Return maximum length of possible prefixed property + */ + ; + + _proto.maxPrefixed = function maxPrefixed(prefixes, decl) { + if (decl._autoprefixerMax) { + return decl._autoprefixerMax; + } + + var max = 0; + + for (var _iterator2 = prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var prefix = _ref2; + prefix = utils.removeNote(prefix); + + if (prefix.length > max) { + max = prefix.length; + } + } + + decl._autoprefixerMax = max; + return decl._autoprefixerMax; + } + /** + * Calculate indentation to create visual cascade + */ + ; + + _proto.calcBefore = function calcBefore(prefixes, decl, prefix) { + if (prefix === void 0) { + prefix = ''; + } + + var max = this.maxPrefixed(prefixes, decl); + var diff = max - utils.removeNote(prefix).length; + var before = decl.raw('before'); + + if (diff > 0) { + before += Array(diff).fill(' ').join(''); + } + + return before; + } + /** + * Remove visual cascade + */ + ; + + _proto.restoreBefore = function restoreBefore(decl) { + var lines = decl.raw('before').split('\n'); + var min = lines[lines.length - 1]; + this.all.group(decl).up(function (prefixed) { + var array = prefixed.raw('before').split('\n'); + var last = array[array.length - 1]; + + if (last.length < min.length) { + min = last; + } + }); + lines[lines.length - 1] = min; + decl.raws.before = lines.join('\n'); + } + /** + * Clone and insert new declaration + */ + ; + + _proto.insert = function insert(decl, prefix, prefixes) { + var cloned = this.set(this.clone(decl), prefix); + if (!cloned) return undefined; + var already = decl.parent.some(function (i) { + return i.prop === cloned.prop && i.value === cloned.value; + }); + + if (already) { + return undefined; + } + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + return decl.parent.insertBefore(decl, cloned); + } + /** + * Did this declaration has this prefix above + */ + ; + + _proto.isAlready = function isAlready(decl, prefixed) { + var already = this.all.group(decl).up(function (i) { + return i.prop === prefixed; + }); + + if (!already) { + already = this.all.group(decl).down(function (i) { + return i.prop === prefixed; + }); + } + + return already; + } + /** + * Clone and add prefixes for declaration + */ + ; + + _proto.add = function add(decl, prefix, prefixes, result) { + var prefixed = this.prefixed(decl.prop, prefix); + + if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) { + return undefined; + } + + return this.insert(decl, prefix, prefixes, result); + } + /** + * Add spaces for visual cascade + */ + ; + + _proto.process = function process(decl, result) { + if (!this.needCascade(decl)) { + _Prefixer.prototype.process.call(this, decl, result); + + return; + } + + var prefixes = _Prefixer.prototype.process.call(this, decl, result); + + if (!prefixes || !prefixes.length) { + return; + } + + this.restoreBefore(decl); + decl.raws.before = this.calcBefore(prefixes, decl); + } + /** + * Return list of prefixed properties to clean old prefixes + */ + ; + + _proto.old = function old(prop, prefix) { + return [this.prefixed(prop, prefix)]; + }; + + return Declaration; +}(Prefixer); + +module.exports = Declaration;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/align-content.js b/node_modules/autoprefixer/lib/hacks/align-content.js new file mode 100644 index 0000000..2796f56 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/align-content.js @@ -0,0 +1,81 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var AlignContent = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(AlignContent, _Declaration); + + function AlignContent() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = AlignContent.prototype; + + /** + * Change property name for 2012 spec + */ + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-line-pack'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'align-content'; + } + /** + * Change value for 2012 spec and ignore prefix for 2009 + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2012) { + decl.value = AlignContent.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } + + if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return AlignContent; +}(Declaration); + +_defineProperty(AlignContent, "names", ['align-content', 'flex-line-pack']); + +_defineProperty(AlignContent, "oldValues", { + 'flex-end': 'end', + 'flex-start': 'start', + 'space-between': 'justify', + 'space-around': 'distribute' +}); + +module.exports = AlignContent;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/align-items.js b/node_modules/autoprefixer/lib/hacks/align-items.js new file mode 100644 index 0000000..a9ed9ba --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/align-items.js @@ -0,0 +1,78 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var AlignItems = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(AlignItems, _Declaration); + + function AlignItems() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = AlignItems.prototype; + + /** + * Change property name for 2009 and 2012 specs + */ + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-align'; + } + + if (spec === 2012) { + return prefix + 'flex-align'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'align-items'; + } + /** + * Change value for 2009 and 2012 specs + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2009 || spec === 2012) { + decl.value = AlignItems.oldValues[decl.value] || decl.value; + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return AlignItems; +}(Declaration); + +_defineProperty(AlignItems, "names", ['align-items', 'flex-align', 'box-align']); + +_defineProperty(AlignItems, "oldValues", { + 'flex-end': 'end', + 'flex-start': 'start' +}); + +module.exports = AlignItems;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/align-self.js b/node_modules/autoprefixer/lib/hacks/align-self.js new file mode 100644 index 0000000..9a2b5f6 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/align-self.js @@ -0,0 +1,86 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var AlignSelf = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(AlignSelf, _Declaration); + + function AlignSelf() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = AlignSelf.prototype; + + _proto.check = function check(decl) { + return decl.parent && decl.parent.every(function (i) { + return !/^grid-/.test(i.prop); + }); + } + /** + * Change property name for 2012 specs + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-item-align'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'align-self'; + } + /** + * Change value for 2012 spec and ignore prefix for 2009 + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2012) { + decl.value = AlignSelf.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } + + if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return AlignSelf; +}(Declaration); + +_defineProperty(AlignSelf, "names", ['align-self', 'flex-item-align']); + +_defineProperty(AlignSelf, "oldValues", { + 'flex-end': 'end', + 'flex-start': 'start' +}); + +module.exports = AlignSelf;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/animation.js b/node_modules/autoprefixer/lib/hacks/animation.js new file mode 100644 index 0000000..55a03d9 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/animation.js @@ -0,0 +1,37 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var Animation = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Animation, _Declaration); + + function Animation() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = Animation.prototype; + + /** + * Don’t add prefixes for modern values. + */ + _proto.check = function check(decl) { + return !decl.value.split(/\s+/).some(function (i) { + var lower = i.toLowerCase(); + return lower === 'reverse' || lower === 'alternate-reverse'; + }); + }; + + return Animation; +}(Declaration); + +_defineProperty(Animation, "names", ['animation', 'animation-direction']); + +module.exports = Animation;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/appearance.js b/node_modules/autoprefixer/lib/hacks/appearance.js new file mode 100644 index 0000000..29424d9 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/appearance.js @@ -0,0 +1,41 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('../utils'); + +var Appearance = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Appearance, _Declaration); + + function Appearance(name, prefixes, all) { + var _this; + + _this = _Declaration.call(this, name, prefixes, all) || this; + + if (_this.prefixes) { + _this.prefixes = utils.uniq(_this.prefixes.map(function (i) { + if (i === '-ms-') { + return '-webkit-'; + } + + return i; + })); + } + + return _this; + } + + return Appearance; +}(Declaration); + +_defineProperty(Appearance, "names", ['appearance']); + +module.exports = Appearance;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/backdrop-filter.js b/node_modules/autoprefixer/lib/hacks/backdrop-filter.js new file mode 100644 index 0000000..5b97e82 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/backdrop-filter.js @@ -0,0 +1,37 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('../utils'); + +var BackdropFilter = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BackdropFilter, _Declaration); + + function BackdropFilter(name, prefixes, all) { + var _this; + + _this = _Declaration.call(this, name, prefixes, all) || this; + + if (_this.prefixes) { + _this.prefixes = utils.uniq(_this.prefixes.map(function (i) { + return i === '-ms-' ? '-webkit-' : i; + })); + } + + return _this; + } + + return BackdropFilter; +}(Declaration); + +_defineProperty(BackdropFilter, "names", ['backdrop-filter']); + +module.exports = BackdropFilter;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/background-clip.js b/node_modules/autoprefixer/lib/hacks/background-clip.js new file mode 100644 index 0000000..58fcbb6 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/background-clip.js @@ -0,0 +1,43 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('../utils'); + +var BackgroundClip = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BackgroundClip, _Declaration); + + function BackgroundClip(name, prefixes, all) { + var _this; + + _this = _Declaration.call(this, name, prefixes, all) || this; + + if (_this.prefixes) { + _this.prefixes = utils.uniq(_this.prefixes.map(function (i) { + return i === '-ms-' ? '-webkit-' : i; + })); + } + + return _this; + } + + var _proto = BackgroundClip.prototype; + + _proto.check = function check(decl) { + return decl.value.toLowerCase() === 'text'; + }; + + return BackgroundClip; +}(Declaration); + +_defineProperty(BackgroundClip, "names", ['background-clip']); + +module.exports = BackgroundClip;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/background-size.js b/node_modules/autoprefixer/lib/hacks/background-size.js new file mode 100644 index 0000000..2b9a035 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/background-size.js @@ -0,0 +1,40 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BackgroundSize = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BackgroundSize, _Declaration); + + function BackgroundSize() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = BackgroundSize.prototype; + + /** + * Duplication parameter for -webkit- browsers + */ + _proto.set = function set(decl, prefix) { + var value = decl.value.toLowerCase(); + + if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') { + decl.value = decl.value + ' ' + decl.value; + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return BackgroundSize; +}(Declaration); + +_defineProperty(BackgroundSize, "names", ['background-size']); + +module.exports = BackgroundSize;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/block-logical.js b/node_modules/autoprefixer/lib/hacks/block-logical.js new file mode 100644 index 0000000..e89ab81 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/block-logical.js @@ -0,0 +1,50 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BlockLogical = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BlockLogical, _Declaration); + + function BlockLogical() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = BlockLogical.prototype; + + /** + * Use old syntax for -moz- and -webkit- + */ + _proto.prefixed = function prefixed(prop, prefix) { + if (prop.indexOf('-start') !== -1) { + return prefix + prop.replace('-block-start', '-before'); + } + + return prefix + prop.replace('-block-end', '-after'); + } + /** + * Return property name by spec + */ + ; + + _proto.normalize = function normalize(prop) { + if (prop.indexOf('-before') !== -1) { + return prop.replace('-before', '-block-start'); + } + + return prop.replace('-after', '-block-end'); + }; + + return BlockLogical; +}(Declaration); + +_defineProperty(BlockLogical, "names", ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']); + +module.exports = BlockLogical;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/border-image.js b/node_modules/autoprefixer/lib/hacks/border-image.js new file mode 100644 index 0000000..aebd64a --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/border-image.js @@ -0,0 +1,35 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BorderImage = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BorderImage, _Declaration); + + function BorderImage() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = BorderImage.prototype; + + /** + * Remove fill parameter for prefixed declarations + */ + _proto.set = function set(decl, prefix) { + decl.value = decl.value.replace(/\s+fill(\s)/, '$1'); + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return BorderImage; +}(Declaration); + +_defineProperty(BorderImage, "names", ['border-image']); + +module.exports = BorderImage;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/border-radius.js b/node_modules/autoprefixer/lib/hacks/border-radius.js new file mode 100644 index 0000000..3bd42fc --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/border-radius.js @@ -0,0 +1,64 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BorderRadius = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BorderRadius, _Declaration); + + function BorderRadius() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = BorderRadius.prototype; + + /** + * Change syntax, when add Mozilla prefix + */ + _proto.prefixed = function prefixed(prop, prefix) { + if (prefix === '-moz-') { + return prefix + (BorderRadius.toMozilla[prop] || prop); + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return unprefixed version of property + */ + ; + + _proto.normalize = function normalize(prop) { + return BorderRadius.toNormal[prop] || prop; + }; + + return BorderRadius; +}(Declaration); + +_defineProperty(BorderRadius, "names", ['border-radius']); + +_defineProperty(BorderRadius, "toMozilla", {}); + +_defineProperty(BorderRadius, "toNormal", {}); + +for (var _i = 0, _arr = ['top', 'bottom']; _i < _arr.length; _i++) { + var ver = _arr[_i]; + + for (var _i2 = 0, _arr2 = ['left', 'right']; _i2 < _arr2.length; _i2++) { + var hor = _arr2[_i2]; + var normal = "border-" + ver + "-" + hor + "-radius"; + var mozilla = "border-radius-" + ver + hor; + BorderRadius.names.push(normal); + BorderRadius.names.push(mozilla); + BorderRadius.toMozilla[normal] = mozilla; + BorderRadius.toNormal[mozilla] = normal; + } +} + +module.exports = BorderRadius;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/break-props.js b/node_modules/autoprefixer/lib/hacks/break-props.js new file mode 100644 index 0000000..7433035 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/break-props.js @@ -0,0 +1,78 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BreakProps = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(BreakProps, _Declaration); + + function BreakProps() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = BreakProps.prototype; + + /** + * Change name for -webkit- and -moz- prefix + */ + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + "column-" + prop; + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize(prop) { + if (prop.indexOf('inside') !== -1) { + return 'break-inside'; + } + + if (prop.indexOf('before') !== -1) { + return 'break-before'; + } + + return 'break-after'; + } + /** + * Change prefixed value for avoid-column and avoid-page + */ + ; + + _proto.set = function set(decl, prefix) { + if (decl.prop === 'break-inside' && decl.value === 'avoid-column' || decl.value === 'avoid-page') { + decl.value = 'avoid'; + } + + return _Declaration.prototype.set.call(this, decl, prefix); + } + /** + * Don’t prefix some values + */ + ; + + _proto.insert = function insert(decl, prefix, prefixes) { + if (decl.prop !== 'break-inside') { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + + if (/region/i.test(decl.value) || /page/i.test(decl.value)) { + return undefined; + } + + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + }; + + return BreakProps; +}(Declaration); + +_defineProperty(BreakProps, "names", ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']); + +module.exports = BreakProps;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/color-adjust.js b/node_modules/autoprefixer/lib/hacks/color-adjust.js new file mode 100644 index 0000000..70f332d --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/color-adjust.js @@ -0,0 +1,42 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var ColorAdjust = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(ColorAdjust, _Declaration); + + function ColorAdjust() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = ColorAdjust.prototype; + + /** + * Change property name for WebKit-based browsers + */ + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + 'print-color-adjust'; + } + /** + * Return property name by spec + */ + ; + + _proto.normalize = function normalize() { + return 'color-adjust'; + }; + + return ColorAdjust; +}(Declaration); + +_defineProperty(ColorAdjust, "names", ['color-adjust', 'print-color-adjust']); + +module.exports = ColorAdjust;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/cross-fade.js b/node_modules/autoprefixer/lib/hacks/cross-fade.js new file mode 100644 index 0000000..b1f0b6e --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/cross-fade.js @@ -0,0 +1,56 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var list = require('postcss').list; + +var Value = require('../value'); + +var CrossFade = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(CrossFade, _Value); + + function CrossFade() { + return _Value.apply(this, arguments) || this; + } + + var _proto = CrossFade.prototype; + + _proto.replace = function replace(string, prefix) { + var _this = this; + + return list.space(string).map(function (value) { + if (value.slice(0, +_this.name.length + 1) !== _this.name + '(') { + return value; + } + + var close = value.lastIndexOf(')'); + var after = value.slice(close + 1); + var args = value.slice(_this.name.length + 1, close); + + if (prefix === '-webkit-') { + var match = args.match(/\d*.?\d+%?/); + + if (match) { + args = args.slice(match[0].length).trim(); + args += ", " + match[0]; + } else { + args += ', 0.5'; + } + } + + return prefix + _this.name + '(' + args + ')' + after; + }).join(' '); + }; + + return CrossFade; +}(Value); + +_defineProperty(CrossFade, "names", ['cross-fade']); + +module.exports = CrossFade;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/display-flex.js b/node_modules/autoprefixer/lib/hacks/display-flex.js new file mode 100644 index 0000000..1da30b3 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/display-flex.js @@ -0,0 +1,96 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var OldValue = require('../old-value'); + +var Value = require('../value'); + +var DisplayFlex = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(DisplayFlex, _Value); + + function DisplayFlex(name, prefixes) { + var _this; + + _this = _Value.call(this, name, prefixes) || this; + + if (name === 'display-flex') { + _this.name = 'flex'; + } + + return _this; + } + /** + * Faster check for flex value + */ + + + var _proto = DisplayFlex.prototype; + + _proto.check = function check(decl) { + return decl.prop === 'display' && decl.value === this.name; + } + /** + * Return value by spec + */ + ; + + _proto.prefixed = function prefixed(prefix) { + var spec, value; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + if (this.name === 'flex') { + value = 'box'; + } else { + value = 'inline-box'; + } + } else if (spec === 2012) { + if (this.name === 'flex') { + value = 'flexbox'; + } else { + value = 'inline-flexbox'; + } + } else if (spec === 'final') { + value = this.name; + } + + return prefix + value; + } + /** + * Add prefix to value depend on flebox spec version + */ + ; + + _proto.replace = function replace(string, prefix) { + return this.prefixed(prefix); + } + /** + * Change value for old specs + */ + ; + + _proto.old = function old(prefix) { + var prefixed = this.prefixed(prefix); + if (!prefixed) return undefined; + return new OldValue(this.name, prefixed); + }; + + return DisplayFlex; +}(Value); + +_defineProperty(DisplayFlex, "names", ['display-flex', 'inline-flex']); + +module.exports = DisplayFlex;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/display-grid.js b/node_modules/autoprefixer/lib/hacks/display-grid.js new file mode 100644 index 0000000..bc63bf8 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/display-grid.js @@ -0,0 +1,43 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Value = require('../value'); + +var DisplayGrid = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(DisplayGrid, _Value); + + function DisplayGrid(name, prefixes) { + var _this; + + _this = _Value.call(this, name, prefixes) || this; + + if (name === 'display-grid') { + _this.name = 'grid'; + } + + return _this; + } + /** + * Faster check for flex value + */ + + + var _proto = DisplayGrid.prototype; + + _proto.check = function check(decl) { + return decl.prop === 'display' && decl.value === this.name; + }; + + return DisplayGrid; +}(Value); + +_defineProperty(DisplayGrid, "names", ['display-grid', 'inline-grid']); + +module.exports = DisplayGrid;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/filter-value.js b/node_modules/autoprefixer/lib/hacks/filter-value.js new file mode 100644 index 0000000..c4c6416 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/filter-value.js @@ -0,0 +1,33 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Value = require('../value'); + +var FilterValue = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(FilterValue, _Value); + + function FilterValue(name, prefixes) { + var _this; + + _this = _Value.call(this, name, prefixes) || this; + + if (name === 'filter-function') { + _this.name = 'filter'; + } + + return _this; + } + + return FilterValue; +}(Value); + +_defineProperty(FilterValue, "names", ['filter', 'filter-function']); + +module.exports = FilterValue;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/filter.js b/node_modules/autoprefixer/lib/hacks/filter.js new file mode 100644 index 0000000..9d44404 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/filter.js @@ -0,0 +1,35 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var Filter = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Filter, _Declaration); + + function Filter() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = Filter.prototype; + + /** + * Check is it Internet Explorer filter + */ + _proto.check = function check(decl) { + var v = decl.value; + return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1; + }; + + return Filter; +}(Declaration); + +_defineProperty(Filter, "names", ['filter']); + +module.exports = Filter;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-basis.js b/node_modules/autoprefixer/lib/hacks/flex-basis.js new file mode 100644 index 0000000..351d61d --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-basis.js @@ -0,0 +1,74 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var FlexBasis = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(FlexBasis, _Declaration); + + function FlexBasis() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = FlexBasis.prototype; + + /** + * Return property name by final spec + */ + _proto.normalize = function normalize() { + return 'flex-basis'; + } + /** + * Return flex property for 2012 spec + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-preferred-size'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Ignore 2009 spec and use flex property for 2012 + */ + ; + + _proto.set = function set(decl, prefix) { + var spec; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2012 || spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return FlexBasis; +}(Declaration); + +_defineProperty(FlexBasis, "names", ['flex-basis', 'flex-preferred-size']); + +module.exports = FlexBasis;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-direction.js b/node_modules/autoprefixer/lib/hacks/flex-direction.js new file mode 100644 index 0000000..bac62af --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-direction.js @@ -0,0 +1,110 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var FlexDirection = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(FlexDirection, _Declaration); + + function FlexDirection() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = FlexDirection.prototype; + + /** + * Return property name by final spec + */ + _proto.normalize = function normalize() { + return 'flex-direction'; + } + /** + * Use two properties for 2009 spec + */ + ; + + _proto.insert = function insert(decl, prefix, prefixes) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec !== 2009) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + + var already = decl.parent.some(function (i) { + return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction'; + }); + + if (already) { + return undefined; + } + + var v = decl.value; + var orient, dir; + + if (v === 'inherit' || v === 'initial' || v === 'unset') { + orient = v; + dir = v; + } else { + orient = v.indexOf('row') !== -1 ? 'horizontal' : 'vertical'; + dir = v.indexOf('reverse') !== -1 ? 'reverse' : 'normal'; + } + + var cloned = this.clone(decl); + cloned.prop = prefix + 'box-orient'; + cloned.value = orient; + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + decl.parent.insertBefore(decl, cloned); + cloned = this.clone(decl); + cloned.prop = prefix + 'box-direction'; + cloned.value = dir; + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + return decl.parent.insertBefore(decl, cloned); + } + /** + * Clean two properties for 2009 spec + */ + ; + + _proto.old = function old(prop, prefix) { + var spec; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2009) { + return [prefix + 'box-orient', prefix + 'box-direction']; + } else { + return _Declaration.prototype.old.call(this, prop, prefix); + } + }; + + return FlexDirection; +}(Declaration); + +_defineProperty(FlexDirection, "names", ['flex-direction', 'box-direction', 'box-orient']); + +module.exports = FlexDirection;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-flow.js b/node_modules/autoprefixer/lib/hacks/flex-flow.js new file mode 100644 index 0000000..23eba4d --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-flow.js @@ -0,0 +1,83 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var FlexFlow = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(FlexFlow, _Declaration); + + function FlexFlow() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = FlexFlow.prototype; + + /** + * Use two properties for 2009 spec + */ + _proto.insert = function insert(decl, prefix, prefixes) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec !== 2009) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + + var values = decl.value.split(/\s+/).filter(function (i) { + return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse'; + }); + + if (values.length === 0) { + return undefined; + } + + var already = decl.parent.some(function (i) { + return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction'; + }); + + if (already) { + return undefined; + } + + var value = values[0]; + var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical'; + var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal'; + var cloned = this.clone(decl); + cloned.prop = prefix + 'box-orient'; + cloned.value = orient; + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + decl.parent.insertBefore(decl, cloned); + cloned = this.clone(decl); + cloned.prop = prefix + 'box-direction'; + cloned.value = dir; + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + return decl.parent.insertBefore(decl, cloned); + }; + + return FlexFlow; +}(Declaration); + +_defineProperty(FlexFlow, "names", ['flex-flow', 'box-direction', 'box-orient']); + +module.exports = FlexFlow;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-grow.js b/node_modules/autoprefixer/lib/hacks/flex-grow.js new file mode 100644 index 0000000..09278a2 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-grow.js @@ -0,0 +1,59 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var Flex = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Flex, _Declaration); + + function Flex() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = Flex.prototype; + + /** + * Return property name by final spec + */ + _proto.normalize = function normalize() { + return 'flex'; + } + /** + * Return flex property for 2009 and 2012 specs + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-flex'; + } + + if (spec === 2012) { + return prefix + 'flex-positive'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + }; + + return Flex; +}(Declaration); + +_defineProperty(Flex, "names", ['flex-grow', 'flex-positive']); + +module.exports = Flex;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-shrink.js b/node_modules/autoprefixer/lib/hacks/flex-shrink.js new file mode 100644 index 0000000..cab835c --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-shrink.js @@ -0,0 +1,74 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var FlexShrink = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(FlexShrink, _Declaration); + + function FlexShrink() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = FlexShrink.prototype; + + /** + * Return property name by final spec + */ + _proto.normalize = function normalize() { + return 'flex-shrink'; + } + /** + * Return flex property for 2012 spec + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-negative'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Ignore 2009 spec and use flex property for 2012 + */ + ; + + _proto.set = function set(decl, prefix) { + var spec; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2012 || spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return FlexShrink; +}(Declaration); + +_defineProperty(FlexShrink, "names", ['flex-shrink', 'flex-negative']); + +module.exports = FlexShrink;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-spec.js b/node_modules/autoprefixer/lib/hacks/flex-spec.js new file mode 100644 index 0000000..d73027a --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-spec.js @@ -0,0 +1,22 @@ +"use strict"; + +/** + * Return flexbox spec versions by prefix + */ +module.exports = function (prefix) { + var spec; + + if (prefix === '-webkit- 2009' || prefix === '-moz-') { + spec = 2009; + } else if (prefix === '-ms-') { + spec = 2012; + } else if (prefix === '-webkit-') { + spec = 'final'; + } + + if (prefix === '-webkit- 2009') { + prefix = '-webkit-'; + } + + return [spec, prefix]; +};
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex-wrap.js b/node_modules/autoprefixer/lib/hacks/flex-wrap.js new file mode 100644 index 0000000..841eb62 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex-wrap.js @@ -0,0 +1,42 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var FlexWrap = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(FlexWrap, _Declaration); + + function FlexWrap() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = FlexWrap.prototype; + + /** + * Don't add prefix for 2009 spec + */ + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec !== 2009) { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return FlexWrap; +}(Declaration); + +_defineProperty(FlexWrap, "names", ['flex-wrap']); + +module.exports = FlexWrap;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/flex.js b/node_modules/autoprefixer/lib/hacks/flex.js new file mode 100644 index 0000000..44c9e1e --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/flex.js @@ -0,0 +1,87 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var list = require('postcss').list; + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var Flex = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Flex, _Declaration); + + function Flex() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = Flex.prototype; + + /** + * Change property name for 2009 spec + */ + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-flex'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'flex'; + } + /** + * Spec 2009 supports only first argument + * Spec 2012 disallows unitless basis + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2009) { + decl.value = list.space(decl.value)[0]; + decl.value = Flex.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } + + if (spec === 2012) { + var components = list.space(decl.value); + + if (components.length === 3 && components[2] === '0') { + decl.value = components.slice(0, 2).concat('0px').join(' '); + } + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return Flex; +}(Declaration); + +_defineProperty(Flex, "names", ['flex', 'box-flex']); + +_defineProperty(Flex, "oldValues", { + auto: '1', + none: '0' +}); + +module.exports = Flex;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/fullscreen.js b/node_modules/autoprefixer/lib/hacks/fullscreen.js new file mode 100644 index 0000000..fae1849 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/fullscreen.js @@ -0,0 +1,42 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Selector = require('../selector'); + +var Fullscreen = +/*#__PURE__*/ +function (_Selector) { + _inheritsLoose(Fullscreen, _Selector); + + function Fullscreen() { + return _Selector.apply(this, arguments) || this; + } + + var _proto = Fullscreen.prototype; + + /** + * Return different selectors depend on prefix + */ + _proto.prefixed = function prefixed(prefix) { + if (prefix === '-webkit-') { + return ':-webkit-full-screen'; + } + + if (prefix === '-moz-') { + return ':-moz-full-screen'; + } + + return ":" + prefix + "fullscreen"; + }; + + return Fullscreen; +}(Selector); + +_defineProperty(Fullscreen, "names", [':fullscreen']); + +module.exports = Fullscreen;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/gradient.js b/node_modules/autoprefixer/lib/hacks/gradient.js new file mode 100644 index 0000000..c1cc747 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/gradient.js @@ -0,0 +1,581 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var parser = require('postcss-value-parser'); + +var range = require('normalize-range'); + +var OldValue = require('../old-value'); + +var Value = require('../value'); + +var utils = require('../utils'); + +var IS_DIRECTION = /top|left|right|bottom/gi; + +var Gradient = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(Gradient, _Value); + + function Gradient() { + var _this; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _Value.call.apply(_Value, [this].concat(args)) || this; + + _defineProperty(_assertThisInitialized(_this), "directions", { + top: 'bottom', + left: 'right', + bottom: 'top', + right: 'left' + }); + + _defineProperty(_assertThisInitialized(_this), "oldDirections", { + 'top': 'left bottom, left top', + 'left': 'right top, left top', + 'bottom': 'left top, left bottom', + 'right': 'left top, right top', + 'top right': 'left bottom, right top', + 'top left': 'right bottom, left top', + 'right top': 'left bottom, right top', + 'right bottom': 'left top, right bottom', + 'bottom right': 'left top, right bottom', + 'bottom left': 'right top, left bottom', + 'left top': 'right bottom, left top', + 'left bottom': 'right top, left bottom' + }); + + return _this; + } + + var _proto = Gradient.prototype; + + /** + * Change degrees for webkit prefix + */ + _proto.replace = function replace(string, prefix) { + var ast = parser(string); + + for (var _iterator = ast.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var node = _ref; + + if (node.type === 'function' && node.value === this.name) { + node.nodes = this.newDirection(node.nodes); + node.nodes = this.normalize(node.nodes); + + if (prefix === '-webkit- old') { + var changes = this.oldWebkit(node); + + if (!changes) { + return false; + } + } else { + node.nodes = this.convertDirection(node.nodes); + node.value = prefix + node.value; + } + } + } + + return ast.toString(); + } + /** + * Replace first token + */ + ; + + _proto.replaceFirst = function replaceFirst(params) { + for (var _len2 = arguments.length, words = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + words[_key2 - 1] = arguments[_key2]; + } + + var prefix = words.map(function (i) { + if (i === ' ') { + return { + type: 'space', + value: i + }; + } + + return { + type: 'word', + value: i + }; + }); + return prefix.concat(params.slice(1)); + } + /** + * Convert angle unit to deg + */ + ; + + _proto.normalizeUnit = function normalizeUnit(str, full) { + var num = parseFloat(str); + var deg = num / full * 360; + return deg + "deg"; + } + /** + * Normalize angle + */ + ; + + _proto.normalize = function normalize(nodes) { + if (!nodes[0]) return nodes; + + if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 400); + } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI); + } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 1); + } else if (nodes[0].value.indexOf('deg') !== -1) { + var num = parseFloat(nodes[0].value); + num = range.wrap(0, 360, num); + nodes[0].value = num + "deg"; + } + + if (nodes[0].value === '0deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'top'); + } else if (nodes[0].value === '90deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'right'); + } else if (nodes[0].value === '180deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom'); + } else if (nodes[0].value === '270deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'left'); + } + + return nodes; + } + /** + * Replace old direction to new + */ + ; + + _proto.newDirection = function newDirection(params) { + if (params[0].value === 'to') { + return params; + } + + IS_DIRECTION.lastIndex = 0; // reset search index of global regexp + + if (!IS_DIRECTION.test(params[0].value)) { + return params; + } + + params.unshift({ + type: 'word', + value: 'to' + }, { + type: 'space', + value: ' ' + }); + + for (var i = 2; i < params.length; i++) { + if (params[i].type === 'div') { + break; + } + + if (params[i].type === 'word') { + params[i].value = this.revertDirection(params[i].value); + } + } + + return params; + } + /** + * Look for at word + */ + ; + + _proto.isRadial = function isRadial(params) { + var state = 'before'; + + for (var _iterator2 = params, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var param = _ref2; + + if (state === 'before' && param.type === 'space') { + state = 'at'; + } else if (state === 'at' && param.value === 'at') { + state = 'after'; + } else if (state === 'after' && param.type === 'space') { + return true; + } else if (param.type === 'div') { + break; + } else { + state = 'before'; + } + } + + return false; + } + /** + * Change new direction to old + */ + ; + + _proto.convertDirection = function convertDirection(params) { + if (params.length > 0) { + if (params[0].value === 'to') { + this.fixDirection(params); + } else if (params[0].value.indexOf('deg') !== -1) { + this.fixAngle(params); + } else if (this.isRadial(params)) { + this.fixRadial(params); + } + } + + return params; + } + /** + * Replace `to top left` to `bottom right` + */ + ; + + _proto.fixDirection = function fixDirection(params) { + params.splice(0, 2); + + for (var _iterator3 = params, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var param = _ref3; + + if (param.type === 'div') { + break; + } + + if (param.type === 'word') { + param.value = this.revertDirection(param.value); + } + } + } + /** + * Add 90 degrees + */ + ; + + _proto.fixAngle = function fixAngle(params) { + var first = params[0].value; + first = parseFloat(first); + first = Math.abs(450 - first) % 360; + first = this.roundFloat(first, 3); + params[0].value = first + "deg"; + } + /** + * Fix radial direction syntax + */ + ; + + _proto.fixRadial = function fixRadial(params) { + var first = []; + var second = []; + var a, b, c, i, next; + + for (i = 0; i < params.length - 2; i++) { + a = params[i]; + b = params[i + 1]; + c = params[i + 2]; + + if (a.type === 'space' && b.value === 'at' && c.type === 'space') { + next = i + 3; + break; + } else { + first.push(a); + } + } + + var div; + + for (i = next; i < params.length; i++) { + if (params[i].type === 'div') { + div = params[i]; + break; + } else { + second.push(params[i]); + } + } + + params.splice.apply(params, [0, i].concat(second, [div], first)); + }; + + _proto.revertDirection = function revertDirection(word) { + return this.directions[word.toLowerCase()] || word; + } + /** + * Round float and save digits under dot + */ + ; + + _proto.roundFloat = function roundFloat(_float, digits) { + return parseFloat(_float.toFixed(digits)); + } + /** + * Convert to old webkit syntax + */ + ; + + _proto.oldWebkit = function oldWebkit(node) { + var nodes = node.nodes; + var string = parser.stringify(node.nodes); + + if (this.name !== 'linear-gradient') { + return false; + } + + if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) { + return false; + } + + if (string.indexOf('px') !== -1 || string.indexOf('-corner') !== -1 || string.indexOf('-side') !== -1) { + return false; + } + + var params = [[]]; + + for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var i = _ref4; + params[params.length - 1].push(i); + + if (i.type === 'div' && i.value === ',') { + params.push([]); + } + } + + this.oldDirection(params); + this.colorStops(params); + node.nodes = []; + + for (var _i5 = 0, _params = params; _i5 < _params.length; _i5++) { + var param = _params[_i5]; + node.nodes = node.nodes.concat(param); + } + + node.nodes.unshift({ + type: 'word', + value: 'linear' + }, this.cloneDiv(node.nodes)); + node.value = '-webkit-gradient'; + return true; + } + /** + * Change direction syntax to old webkit + */ + ; + + _proto.oldDirection = function oldDirection(params) { + var div = this.cloneDiv(params[0]); + + if (params[0][0].value !== 'to') { + return params.unshift([{ + type: 'word', + value: this.oldDirections.bottom + }, div]); + } else { + var words = []; + + for (var _iterator5 = params[0].slice(2), _isArray5 = Array.isArray(_iterator5), _i6 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i6 >= _iterator5.length) break; + _ref5 = _iterator5[_i6++]; + } else { + _i6 = _iterator5.next(); + if (_i6.done) break; + _ref5 = _i6.value; + } + + var node = _ref5; + + if (node.type === 'word') { + words.push(node.value.toLowerCase()); + } + } + + words = words.join(' '); + var old = this.oldDirections[words] || words; + params[0] = [{ + type: 'word', + value: old + }, div]; + return params[0]; + } + } + /** + * Get div token from exists parameters + */ + ; + + _proto.cloneDiv = function cloneDiv(params) { + for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i7 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i7 >= _iterator6.length) break; + _ref6 = _iterator6[_i7++]; + } else { + _i7 = _iterator6.next(); + if (_i7.done) break; + _ref6 = _i7.value; + } + + var i = _ref6; + + if (i.type === 'div' && i.value === ',') { + return i; + } + } + + return { + type: 'div', + value: ',', + after: ' ' + }; + } + /** + * Change colors syntax to old webkit + */ + ; + + _proto.colorStops = function colorStops(params) { + var result = []; + + for (var i = 0; i < params.length; i++) { + var pos = void 0; + var param = params[i]; + var item = void 0; + + if (i === 0) { + continue; + } + + var color = parser.stringify(param[0]); + + if (param[1] && param[1].type === 'word') { + pos = param[1].value; + } else if (param[2] && param[2].type === 'word') { + pos = param[2].value; + } + + var stop = void 0; + + if (i === 1 && (!pos || pos === '0%')) { + stop = "from(" + color + ")"; + } else if (i === params.length - 1 && (!pos || pos === '100%')) { + stop = "to(" + color + ")"; + } else if (pos) { + stop = "color-stop(" + pos + ", " + color + ")"; + } else { + stop = "color-stop(" + color + ")"; + } + + var div = param[param.length - 1]; + params[i] = [{ + type: 'word', + value: stop + }]; + + if (div.type === 'div' && div.value === ',') { + item = params[i].push(div); + } + + result.push(item); + } + + return result; + } + /** + * Remove old WebKit gradient too + */ + ; + + _proto.old = function old(prefix) { + if (prefix === '-webkit-') { + var type = this.name === 'linear-gradient' ? 'linear' : 'radial'; + var string = '-gradient'; + var regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false); + return new OldValue(this.name, prefix + this.name, string, regexp); + } else { + return _Value.prototype.old.call(this, prefix); + } + } + /** + * Do not add non-webkit prefixes for list-style and object + */ + ; + + _proto.add = function add(decl, prefix) { + var p = decl.prop; + + if (p.indexOf('mask') !== -1) { + if (prefix === '-webkit-' || prefix === '-webkit- old') { + return _Value.prototype.add.call(this, decl, prefix); + } + } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') { + if (prefix === '-webkit-' || prefix === '-webkit- old') { + return _Value.prototype.add.call(this, decl, prefix); + } + } else { + return _Value.prototype.add.call(this, decl, prefix); + } + + return undefined; + }; + + return Gradient; +}(Value); + +_defineProperty(Gradient, "names", ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient']); + +module.exports = Gradient;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-area.js b/node_modules/autoprefixer/lib/hacks/grid-area.js new file mode 100644 index 0000000..8c1b39c --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-area.js @@ -0,0 +1,54 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('./grid-utils'); + +var GridArea = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridArea, _Declaration); + + function GridArea() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridArea.prototype; + + /** + * Translate grid-area to separate -ms- prefixed properties + */ + _proto.insert = function insert(decl, prefix, prefixes, result) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + var values = utils.parse(decl); + + var _utils$translate = utils.translate(values, 0, 2), + rowStart = _utils$translate[0], + rowSpan = _utils$translate[1]; + + var _utils$translate2 = utils.translate(values, 1, 3), + columnStart = _utils$translate2[0], + columnSpan = _utils$translate2[1]; + + [['grid-row', rowStart], ['grid-row-span', rowSpan], ['grid-column', columnStart], ['grid-column-span', columnSpan]].forEach(function (_ref) { + var prop = _ref[0], + value = _ref[1]; + utils.insertDecl(decl, prop, value); + }); + utils.warnTemplateSelectorNotFound(decl, result); + utils.warnIfGridRowColumnExists(decl, result); + return undefined; + }; + + return GridArea; +}(Declaration); + +_defineProperty(GridArea, "names", ['grid-area']); + +module.exports = GridArea;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-column-align.js b/node_modules/autoprefixer/lib/hacks/grid-column-align.js new file mode 100644 index 0000000..c69efb5 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-column-align.js @@ -0,0 +1,50 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var GridColumnAlign = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridColumnAlign, _Declaration); + + function GridColumnAlign() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridColumnAlign.prototype; + + /** + * Do not prefix flexbox values + */ + _proto.check = function check(decl) { + return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline'; + } + /** + * Change property name for IE + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + 'grid-column-align'; + } + /** + * Change IE property back + */ + ; + + _proto.normalize = function normalize() { + return 'justify-self'; + }; + + return GridColumnAlign; +}(Declaration); + +_defineProperty(GridColumnAlign, "names", ['grid-column-align']); + +module.exports = GridColumnAlign;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-end.js b/node_modules/autoprefixer/lib/hacks/grid-end.js new file mode 100644 index 0000000..d13c7b8 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-end.js @@ -0,0 +1,64 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var GridEnd = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridEnd, _Declaration); + + function GridEnd() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridEnd.prototype; + + /** + * Change repeating syntax for IE + */ + _proto.insert = function insert(decl, prefix, prefixes, result) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + var clonedDecl = this.clone(decl); + var startProp = decl.prop.replace(/end$/, 'start'); + var spanProp = prefix + decl.prop.replace(/end$/, 'span'); + + if (decl.parent.some(function (i) { + return i.prop === spanProp; + })) { + return undefined; + } + + clonedDecl.prop = spanProp; + + if (decl.value.includes('span')) { + clonedDecl.value = decl.value.replace(/span\s/i, ''); + } else { + var startDecl; + decl.parent.walkDecls(startProp, function (d) { + startDecl = d; + }); + + if (startDecl) { + var value = Number(decl.value) - Number(startDecl.value) + ''; + clonedDecl.value = value; + } else { + decl.warn(result, "Can not prefix " + decl.prop + " (" + startProp + " is not found)"); + } + } + + decl.cloneBefore(clonedDecl); + return undefined; + }; + + return GridEnd; +}(Declaration); + +_defineProperty(GridEnd, "names", ['grid-row-end', 'grid-column-end']); + +module.exports = GridEnd;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-row-align.js b/node_modules/autoprefixer/lib/hacks/grid-row-align.js new file mode 100644 index 0000000..5d0e4dc --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-row-align.js @@ -0,0 +1,50 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var GridRowAlign = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridRowAlign, _Declaration); + + function GridRowAlign() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridRowAlign.prototype; + + /** + * Do not prefix flexbox values + */ + _proto.check = function check(decl) { + return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline'; + } + /** + * Change property name for IE + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + 'grid-row-align'; + } + /** + * Change IE property back + */ + ; + + _proto.normalize = function normalize() { + return 'align-self'; + }; + + return GridRowAlign; +}(Declaration); + +_defineProperty(GridRowAlign, "names", ['grid-row-align']); + +module.exports = GridRowAlign;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-row-column.js b/node_modules/autoprefixer/lib/hacks/grid-row-column.js new file mode 100644 index 0000000..256f9d1 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-row-column.js @@ -0,0 +1,54 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('./grid-utils'); + +var GridRowColumn = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridRowColumn, _Declaration); + + function GridRowColumn() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridRowColumn.prototype; + + /** + * Translate grid-row / grid-column to separate -ms- prefixed properties + */ + _proto.insert = function insert(decl, prefix, prefixes) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + var values = utils.parse(decl); + + var _utils$translate = utils.translate(values, 0, 1), + start = _utils$translate[0], + span = _utils$translate[1]; + + var hasStartValueSpan = values[0] && values[0].includes('span'); + + if (hasStartValueSpan) { + span = values[0].join('').replace(/\D/g, ''); + } + + [[decl.prop, start], [decl.prop + "-span", span]].forEach(function (_ref) { + var prop = _ref[0], + value = _ref[1]; + utils.insertDecl(decl, prop, value); + }); + return undefined; + }; + + return GridRowColumn; +}(Declaration); + +_defineProperty(GridRowColumn, "names", ['grid-row', 'grid-column']); + +module.exports = GridRowColumn;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js b/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js new file mode 100644 index 0000000..edd1ee6 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js @@ -0,0 +1,149 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var _require = require('./grid-utils'), + prefixTrackProp = _require.prefixTrackProp, + prefixTrackValue = _require.prefixTrackValue, + autoplaceGridItems = _require.autoplaceGridItems, + getGridGap = _require.getGridGap, + inheritGridGap = _require.inheritGridGap; + +var Processor = require('../processor'); + +var GridRowsColumns = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridRowsColumns, _Declaration); + + function GridRowsColumns() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridRowsColumns.prototype; + + /** + * Change property name for IE + */ + _proto.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return prefixTrackProp({ + prop: prop, + prefix: prefix + }); + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Change IE property back + */ + ; + + _proto.normalize = function normalize(prop) { + return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1'); + }; + + _proto.insert = function insert(decl, prefix, prefixes, result) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + var parent = decl.parent, + prop = decl.prop, + value = decl.value; + var isRowProp = prop.includes('rows'); + var isColumnProp = prop.includes('columns'); + var hasGridTemplate = parent.some(function (i) { + return i.prop === 'grid-template' || i.prop === 'grid-template-areas'; + }); + /** + * Not to prefix rows declaration if grid-template(-areas) is present + */ + + if (hasGridTemplate && isRowProp) { + return false; + } + + var processor = new Processor({}); + var status = processor.gridStatus(parent, result); + var gap = getGridGap(decl); + gap = inheritGridGap(decl, gap) || gap; + var gapValue = isRowProp ? gap.row : gap.column; + + if ((status === 'no-autoplace' || status === true) && !hasGridTemplate) { + gapValue = null; + } + + var prefixValue = prefixTrackValue({ + value: value, + gap: gapValue + }); + /** + * Insert prefixes + */ + + decl.cloneBefore({ + prop: prefixTrackProp({ + prop: prop, + prefix: prefix + }), + value: prefixValue + }); + var autoflow = parent.nodes.find(function (i) { + return i.prop === 'grid-auto-flow'; + }); + var autoflowValue = 'row'; + + if (autoflow && !processor.disabled(autoflow, result)) { + autoflowValue = autoflow.value.trim(); + } + + if (status === 'autoplace') { + /** + * Show warning if grid-template-rows decl is not found + */ + var rowDecl = parent.nodes.find(function (i) { + return i.prop === 'grid-template-rows'; + }); + + if (!rowDecl && hasGridTemplate) { + return undefined; + } else if (!rowDecl && !hasGridTemplate) { + decl.warn(result, "Autoplacement does not work without grid-template-rows property"); + return undefined; + } + /** + * Show warning if grid-template-columns decl is not found + */ + + + var columnDecl = parent.nodes.find(function (i) { + return i.prop === 'grid-template-columns'; + }); + + if (!columnDecl && !hasGridTemplate) { + decl.warn(result, "Autoplacement does not work without grid-template-columns property"); + } + /** + * Autoplace grid items + */ + + + if (isColumnProp && !hasGridTemplate) { + autoplaceGridItems(decl, result, gap, autoflowValue); + } + } + + return undefined; + }; + + return GridRowsColumns; +}(Declaration); + +_defineProperty(GridRowsColumns, "names", ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns']); + +module.exports = GridRowsColumns;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-start.js b/node_modules/autoprefixer/lib/hacks/grid-start.js new file mode 100644 index 0000000..dfbc68b --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-start.js @@ -0,0 +1,57 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var GridStart = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridStart, _Declaration); + + function GridStart() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridStart.prototype; + + /** + * Do not add prefix for unsupported value in IE + */ + _proto.check = function check(decl) { + var value = decl.value; + return value.indexOf('/') === -1 || value.indexOf('span') !== -1; + } + /** + * Return a final spec property + */ + ; + + _proto.normalize = function normalize(prop) { + return prop.replace('-start', ''); + } + /** + * Change property name for IE + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var result = _Declaration.prototype.prefixed.call(this, prop, prefix); + + if (prefix === '-ms-') { + result = result.replace('-start', ''); + } + + return result; + }; + + return GridStart; +}(Declaration); + +_defineProperty(GridStart, "names", ['grid-row-start', 'grid-column-start']); + +module.exports = GridStart;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-template-areas.js b/node_modules/autoprefixer/lib/hacks/grid-template-areas.js new file mode 100644 index 0000000..9da1685 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-template-areas.js @@ -0,0 +1,103 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var _require = require('./grid-utils'), + parseGridAreas = _require.parseGridAreas, + warnMissedAreas = _require.warnMissedAreas, + prefixTrackProp = _require.prefixTrackProp, + prefixTrackValue = _require.prefixTrackValue, + getGridGap = _require.getGridGap, + warnGridGap = _require.warnGridGap, + inheritGridGap = _require.inheritGridGap; + +function getGridRows(tpl) { + return tpl.trim().slice(1, -1).split(/['"]\s*['"]?/g); +} + +var GridTemplateAreas = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridTemplateAreas, _Declaration); + + function GridTemplateAreas() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridTemplateAreas.prototype; + + /** + * Translate grid-template-areas to separate -ms- prefixed properties + */ + _proto.insert = function insert(decl, prefix, prefixes, result) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + var hasColumns = false; + var hasRows = false; + var parent = decl.parent; + var gap = getGridGap(decl); + gap = inheritGridGap(decl, gap) || gap; // remove already prefixed rows + // to prevent doubling prefixes + + parent.walkDecls(/-ms-grid-rows/, function (i) { + return i.remove(); + }); // add empty tracks to rows + + parent.walkDecls(/grid-template-(rows|columns)/, function (trackDecl) { + if (trackDecl.prop === 'grid-template-rows') { + hasRows = true; + var prop = trackDecl.prop, + value = trackDecl.value; + trackDecl.cloneBefore({ + prop: prefixTrackProp({ + prop: prop, + prefix: prefix + }), + value: prefixTrackValue({ + value: value, + gap: gap.row + }) + }); + } else { + hasColumns = true; + } + }); + var gridRows = getGridRows(decl.value); + + if (hasColumns && !hasRows && gap.row && gridRows.length > 1) { + decl.cloneBefore({ + prop: '-ms-grid-rows', + value: prefixTrackValue({ + value: "repeat(" + gridRows.length + ", auto)", + gap: gap.row + }), + raws: {} + }); + } // warnings + + + warnGridGap({ + gap: gap, + hasColumns: hasColumns, + decl: decl, + result: result + }); + var areas = parseGridAreas({ + rows: gridRows, + gap: gap + }); + warnMissedAreas(areas, decl, result); + return decl; + }; + + return GridTemplateAreas; +}(Declaration); + +_defineProperty(GridTemplateAreas, "names", ['grid-template-areas']); + +module.exports = GridTemplateAreas;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-template.js b/node_modules/autoprefixer/lib/hacks/grid-template.js new file mode 100644 index 0000000..88ce36b --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-template.js @@ -0,0 +1,92 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var _require = require('./grid-utils'), + parseTemplate = _require.parseTemplate, + warnMissedAreas = _require.warnMissedAreas, + getGridGap = _require.getGridGap, + warnGridGap = _require.warnGridGap, + inheritGridGap = _require.inheritGridGap; + +var GridTemplate = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(GridTemplate, _Declaration); + + function GridTemplate() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = GridTemplate.prototype; + + /** + * Translate grid-template to separate -ms- prefixed properties + */ + _proto.insert = function insert(decl, prefix, prefixes, result) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + + if (decl.parent.some(function (i) { + return i.prop === '-ms-grid-rows'; + })) { + return undefined; + } + + var gap = getGridGap(decl); + /** + * we must insert inherited gap values in some cases: + * if we are inside media query && if we have no grid-gap value + */ + + var inheritedGap = inheritGridGap(decl, gap); + + var _parseTemplate = parseTemplate({ + decl: decl, + gap: inheritedGap || gap + }), + rows = _parseTemplate.rows, + columns = _parseTemplate.columns, + areas = _parseTemplate.areas; + + var hasAreas = Object.keys(areas).length > 0; + var hasRows = Boolean(rows); + var hasColumns = Boolean(columns); + warnGridGap({ + gap: gap, + hasColumns: hasColumns, + decl: decl, + result: result + }); + warnMissedAreas(areas, decl, result); + + if (hasRows && hasColumns || hasAreas) { + decl.cloneBefore({ + prop: '-ms-grid-rows', + value: rows, + raws: {} + }); + } + + if (hasColumns) { + decl.cloneBefore({ + prop: '-ms-grid-columns', + value: columns, + raws: {} + }); + } + + return decl; + }; + + return GridTemplate; +}(Declaration); + +_defineProperty(GridTemplate, "names", ['grid-template']); + +module.exports = GridTemplate;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/grid-utils.js b/node_modules/autoprefixer/lib/hacks/grid-utils.js new file mode 100644 index 0000000..06f868c --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/grid-utils.js @@ -0,0 +1,1150 @@ +"use strict"; + +var parser = require('postcss-value-parser'); + +var list = require('postcss').list; + +var uniq = require('../utils').uniq; + +var escapeRegexp = require('../utils').escapeRegexp; + +var splitSelector = require('../utils').splitSelector; + +function convert(value) { + if (value && value.length === 2 && value[0] === 'span' && parseInt(value[1], 10) > 0) { + return [false, parseInt(value[1], 10)]; + } + + if (value && value.length === 1 && parseInt(value[0], 10) > 0) { + return [parseInt(value[0], 10), false]; + } + + return [false, false]; +} + +function translate(values, startIndex, endIndex) { + var startValue = values[startIndex]; + var endValue = values[endIndex]; + + if (!startValue) { + return [false, false]; + } + + var _convert = convert(startValue), + start = _convert[0], + spanStart = _convert[1]; + + var _convert2 = convert(endValue), + end = _convert2[0], + spanEnd = _convert2[1]; + + if (start && !endValue) { + return [start, false]; + } + + if (spanStart && end) { + return [end - spanStart, spanStart]; + } + + if (start && spanEnd) { + return [start, spanEnd]; + } + + if (start && end) { + return [start, end - start]; + } + + return [false, false]; +} + +function parse(decl) { + var node = parser(decl.value); + var values = []; + var current = 0; + values[current] = []; + + for (var _iterator = node.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if (i.type === 'div') { + current += 1; + values[current] = []; + } else if (i.type === 'word') { + values[current].push(i.value); + } + } + + return values; +} + +function insertDecl(decl, prop, value) { + if (value && !decl.parent.some(function (i) { + return i.prop === "-ms-" + prop; + })) { + decl.cloneBefore({ + prop: "-ms-" + prop, + value: value.toString() + }); + } +} // Track transforms + + +function prefixTrackProp(_ref2) { + var prop = _ref2.prop, + prefix = _ref2.prefix; + return prefix + prop.replace('template-', ''); +} + +function transformRepeat(_ref3, _ref4) { + var nodes = _ref3.nodes; + var gap = _ref4.gap; + + var _nodes$reduce = nodes.reduce(function (result, node) { + if (node.type === 'div' && node.value === ',') { + result.key = 'size'; + } else { + result[result.key].push(parser.stringify(node)); + } + + return result; + }, { + key: 'count', + size: [], + count: [] + }), + count = _nodes$reduce.count, + size = _nodes$reduce.size; // insert gap values + + + if (gap) { + var _ret = function () { + size = size.filter(function (i) { + return i.trim(); + }); + var val = []; + + var _loop = function _loop(i) { + size.forEach(function (item, index) { + if (index > 0 || i > 1) { + val.push(gap); + } + + val.push(item); + }); + }; + + for (var i = 1; i <= count; i++) { + _loop(i); + } + + return { + v: val.join(' ') + }; + }(); + + if (typeof _ret === "object") return _ret.v; + } + + return "(" + size.join('') + ")[" + count.join('') + "]"; +} + +function prefixTrackValue(_ref5) { + var value = _ref5.value, + gap = _ref5.gap; + var result = parser(value).nodes.reduce(function (nodes, node) { + if (node.type === 'function' && node.value === 'repeat') { + return nodes.concat({ + type: 'word', + value: transformRepeat(node, { + gap: gap + }) + }); + } + + if (gap && node.type === 'space') { + return nodes.concat({ + type: 'space', + value: ' ' + }, { + type: 'word', + value: gap + }, node); + } + + return nodes.concat(node); + }, []); + return parser.stringify(result); +} // Parse grid-template-areas + + +var DOTS = /^\.+$/; + +function track(start, end) { + return { + start: start, + end: end, + span: end - start + }; +} + +function getColumns(line) { + return line.trim().split(/\s+/g); +} + +function parseGridAreas(_ref6) { + var rows = _ref6.rows, + gap = _ref6.gap; + return rows.reduce(function (areas, line, rowIndex) { + if (gap.row) rowIndex *= 2; + if (line.trim() === '') return areas; + getColumns(line).forEach(function (area, columnIndex) { + if (DOTS.test(area)) return; + if (gap.column) columnIndex *= 2; + + if (typeof areas[area] === 'undefined') { + areas[area] = { + column: track(columnIndex + 1, columnIndex + 2), + row: track(rowIndex + 1, rowIndex + 2) + }; + } else { + var _areas$area = areas[area], + column = _areas$area.column, + row = _areas$area.row; + column.start = Math.min(column.start, columnIndex + 1); + column.end = Math.max(column.end, columnIndex + 2); + column.span = column.end - column.start; + row.start = Math.min(row.start, rowIndex + 1); + row.end = Math.max(row.end, rowIndex + 2); + row.span = row.end - row.start; + } + }); + return areas; + }, {}); +} // Parse grid-template + + +function testTrack(node) { + return node.type === 'word' && /^\[.+\]$/.test(node.value); +} + +function verifyRowSize(result) { + if (result.areas.length > result.rows.length) { + result.rows.push('auto'); + } + + return result; +} + +function parseTemplate(_ref7) { + var decl = _ref7.decl, + gap = _ref7.gap; + var gridTemplate = parser(decl.value).nodes.reduce(function (result, node) { + var type = node.type, + value = node.value; + if (testTrack(node) || type === 'space') return result; // area + + if (type === 'string') { + result = verifyRowSize(result); + result.areas.push(value); + } // values and function + + + if (type === 'word' || type === 'function') { + result[result.key].push(parser.stringify(node)); + } // divider(/) + + + if (type === 'div' && value === '/') { + result.key = 'columns'; + result = verifyRowSize(result); + } + + return result; + }, { + key: 'rows', + columns: [], + rows: [], + areas: [] + }); + return { + areas: parseGridAreas({ + rows: gridTemplate.areas, + gap: gap + }), + columns: prefixTrackValue({ + value: gridTemplate.columns.join(' '), + gap: gap.column + }), + rows: prefixTrackValue({ + value: gridTemplate.rows.join(' '), + gap: gap.row + }) + }; +} // Insert parsed grid areas + +/** + * Get an array of -ms- prefixed props and values + * @param {Object} [area] area object with column and row data + * @param {Boolean} [addRowSpan] should we add grid-column-row value? + * @param {Boolean} [addColumnSpan] should we add grid-column-span value? + * @return {Array<Object>} + */ + + +function getMSDecls(area, addRowSpan, addColumnSpan) { + if (addRowSpan === void 0) { + addRowSpan = false; + } + + if (addColumnSpan === void 0) { + addColumnSpan = false; + } + + return [].concat({ + prop: '-ms-grid-row', + value: String(area.row.start) + }, area.row.span > 1 || addRowSpan ? { + prop: '-ms-grid-row-span', + value: String(area.row.span) + } : [], { + prop: '-ms-grid-column', + value: String(area.column.start) + }, area.column.span > 1 || addColumnSpan ? { + prop: '-ms-grid-column-span', + value: String(area.column.span) + } : []); +} + +function getParentMedia(parent) { + if (parent.type === 'atrule' && parent.name === 'media') { + return parent; + } + + if (!parent.parent) { + return false; + } + + return getParentMedia(parent.parent); +} +/** + * change selectors for rules with duplicate grid-areas. + * @param {Array<Rule>} rules + * @param {Array<String>} templateSelectors + * @return {Array<Rule>} rules with changed selectors + */ + + +function changeDuplicateAreaSelectors(ruleSelectors, templateSelectors) { + ruleSelectors = ruleSelectors.map(function (selector) { + var selectorBySpace = list.space(selector); + var selectorByComma = list.comma(selector); + + if (selectorBySpace.length > selectorByComma.length) { + selector = selectorBySpace.slice(-1).join(''); + } + + return selector; + }); + return ruleSelectors.map(function (ruleSelector) { + var newSelector = templateSelectors.map(function (tplSelector, index) { + var space = index === 0 ? '' : ' '; + return "" + space + tplSelector + " > " + ruleSelector; + }); + return newSelector; + }); +} +/** + * check if selector of rules are equal + * @param {Rule} ruleA + * @param {Rule} ruleB + * @return {Boolean} + */ + + +function selectorsEqual(ruleA, ruleB) { + return ruleA.selectors.some(function (sel) { + return ruleB.selectors.some(function (s) { + return s === sel; + }); + }); +} +/** + * Parse data from all grid-template(-areas) declarations + * @param {Root} css css root + * @return {Object} parsed data + */ + + +function parseGridTemplatesData(css) { + var parsed = []; // we walk through every grid-template(-areas) declaration and store + // data with the same area names inside the item + + css.walkDecls(/grid-template(-areas)?$/, function (d) { + var rule = d.parent; + var media = getParentMedia(rule); + var gap = getGridGap(d); + var inheritedGap = inheritGridGap(d, gap); + + var _parseTemplate = parseTemplate({ + decl: d, + gap: inheritedGap || gap + }), + areas = _parseTemplate.areas; + + var areaNames = Object.keys(areas); // skip node if it doesn't have areas + + if (areaNames.length === 0) { + return true; + } // check parsed array for item that include the same area names + // return index of that item + + + var index = parsed.reduce(function (acc, _ref8, idx) { + var allAreas = _ref8.allAreas; + var hasAreas = allAreas && areaNames.some(function (area) { + return allAreas.includes(area); + }); + return hasAreas ? idx : acc; + }, null); + + if (index !== null) { + // index is found, add the grid-template data to that item + var _parsed$index = parsed[index], + allAreas = _parsed$index.allAreas, + rules = _parsed$index.rules; // check if rule has no duplicate area names + + var hasNoDuplicates = rules.some(function (r) { + return r.hasDuplicates === false && selectorsEqual(r, rule); + }); + var duplicatesFound = false; // check need to gather all duplicate area names + + var duplicateAreaNames = rules.reduce(function (acc, r) { + if (!r.params && selectorsEqual(r, rule)) { + duplicatesFound = true; + return r.duplicateAreaNames; + } + + if (!duplicatesFound) { + areaNames.forEach(function (name) { + if (r.areas[name]) { + acc.push(name); + } + }); + } + + return uniq(acc); + }, []); // update grid-row/column-span values for areas with duplicate + // area names. @see #1084 and #1146 + + rules.forEach(function (r) { + areaNames.forEach(function (name) { + var area = r.areas[name]; + + if (area && area.row.span !== areas[name].row.span) { + areas[name].row.updateSpan = true; + } + + if (area && area.column.span !== areas[name].column.span) { + areas[name].column.updateSpan = true; + } + }); + }); + parsed[index].allAreas = uniq([].concat(allAreas, areaNames)); + parsed[index].rules.push({ + hasDuplicates: !hasNoDuplicates, + params: media.params, + selectors: rule.selectors, + node: rule, + duplicateAreaNames: duplicateAreaNames, + areas: areas + }); + } else { + // index is NOT found, push the new item to the parsed array + parsed.push({ + allAreas: areaNames, + areasCount: 0, + rules: [{ + hasDuplicates: false, + duplicateRules: [], + params: media.params, + selectors: rule.selectors, + node: rule, + duplicateAreaNames: [], + areas: areas + }] + }); + } + + return undefined; + }); + return parsed; +} +/** + * insert prefixed grid-area declarations + * @param {Root} css css root + * @param {Function} isDisabled check if the rule is disabled + * @return {void} + */ + + +function insertAreas(css, isDisabled) { + // parse grid-template declarations + var gridTemplatesData = parseGridTemplatesData(css); // return undefined if no declarations found + + if (gridTemplatesData.length === 0) { + return undefined; + } // we need to store the rules that we will insert later + + + var rulesToInsert = {}; + css.walkDecls('grid-area', function (gridArea) { + var gridAreaRule = gridArea.parent; + var hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row'; + var gridAreaMedia = getParentMedia(gridAreaRule); + + if (isDisabled(gridArea)) { + return undefined; + } + + var gridAreaRuleIndex = gridAreaMedia ? css.index(gridAreaMedia) : css.index(gridAreaRule); + var value = gridArea.value; // found the data that matches grid-area identifier + + var data = gridTemplatesData.filter(function (d) { + return d.allAreas.includes(value); + })[0]; + + if (!data) { + return true; + } + + var lastArea = data.allAreas[data.allAreas.length - 1]; + var selectorBySpace = list.space(gridAreaRule.selector); + var selectorByComma = list.comma(gridAreaRule.selector); + var selectorIsComplex = selectorBySpace.length > 1 && selectorBySpace.length > selectorByComma.length; // prevent doubling of prefixes + + if (hasPrefixedRow) { + return false; + } // create the empty object with the key as the last area name + // e.g if we have templates with "a b c" values, "c" will be the last area + + + if (!rulesToInsert[lastArea]) { + rulesToInsert[lastArea] = {}; + } + + var lastRuleIsSet = false; // walk through every grid-template rule data + + for (var _iterator2 = data.rules, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref9; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref9 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref9 = _i2.value; + } + + var rule = _ref9; + var area = rule.areas[value]; + var hasDuplicateName = rule.duplicateAreaNames.includes(value); // if we can't find the area name, update lastRule and continue + + if (!area) { + var lastRuleIndex = css.index(rulesToInsert[lastArea].lastRule); + + if (gridAreaRuleIndex > lastRuleIndex) { + rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule; + } + + continue; + } // for grid-templates inside media rule we need to create empty + // array to push prefixed grid-area rules later + + + if (rule.params && !rulesToInsert[lastArea][rule.params]) { + rulesToInsert[lastArea][rule.params] = []; + } + + if ((!rule.hasDuplicates || !hasDuplicateName) && !rule.params) { + // grid-template has no duplicates and not inside media rule + getMSDecls(area, false, false).reverse().forEach(function (i) { + return gridAreaRule.prepend(Object.assign(i, { + raws: { + between: gridArea.raws.between + } + })); + }); + rulesToInsert[lastArea].lastRule = gridAreaRule; + lastRuleIsSet = true; + } else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) { + (function () { + // grid-template has duplicates and not inside media rule + var cloned = gridAreaRule.clone(); + cloned.removeAll(); + getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) { + return cloned.prepend(Object.assign(i, { + raws: { + between: gridArea.raws.between + } + })); + }); + cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors); + + if (rulesToInsert[lastArea].lastRule) { + rulesToInsert[lastArea].lastRule.after(cloned); + } + + rulesToInsert[lastArea].lastRule = cloned; + lastRuleIsSet = true; + })(); + } else if (rule.hasDuplicates && !rule.params && selectorIsComplex && gridAreaRule.selector.includes(rule.selectors[0])) { + // grid-template has duplicates and not inside media rule + // and the selector is complex + gridAreaRule.walkDecls(/-ms-grid-(row|column)/, function (d) { + return d.remove(); + }); + getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) { + return gridAreaRule.prepend(Object.assign(i, { + raws: { + between: gridArea.raws.between + } + })); + }); + } else if (rule.params) { + (function () { + // grid-template is inside media rule + // if we're inside media rule, we need to store prefixed rules + // inside rulesToInsert object to be able to preserve the order of media + // rules and merge them easily + var cloned = gridAreaRule.clone(); + cloned.removeAll(); + getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) { + return cloned.prepend(Object.assign(i, { + raws: { + between: gridArea.raws.between + } + })); + }); + + if (rule.hasDuplicates && hasDuplicateName) { + cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors); + } + + cloned.raws = rule.node.raws; + + if (css.index(rule.node.parent) > gridAreaRuleIndex) { + // append the prefixed rules right inside media rule + // with grid-template + rule.node.parent.append(cloned); + } else { + // store the rule to insert later + rulesToInsert[lastArea][rule.params].push(cloned); + } // set new rule as last rule ONLY if we didn't set lastRule for + // this grid-area before + + + if (!lastRuleIsSet) { + rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule; + } + })(); + } + } + + return undefined; + }); // append stored rules inside the media rules + + Object.keys(rulesToInsert).forEach(function (area) { + var data = rulesToInsert[area]; + var lastRule = data.lastRule; + Object.keys(data).reverse().filter(function (p) { + return p !== 'lastRule'; + }).forEach(function (params) { + if (data[params].length > 0 && lastRule) { + lastRule.after({ + name: 'media', + params: params + }); + lastRule.next().append(data[params]); + } + }); + }); + return undefined; +} +/** + * Warn user if grid area identifiers are not found + * @param {Object} areas + * @param {Declaration} decl + * @param {Result} result + * @return {void} + */ + + +function warnMissedAreas(areas, decl, result) { + var missed = Object.keys(areas); + decl.root().walkDecls('grid-area', function (gridArea) { + missed = missed.filter(function (e) { + return e !== gridArea.value; + }); + }); + + if (missed.length > 0) { + decl.warn(result, 'Can not find grid areas: ' + missed.join(', ')); + } + + return undefined; +} +/** + * compare selectors with grid-area rule and grid-template rule + * show warning if grid-template selector is not found + * (this function used for grid-area rule) + * @param {Declaration} decl + * @param {Result} result + * @return {void} + */ + + +function warnTemplateSelectorNotFound(decl, result) { + var rule = decl.parent; + var root = decl.root(); + var duplicatesFound = false; // slice selector array. Remove the last part (for comparison) + + var slicedSelectorArr = list.space(rule.selector).filter(function (str) { + return str !== '>'; + }).slice(0, -1); // we need to compare only if selector is complex. + // e.g '.grid-cell' is simple, but '.parent > .grid-cell' is complex + + if (slicedSelectorArr.length > 0) { + var gridTemplateFound = false; + var foundAreaSelector = null; + root.walkDecls(/grid-template(-areas)?$/, function (d) { + var parent = d.parent; + var templateSelectors = parent.selectors; + + var _parseTemplate2 = parseTemplate({ + decl: d, + gap: getGridGap(d) + }), + areas = _parseTemplate2.areas; + + var hasArea = areas[decl.value]; // find the the matching selectors + + for (var _iterator3 = templateSelectors, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref10; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref10 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref10 = _i3.value; + } + + var tplSelector = _ref10; + + if (gridTemplateFound) { + break; + } + + var tplSelectorArr = list.space(tplSelector).filter(function (str) { + return str !== '>'; + }); + gridTemplateFound = tplSelectorArr.every(function (item, idx) { + return item === slicedSelectorArr[idx]; + }); + } + + if (gridTemplateFound || !hasArea) { + return true; + } + + if (!foundAreaSelector) { + foundAreaSelector = parent.selector; + } // if we found the duplicate area with different selector + + + if (foundAreaSelector && foundAreaSelector !== parent.selector) { + duplicatesFound = true; + } + + return undefined; + }); // warn user if we didn't find template + + if (!gridTemplateFound && duplicatesFound) { + decl.warn(result, "Autoprefixer cannot find a grid-template " + ("containing the duplicate grid-area \"" + decl.value + "\" ") + ("with full selector matching: " + slicedSelectorArr.join(' '))); + } + } +} +/** + * warn user if both grid-area and grid-(row|column) + * declarations are present in the same rule + * @param {Declaration} decl + * @param {Result} result + * @return {void} + */ + + +function warnIfGridRowColumnExists(decl, result) { + var rule = decl.parent; + var decls = []; + rule.walkDecls(/^grid-(row|column)/, function (d) { + if (!/-end$/.test(d.prop) && !/^span/.test(d.value)) { + decls.push(d); + } + }); + + if (decls.length > 0) { + decls.forEach(function (d) { + d.warn(result, "You already have a grid-area declaration present in the rule. " + ("You should use either grid-area or " + d.prop + ", not both")); + }); + } + + return undefined; +} // Gap utils + + +function getGridGap(decl) { + var gap = {}; // try to find gap + + var testGap = /^(grid-)?((row|column)-)?gap$/; + decl.parent.walkDecls(testGap, function (_ref11) { + var prop = _ref11.prop, + value = _ref11.value; + + if (/^(grid-)?gap$/.test(prop)) { + var _parser$nodes = parser(value).nodes, + row = _parser$nodes[0], + column = _parser$nodes[2]; + gap.row = row && parser.stringify(row); + gap.column = column ? parser.stringify(column) : gap.row; + } + + if (/^(grid-)?row-gap$/.test(prop)) gap.row = value; + if (/^(grid-)?column-gap$/.test(prop)) gap.column = value; + }); + return gap; +} +/** + * parse media parameters (for example 'min-width: 500px') + * @param {String} params parameter to parse + * @return {} + */ + + +function parseMediaParams(params) { + if (!params) { + return false; + } + + var parsed = parser(params); + var prop; + var value; + parsed.walk(function (node) { + if (node.type === 'word' && /min|max/g.test(node.value)) { + prop = node.value; + } else if (node.value.includes('px')) { + value = parseInt(node.value.replace(/\D/g, '')); + } + }); + return [prop, value]; +} +/** + * Compare the selectors and decide if we + * need to inherit gap from compared selector or not. + * @type {String} selA + * @type {String} selB + * @return {Boolean} + */ + + +function shouldInheritGap(selA, selB) { + var result; // get arrays of selector split in 3-deep array + + var splitSelectorArrA = splitSelector(selA); + var splitSelectorArrB = splitSelector(selB); + + if (splitSelectorArrA[0].length < splitSelectorArrB[0].length) { + // abort if selectorA has lower descendant specificity then selectorB + // (e.g '.grid' and '.hello .world .grid') + return false; + } else if (splitSelectorArrA[0].length > splitSelectorArrB[0].length) { + // if selectorA has higher descendant specificity then selectorB + // (e.g '.foo .bar .grid' and '.grid') + var idx = splitSelectorArrA[0].reduce(function (res, _ref12, index) { + var item = _ref12[0]; + var firstSelectorPart = splitSelectorArrB[0][0][0]; + + if (item === firstSelectorPart) { + return index; + } + + return false; + }, false); + + if (idx) { + result = splitSelectorArrB[0].every(function (arr, index) { + return arr.every(function (part, innerIndex) { + return (// because selectorA has more space elements, we need to slice + // selectorA array by 'idx' number to compare them + splitSelectorArrA[0].slice(idx)[index][innerIndex] === part + ); + }); + }); + } + } else { + // if selectorA has the same descendant specificity as selectorB + // this condition covers cases such as: '.grid.foo.bar' and '.grid' + result = splitSelectorArrB.some(function (byCommaArr) { + return byCommaArr.every(function (bySpaceArr, index) { + return bySpaceArr.every(function (part, innerIndex) { + return splitSelectorArrA[0][index][innerIndex] === part; + }); + }); + }); + } + + return result; +} +/** + * inherit grid gap values from the closest rule above + * with the same selector + * @param {Declaration} decl + * @param {Object} gap gap values + * @return {Object | Boolean} return gap values or false (if not found) + */ + + +function inheritGridGap(decl, gap) { + var rule = decl.parent; + var mediaRule = getParentMedia(rule); + var root = rule.root(); // get an array of selector split in 3-deep array + + var splitSelectorArr = splitSelector(rule.selector); // abort if the rule already has gaps + + if (Object.keys(gap).length > 0) { + return false; + } // e.g ['min-width'] + + + var _parseMediaParams = parseMediaParams(mediaRule.params), + prop = _parseMediaParams[0]; + + var lastBySpace = splitSelectorArr[0]; // get escaped value from the selector + // if we have '.grid-2.foo.bar' selector, will be '\.grid\-2' + + var escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0]); + var regexp = new RegExp("(" + escaped + "$)|(" + escaped + "[,.])"); // find the closest rule with the same selector + + var closestRuleGap; + root.walkRules(regexp, function (r) { + var gridGap; // abort if are checking the same rule + + if (rule.toString() === r.toString()) { + return false; + } // find grid-gap values + + + r.walkDecls('grid-gap', function (d) { + return gridGap = getGridGap(d); + }); // skip rule without gaps + + if (!gridGap || Object.keys(gridGap).length === 0) { + return true; + } // skip rules that should not be inherited from + + + if (!shouldInheritGap(rule.selector, r.selector)) { + return true; + } + + var media = getParentMedia(r); + + if (media) { + // if we are inside media, we need to check that media props match + // e.g ('min-width' === 'min-width') + var propToCompare = parseMediaParams(media.params)[0]; + + if (propToCompare === prop) { + closestRuleGap = gridGap; + return true; + } + } else { + closestRuleGap = gridGap; + return true; + } + + return undefined; + }); // if we find the closest gap object + + if (closestRuleGap && Object.keys(closestRuleGap).length > 0) { + return closestRuleGap; + } + + return false; +} + +function warnGridGap(_ref13) { + var gap = _ref13.gap, + hasColumns = _ref13.hasColumns, + decl = _ref13.decl, + result = _ref13.result; + var hasBothGaps = gap.row && gap.column; + + if (!hasColumns && (hasBothGaps || gap.column && !gap.row)) { + delete gap.column; + decl.warn(result, 'Can not implement grid-gap without grid-template-columns'); + } +} +/** + * normalize the grid-template-rows/columns values + * @param {String} str grid-template-rows/columns value + * @return {Array} normalized array with values + * @example + * let normalized = normalizeRowColumn('1fr repeat(2, 20px 50px) 1fr') + * normalized // <= ['1fr', '20px', '50px', '20px', '50px', '1fr'] + */ + + +function normalizeRowColumn(str) { + var normalized = parser(str).nodes.reduce(function (result, node) { + if (node.type === 'function' && node.value === 'repeat') { + var key = 'count'; + + var _node$nodes$reduce = node.nodes.reduce(function (acc, n) { + if (n.type === 'word' && key === 'count') { + acc[0] = Math.abs(parseInt(n.value)); + return acc; + } + + if (n.type === 'div' && n.value === ',') { + key = 'value'; + return acc; + } + + if (key === 'value') { + acc[1] += parser.stringify(n); + } + + return acc; + }, [0, '']), + count = _node$nodes$reduce[0], + value = _node$nodes$reduce[1]; + + if (count) { + for (var i = 0; i < count; i++) { + result.push(value); + } + } + + return result; + } + + if (node.type === 'space') { + return result; + } + + return result.concat(parser.stringify(node)); + }, []); + return normalized; +} +/** + * Autoplace grid items + * @param {Declaration} decl + * @param {Result} result + * @param {Object} gap gap values + * @param {String} autoflowValue grid-auto-flow value + * @return {void} + * @see https://github.com/postcss/autoprefixer/issues/1148 + */ + + +function autoplaceGridItems(decl, result, gap, autoflowValue) { + if (autoflowValue === void 0) { + autoflowValue = 'row'; + } + + var parent = decl.parent; + var rowDecl = parent.nodes.find(function (i) { + return i.prop === 'grid-template-rows'; + }); + var rows = normalizeRowColumn(rowDecl.value); + var columns = normalizeRowColumn(decl.value); // Build array of area names with dummy values. If we have 3 columns and + // 2 rows, filledRows will be equal to ['1 2 3', '4 5 6'] + + var filledRows = rows.map(function (_, rowIndex) { + return Array.from({ + length: columns.length + }, function (v, k) { + return k + rowIndex * columns.length + 1; + }).join(' '); + }); + var areas = parseGridAreas({ + rows: filledRows, + gap: gap + }); + var keys = Object.keys(areas); + var items = keys.map(function (i) { + return areas[i]; + }); // Change the order of cells if grid-auto-flow value is 'column' + + if (autoflowValue.includes('column')) { + items = items.sort(function (a, b) { + return a.column.start - b.column.start; + }); + } // Insert new rules + + + items.reverse().forEach(function (item, index) { + var column = item.column, + row = item.row; + var nodeSelector = parent.selectors.map(function (sel) { + return sel + (" > *:nth-child(" + (keys.length - index) + ")"); + }).join(', '); // create new rule + + var node = parent.clone().removeAll(); // change rule selector + + node.selector = nodeSelector; // insert prefixed row/column values + + node.append({ + prop: '-ms-grid-row', + value: row.start + }); + node.append({ + prop: '-ms-grid-column', + value: column.start + }); // insert rule + + parent.after(node); + }); + return undefined; +} + +module.exports = { + parse: parse, + translate: translate, + parseTemplate: parseTemplate, + parseGridAreas: parseGridAreas, + warnMissedAreas: warnMissedAreas, + insertAreas: insertAreas, + insertDecl: insertDecl, + prefixTrackProp: prefixTrackProp, + prefixTrackValue: prefixTrackValue, + getGridGap: getGridGap, + warnGridGap: warnGridGap, + warnTemplateSelectorNotFound: warnTemplateSelectorNotFound, + warnIfGridRowColumnExists: warnIfGridRowColumnExists, + inheritGridGap: inheritGridGap, + autoplaceGridItems: autoplaceGridItems +};
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/image-rendering.js b/node_modules/autoprefixer/lib/hacks/image-rendering.js new file mode 100644 index 0000000..d6de83c --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/image-rendering.js @@ -0,0 +1,73 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var ImageRendering = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(ImageRendering, _Declaration); + + function ImageRendering() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = ImageRendering.prototype; + + /** + * Add hack only for crisp-edges + */ + _proto.check = function check(decl) { + return decl.value === 'pixelated'; + } + /** + * Change property name for IE + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return '-ms-interpolation-mode'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Change property and value for IE + */ + ; + + _proto.set = function set(decl, prefix) { + if (prefix !== '-ms-') return _Declaration.prototype.set.call(this, decl, prefix); + decl.prop = '-ms-interpolation-mode'; + decl.value = 'nearest-neighbor'; + return decl; + } + /** + * Return property name by spec + */ + ; + + _proto.normalize = function normalize() { + return 'image-rendering'; + } + /** + * Warn on old value + */ + ; + + _proto.process = function process(node, result) { + return _Declaration.prototype.process.call(this, node, result); + }; + + return ImageRendering; +}(Declaration); + +_defineProperty(ImageRendering, "names", ['image-rendering', 'interpolation-mode']); + +module.exports = ImageRendering;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/image-set.js b/node_modules/autoprefixer/lib/hacks/image-set.js new file mode 100644 index 0000000..2263aaf --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/image-set.js @@ -0,0 +1,40 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Value = require('../value'); + +var ImageSet = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(ImageSet, _Value); + + function ImageSet() { + return _Value.apply(this, arguments) || this; + } + + var _proto = ImageSet.prototype; + + /** + * Use non-standard name for WebKit and Firefox + */ + _proto.replace = function replace(string, prefix) { + var fixed = _Value.prototype.replace.call(this, string, prefix); + + if (prefix === '-webkit-') { + fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2'); + } + + return fixed; + }; + + return ImageSet; +}(Value); + +_defineProperty(ImageSet, "names", ['image-set']); + +module.exports = ImageSet;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/inline-logical.js b/node_modules/autoprefixer/lib/hacks/inline-logical.js new file mode 100644 index 0000000..819f14a --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/inline-logical.js @@ -0,0 +1,42 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var InlineLogical = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(InlineLogical, _Declaration); + + function InlineLogical() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = InlineLogical.prototype; + + /** + * Use old syntax for -moz- and -webkit- + */ + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + prop.replace('-inline', ''); + } + /** + * Return property name by spec + */ + ; + + _proto.normalize = function normalize(prop) { + return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2'); + }; + + return InlineLogical; +}(Declaration); + +_defineProperty(InlineLogical, "names", ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']); + +module.exports = InlineLogical;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/intrinsic.js b/node_modules/autoprefixer/lib/hacks/intrinsic.js new file mode 100644 index 0000000..59367c0 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/intrinsic.js @@ -0,0 +1,76 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var OldValue = require('../old-value'); + +var Value = require('../value'); + +function _regexp(name) { + return new RegExp("(^|[\\s,(])(" + name + "($|[\\s),]))", 'gi'); +} + +var Intrinsic = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(Intrinsic, _Value); + + function Intrinsic() { + return _Value.apply(this, arguments) || this; + } + + var _proto = Intrinsic.prototype; + + _proto.regexp = function regexp() { + if (!this.regexpCache) this.regexpCache = _regexp(this.name); + return this.regexpCache; + }; + + _proto.isStretch = function isStretch() { + return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available'; + }; + + _proto.replace = function replace(string, prefix) { + if (prefix === '-moz-' && this.isStretch()) { + return string.replace(this.regexp(), '$1-moz-available$3'); + } + + if (prefix === '-webkit-' && this.isStretch()) { + return string.replace(this.regexp(), '$1-webkit-fill-available$3'); + } + + return _Value.prototype.replace.call(this, string, prefix); + }; + + _proto.old = function old(prefix) { + var prefixed = prefix + this.name; + + if (this.isStretch()) { + if (prefix === '-moz-') { + prefixed = '-moz-available'; + } else if (prefix === '-webkit-') { + prefixed = '-webkit-fill-available'; + } + } + + return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed)); + }; + + _proto.add = function add(decl, prefix) { + if (decl.prop.indexOf('grid') !== -1 && prefix !== '-webkit-') { + return undefined; + } + + return _Value.prototype.add.call(this, decl, prefix); + }; + + return Intrinsic; +}(Value); + +_defineProperty(Intrinsic, "names", ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']); + +module.exports = Intrinsic;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/justify-content.js b/node_modules/autoprefixer/lib/hacks/justify-content.js new file mode 100644 index 0000000..7e7bb95 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/justify-content.js @@ -0,0 +1,87 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var JustifyContent = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(JustifyContent, _Declaration); + + function JustifyContent() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = JustifyContent.prototype; + + /** + * Change property name for 2009 and 2012 specs + */ + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-pack'; + } + + if (spec === 2012) { + return prefix + 'flex-pack'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'justify-content'; + } + /** + * Change value for 2009 and 2012 specs + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2009 || spec === 2012) { + var value = JustifyContent.oldValues[decl.value] || decl.value; + decl.value = value; + + if (spec !== 2009 || value !== 'distribute') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + } else if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return undefined; + }; + + return JustifyContent; +}(Declaration); + +_defineProperty(JustifyContent, "names", ['justify-content', 'flex-pack', 'box-pack']); + +_defineProperty(JustifyContent, "oldValues", { + 'flex-end': 'end', + 'flex-start': 'start', + 'space-between': 'justify', + 'space-around': 'distribute' +}); + +module.exports = JustifyContent;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/mask-border.js b/node_modules/autoprefixer/lib/hacks/mask-border.js new file mode 100644 index 0000000..751615a --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/mask-border.js @@ -0,0 +1,48 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var MaskBorder = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(MaskBorder, _Declaration); + + function MaskBorder() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = MaskBorder.prototype; + + /** + * Return property name by final spec + */ + _proto.normalize = function normalize() { + return this.name.replace('box-image', 'border'); + } + /** + * Return flex property for 2012 spec + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + var result = _Declaration.prototype.prefixed.call(this, prop, prefix); + + if (prefix === '-webkit-') { + result = result.replace('border', 'box-image'); + } + + return result; + }; + + return MaskBorder; +}(Declaration); + +_defineProperty(MaskBorder, "names", ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']); + +module.exports = MaskBorder;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/mask-composite.js b/node_modules/autoprefixer/lib/hacks/mask-composite.js new file mode 100644 index 0000000..f68fe00 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/mask-composite.js @@ -0,0 +1,106 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var MaskComposite = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(MaskComposite, _Declaration); + + function MaskComposite() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = MaskComposite.prototype; + + /** + * Prefix mask-composite for webkit + */ + _proto.insert = function insert(decl, prefix, prefixes) { + var isCompositeProp = decl.prop === 'mask-composite'; + var compositeValues; + + if (isCompositeProp) { + compositeValues = decl.value.split(','); + } else { + compositeValues = decl.value.match(MaskComposite.regexp) || []; + } + + compositeValues = compositeValues.map(function (el) { + return el.trim(); + }).filter(function (el) { + return el; + }); + var hasCompositeValues = compositeValues.length; + var compositeDecl; + + if (hasCompositeValues) { + compositeDecl = this.clone(decl); + compositeDecl.value = compositeValues.map(function (value) { + return MaskComposite.oldValues[value] || value; + }).join(', '); + + if (compositeValues.includes('intersect')) { + compositeDecl.value += ', xor'; + } + + compositeDecl.prop = prefix + 'mask-composite'; + } + + if (isCompositeProp) { + if (!hasCompositeValues) { + return undefined; + } + + if (this.needCascade(decl)) { + compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + return decl.parent.insertBefore(decl, compositeDecl); + } + + var cloned = this.clone(decl); + cloned.prop = prefix + cloned.prop; + + if (hasCompositeValues) { + cloned.value = cloned.value.replace(MaskComposite.regexp, ''); + } + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + decl.parent.insertBefore(decl, cloned); + + if (!hasCompositeValues) { + return decl; + } + + if (this.needCascade(decl)) { + compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + return decl.parent.insertBefore(decl, compositeDecl); + }; + + return MaskComposite; +}(Declaration); + +_defineProperty(MaskComposite, "names", ['mask', 'mask-composite']); + +_defineProperty(MaskComposite, "oldValues", { + add: 'source-over', + substract: 'source-out', + intersect: 'source-in', + exclude: 'xor' +}); + +_defineProperty(MaskComposite, "regexp", new RegExp("\\s+(" + Object.keys(MaskComposite.oldValues).join('|') + ")\\b(?!\\))\\s*(?=[,])", 'ig')); + +module.exports = MaskComposite;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/order.js b/node_modules/autoprefixer/lib/hacks/order.js new file mode 100644 index 0000000..1226a41 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/order.js @@ -0,0 +1,74 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var flexSpec = require('./flex-spec'); + +var Declaration = require('../declaration'); + +var Order = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(Order, _Declaration); + + function Order() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = Order.prototype; + + /** + * Change property name for 2009 and 2012 specs + */ + _proto.prefixed = function prefixed(prop, prefix) { + var spec; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-ordinal-group'; + } + + if (spec === 2012) { + return prefix + 'flex-order'; + } + + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + /** + * Return property name by final spec + */ + ; + + _proto.normalize = function normalize() { + return 'order'; + } + /** + * Fix value for 2009 spec + */ + ; + + _proto.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + + if (spec === 2009 && /\d/.test(decl.value)) { + decl.value = (parseInt(decl.value) + 1).toString(); + return _Declaration.prototype.set.call(this, decl, prefix); + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return Order; +}(Declaration); + +_defineProperty(Order, "names", ['order', 'flex-order', 'box-ordinal-group']); + +module.exports = Order;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js b/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js new file mode 100644 index 0000000..be58e9e --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js @@ -0,0 +1,56 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var OverscrollBehavior = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(OverscrollBehavior, _Declaration); + + function OverscrollBehavior() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = OverscrollBehavior.prototype; + + /** + * Change property name for IE + */ + _proto.prefixed = function prefixed(prop, prefix) { + return prefix + 'scroll-chaining'; + } + /** + * Return property name by spec + */ + ; + + _proto.normalize = function normalize() { + return 'overscroll-behavior'; + } + /** + * Change value for IE + */ + ; + + _proto.set = function set(decl, prefix) { + if (decl.value === 'auto') { + decl.value = 'chained'; + } else if (decl.value === 'none' || decl.value === 'contain') { + decl.value = 'none'; + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return OverscrollBehavior; +}(Declaration); + +_defineProperty(OverscrollBehavior, "names", ['overscroll-behavior', 'scroll-chaining']); + +module.exports = OverscrollBehavior;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/pixelated.js b/node_modules/autoprefixer/lib/hacks/pixelated.js new file mode 100644 index 0000000..3e0b906 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/pixelated.js @@ -0,0 +1,60 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var OldValue = require('../old-value'); + +var Value = require('../value'); + +var Pixelated = +/*#__PURE__*/ +function (_Value) { + _inheritsLoose(Pixelated, _Value); + + function Pixelated() { + return _Value.apply(this, arguments) || this; + } + + var _proto = Pixelated.prototype; + + /** + * Use non-standard name for WebKit and Firefox + */ + _proto.replace = function replace(string, prefix) { + if (prefix === '-webkit-') { + return string.replace(this.regexp(), '$1-webkit-optimize-contrast'); + } + + if (prefix === '-moz-') { + return string.replace(this.regexp(), '$1-moz-crisp-edges'); + } + + return _Value.prototype.replace.call(this, string, prefix); + } + /** + * Different name for WebKit and Firefox + */ + ; + + _proto.old = function old(prefix) { + if (prefix === '-webkit-') { + return new OldValue(this.name, '-webkit-optimize-contrast'); + } + + if (prefix === '-moz-') { + return new OldValue(this.name, '-moz-crisp-edges'); + } + + return _Value.prototype.old.call(this, prefix); + }; + + return Pixelated; +}(Value); + +_defineProperty(Pixelated, "names", ['pixelated']); + +module.exports = Pixelated;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/place-self.js b/node_modules/autoprefixer/lib/hacks/place-self.js new file mode 100644 index 0000000..dc517ad --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/place-self.js @@ -0,0 +1,57 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var utils = require('./grid-utils'); + +var PlaceSelf = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(PlaceSelf, _Declaration); + + function PlaceSelf() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = PlaceSelf.prototype; + + /** + * Translate place-self to separate -ms- prefixed properties + */ + _proto.insert = function insert(decl, prefix, prefixes) { + if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); // prevent doubling of prefixes + + if (decl.parent.some(function (i) { + return i.prop === '-ms-grid-row-align'; + })) { + return undefined; + } + + var _utils$parse = utils.parse(decl), + _utils$parse$ = _utils$parse[0], + first = _utils$parse$[0], + second = _utils$parse$[1]; + + if (second) { + utils.insertDecl(decl, 'grid-row-align', first); + utils.insertDecl(decl, 'grid-column-align', second); + } else { + utils.insertDecl(decl, 'grid-row-align', first); + utils.insertDecl(decl, 'grid-column-align', first); + } + + return undefined; + }; + + return PlaceSelf; +}(Declaration); + +_defineProperty(PlaceSelf, "names", ['place-self']); + +module.exports = PlaceSelf;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/placeholder.js b/node_modules/autoprefixer/lib/hacks/placeholder.js new file mode 100644 index 0000000..d84026f --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/placeholder.js @@ -0,0 +1,58 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Selector = require('../selector'); + +var Placeholder = +/*#__PURE__*/ +function (_Selector) { + _inheritsLoose(Placeholder, _Selector); + + function Placeholder() { + return _Selector.apply(this, arguments) || this; + } + + var _proto = Placeholder.prototype; + + /** + * Add old mozilla to possible prefixes + */ + _proto.possible = function possible() { + return _Selector.prototype.possible.call(this).concat(['-moz- old', '-ms- old']); + } + /** + * Return different selectors depend on prefix + */ + ; + + _proto.prefixed = function prefixed(prefix) { + if (prefix === '-webkit-') { + return '::-webkit-input-placeholder'; + } + + if (prefix === '-ms-') { + return '::-ms-input-placeholder'; + } + + if (prefix === '-ms- old') { + return ':-ms-input-placeholder'; + } + + if (prefix === '-moz- old') { + return ':-moz-placeholder'; + } + + return "::" + prefix + "placeholder"; + }; + + return Placeholder; +}(Selector); + +_defineProperty(Placeholder, "names", ['::placeholder']); + +module.exports = Placeholder;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js b/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js new file mode 100644 index 0000000..7c3e630 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js @@ -0,0 +1,40 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var TextDecorationSkipInk = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(TextDecorationSkipInk, _Declaration); + + function TextDecorationSkipInk() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = TextDecorationSkipInk.prototype; + + /** + * Change prefix for ink value + */ + _proto.set = function set(decl, prefix) { + if (decl.prop === 'text-decoration-skip-ink' && decl.value === 'auto') { + decl.prop = prefix + 'text-decoration-skip'; + decl.value = 'ink'; + return decl; + } else { + return _Declaration.prototype.set.call(this, decl, prefix); + } + }; + + return TextDecorationSkipInk; +}(Declaration); + +_defineProperty(TextDecorationSkipInk, "names", ['text-decoration-skip-ink', 'text-decoration-skip']); + +module.exports = TextDecorationSkipInk;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/text-decoration.js b/node_modules/autoprefixer/lib/hacks/text-decoration.js new file mode 100644 index 0000000..40e0056 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/text-decoration.js @@ -0,0 +1,38 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset']; + +var TextDecoration = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(TextDecoration, _Declaration); + + function TextDecoration() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = TextDecoration.prototype; + + /** + * Do not add prefixes for basic values. + */ + _proto.check = function check(decl) { + return decl.value.split(/\s+/).some(function (i) { + return BASIC.indexOf(i) === -1; + }); + }; + + return TextDecoration; +}(Declaration); + +_defineProperty(TextDecoration, "names", ['text-decoration']); + +module.exports = TextDecoration;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js b/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js new file mode 100644 index 0000000..eef1218 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js @@ -0,0 +1,35 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var TextEmphasisPosition = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(TextEmphasisPosition, _Declaration); + + function TextEmphasisPosition() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = TextEmphasisPosition.prototype; + + _proto.set = function set(decl, prefix) { + if (prefix === '-webkit-') { + decl.value = decl.value.replace(/\s*(right|left)\s*/i, ''); + } + + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return TextEmphasisPosition; +}(Declaration); + +_defineProperty(TextEmphasisPosition, "names", ['text-emphasis-position']); + +module.exports = TextEmphasisPosition;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/transform-decl.js b/node_modules/autoprefixer/lib/hacks/transform-decl.js new file mode 100644 index 0000000..94c5a85 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/transform-decl.js @@ -0,0 +1,112 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var TransformDecl = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(TransformDecl, _Declaration); + + function TransformDecl() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = TransformDecl.prototype; + + /** + * Recursively check all parents for @keyframes + */ + _proto.keyframeParents = function keyframeParents(decl) { + var parent = decl.parent; + + while (parent) { + if (parent.type === 'atrule' && parent.name === 'keyframes') { + return true; + } + + var _parent = parent; + parent = _parent.parent; + } + + return false; + } + /** + * Is transform contain 3D commands + */ + ; + + _proto.contain3d = function contain3d(decl) { + if (decl.prop === 'transform-origin') { + return false; + } + + for (var _iterator = TransformDecl.functions3d, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var func = _ref; + + if (decl.value.indexOf(func + "(") !== -1) { + return true; + } + } + + return false; + } + /** + * Replace rotateZ to rotate for IE 9 + */ + ; + + _proto.set = function set(decl, prefix) { + decl = _Declaration.prototype.set.call(this, decl, prefix); + + if (prefix === '-ms-') { + decl.value = decl.value.replace(/rotateZ/gi, 'rotate'); + } + + return decl; + } + /** + * Don't add prefix for IE in keyframes + */ + ; + + _proto.insert = function insert(decl, prefix, prefixes) { + if (prefix === '-ms-') { + if (!this.contain3d(decl) && !this.keyframeParents(decl)) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + } else if (prefix === '-o-') { + if (!this.contain3d(decl)) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + } else { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + + return undefined; + }; + + return TransformDecl; +}(Declaration); + +_defineProperty(TransformDecl, "names", ['transform', 'transform-origin']); + +_defineProperty(TransformDecl, "functions3d", ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective']); + +module.exports = TransformDecl;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/hacks/writing-mode.js b/node_modules/autoprefixer/lib/hacks/writing-mode.js new file mode 100644 index 0000000..71bfc05 --- /dev/null +++ b/node_modules/autoprefixer/lib/hacks/writing-mode.js @@ -0,0 +1,61 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var Declaration = require('../declaration'); + +var WritingMode = +/*#__PURE__*/ +function (_Declaration) { + _inheritsLoose(WritingMode, _Declaration); + + function WritingMode() { + return _Declaration.apply(this, arguments) || this; + } + + var _proto = WritingMode.prototype; + + _proto.insert = function insert(decl, prefix, prefixes) { + if (prefix === '-ms-') { + var cloned = this.set(this.clone(decl), prefix); + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + + var direction = 'ltr'; + decl.parent.nodes.forEach(function (i) { + if (i.prop === 'direction') { + if (i.value === 'rtl' || i.value === 'ltr') direction = i.value; + } + }); + cloned.value = WritingMode.msValues[direction][decl.value] || decl.value; + return decl.parent.insertBefore(decl, cloned); + } + + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + }; + + return WritingMode; +}(Declaration); + +_defineProperty(WritingMode, "names", ['writing-mode']); + +_defineProperty(WritingMode, "msValues", { + ltr: { + 'horizontal-tb': 'lr-tb', + 'vertical-rl': 'tb-rl', + 'vertical-lr': 'tb-lr' + }, + rtl: { + 'horizontal-tb': 'rl-tb', + 'vertical-rl': 'bt-rl', + 'vertical-lr': 'bt-lr' + } +}); + +module.exports = WritingMode;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/info.js b/node_modules/autoprefixer/lib/info.js new file mode 100644 index 0000000..a036b20 --- /dev/null +++ b/node_modules/autoprefixer/lib/info.js @@ -0,0 +1,176 @@ +"use strict"; + +var browserslist = require('browserslist'); + +function capitalize(str) { + return str.slice(0, 1).toUpperCase() + str.slice(1); +} + +var NAMES = { + ie: 'IE', + ie_mob: 'IE Mobile', + ios_saf: 'iOS', + op_mini: 'Opera Mini', + op_mob: 'Opera Mobile', + and_chr: 'Chrome for Android', + and_ff: 'Firefox for Android', + and_uc: 'UC for Android' +}; + +function prefix(name, prefixes, note) { + var out = " " + name; + if (note) out += ' *'; + out += ': '; + out += prefixes.map(function (i) { + return i.replace(/^-(.*)-$/g, '$1'); + }).join(', '); + out += '\n'; + return out; +} + +module.exports = function (prefixes) { + if (prefixes.browsers.selected.length === 0) { + return 'No browsers selected'; + } + + var versions = {}; + + for (var _iterator = prefixes.browsers.selected, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var _browser = _ref; + + var parts = _browser.split(' '); + + var _name2 = parts[0]; + var version = parts[1]; + _name2 = NAMES[_name2] || capitalize(_name2); + + if (versions[_name2]) { + versions[_name2].push(version); + } else { + versions[_name2] = [version]; + } + } + + var out = 'Browsers:\n'; + + for (var browser in versions) { + var list = versions[browser]; + list = list.sort(function (a, b) { + return parseFloat(b) - parseFloat(a); + }); + out += " " + browser + ": " + list.join(', ') + "\n"; + } + + var coverage = browserslist.coverage(prefixes.browsers.selected); + var round = Math.round(coverage * 100) / 100.0; + out += "\nThese browsers account for " + round + "% of all users globally\n"; + var atrules = []; + + for (var name in prefixes.add) { + var data = prefixes.add[name]; + + if (name[0] === '@' && data.prefixes) { + atrules.push(prefix(name, data.prefixes)); + } + } + + if (atrules.length > 0) { + out += "\nAt-Rules:\n" + atrules.sort().join(''); + } + + var selectors = []; + + for (var _iterator2 = prefixes.add.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var selector = _ref2; + + if (selector.prefixes) { + selectors.push(prefix(selector.name, selector.prefixes)); + } + } + + if (selectors.length > 0) { + out += "\nSelectors:\n" + selectors.sort().join(''); + } + + var values = []; + var props = []; + var hadGrid = false; + + for (var _name in prefixes.add) { + var _data = prefixes.add[_name]; + + if (_name[0] !== '@' && _data.prefixes) { + var grid = _name.indexOf('grid-') === 0; + if (grid) hadGrid = true; + props.push(prefix(_name, _data.prefixes, grid)); + } + + if (!Array.isArray(_data.values)) { + continue; + } + + for (var _iterator3 = _data.values, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var value = _ref3; + + var _grid = value.name.includes('grid'); + + if (_grid) hadGrid = true; + var string = prefix(value.name, value.prefixes, _grid); + + if (!values.includes(string)) { + values.push(string); + } + } + } + + if (props.length > 0) { + out += "\nProperties:\n" + props.sort().join(''); + } + + if (values.length > 0) { + out += "\nValues:\n" + values.sort().join(''); + } + + if (hadGrid) { + out += '\n* - Prefixes will be added only on grid: true option.\n'; + } + + if (!atrules.length && !selectors.length && !props.length && !values.length) { + out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.'; + } + + return out; +};
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/old-selector.js b/node_modules/autoprefixer/lib/old-selector.js new file mode 100644 index 0000000..ba0913e --- /dev/null +++ b/node_modules/autoprefixer/lib/old-selector.js @@ -0,0 +1,95 @@ +"use strict"; + +var OldSelector = +/*#__PURE__*/ +function () { + function OldSelector(selector, prefix) { + this.prefix = prefix; + this.prefixed = selector.prefixed(this.prefix); + this.regexp = selector.regexp(this.prefix); + this.prefixeds = selector.possible().map(function (x) { + return [selector.prefixed(x), selector.regexp(x)]; + }); + this.unprefixed = selector.name; + this.nameRegexp = selector.regexp(); + } + /** + * Is rule a hack without unprefixed version bottom + */ + + + var _proto = OldSelector.prototype; + + _proto.isHack = function isHack(rule) { + var index = rule.parent.index(rule) + 1; + var rules = rule.parent.nodes; + + while (index < rules.length) { + var before = rules[index].selector; + + if (!before) { + return true; + } + + if (before.includes(this.unprefixed) && before.match(this.nameRegexp)) { + return false; + } + + var some = false; + + for (var _iterator = this.prefixeds, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var _ref2 = _ref, + string = _ref2[0], + regexp = _ref2[1]; + + if (before.includes(string) && before.match(regexp)) { + some = true; + break; + } + } + + if (!some) { + return true; + } + + index += 1; + } + + return true; + } + /** + * Does rule contain an unnecessary prefixed selector + */ + ; + + _proto.check = function check(rule) { + if (!rule.selector.includes(this.prefixed)) { + return false; + } + + if (!rule.selector.match(this.regexp)) { + return false; + } + + if (this.isHack(rule)) { + return false; + } + + return true; + }; + + return OldSelector; +}(); + +module.exports = OldSelector;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/old-value.js b/node_modules/autoprefixer/lib/old-value.js new file mode 100644 index 0000000..0a18e1e --- /dev/null +++ b/node_modules/autoprefixer/lib/old-value.js @@ -0,0 +1,32 @@ +"use strict"; + +var utils = require('./utils'); + +var OldValue = +/*#__PURE__*/ +function () { + function OldValue(unprefixed, prefixed, string, regexp) { + this.unprefixed = unprefixed; + this.prefixed = prefixed; + this.string = string || prefixed; + this.regexp = regexp || utils.regexp(prefixed); + } + /** + * Check, that value contain old value + */ + + + var _proto = OldValue.prototype; + + _proto.check = function check(value) { + if (value.includes(this.string)) { + return !!value.match(this.regexp); + } + + return false; + }; + + return OldValue; +}(); + +module.exports = OldValue;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/prefixer.js b/node_modules/autoprefixer/lib/prefixer.js new file mode 100644 index 0000000..63acf09 --- /dev/null +++ b/node_modules/autoprefixer/lib/prefixer.js @@ -0,0 +1,174 @@ +"use strict"; + +var vendor = require('postcss').vendor; + +var Browsers = require('./browsers'); + +var utils = require('./utils'); +/** + * Recursively clone objects + */ + + +function _clone(obj, parent) { + var cloned = new obj.constructor(); + + for (var _i = 0, _Object$keys = Object.keys(obj || {}); _i < _Object$keys.length; _i++) { + var i = _Object$keys[_i]; + var value = obj[i]; + + if (i === 'parent' && typeof value === 'object') { + if (parent) { + cloned[i] = parent; + } + } else if (i === 'source' || i === null) { + cloned[i] = value; + } else if (Array.isArray(value)) { + cloned[i] = value.map(function (x) { + return _clone(x, cloned); + }); + } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') { + if (typeof value === 'object' && value !== null) { + value = _clone(value, cloned); + } + + cloned[i] = value; + } + } + + return cloned; +} + +var Prefixer = +/*#__PURE__*/ +function () { + /** + * Add hack to selected names + */ + Prefixer.hack = function hack(klass) { + var _this = this; + + if (!this.hacks) { + this.hacks = {}; + } + + return klass.names.map(function (name) { + _this.hacks[name] = klass; + return _this.hacks[name]; + }); + } + /** + * Load hacks for some names + */ + ; + + Prefixer.load = function load(name, prefixes, all) { + var Klass = this.hacks && this.hacks[name]; + + if (Klass) { + return new Klass(name, prefixes, all); + } else { + return new this(name, prefixes, all); + } + } + /** + * Clone node and clean autprefixer custom caches + */ + ; + + Prefixer.clone = function clone(node, overrides) { + var cloned = _clone(node); + + for (var name in overrides) { + cloned[name] = overrides[name]; + } + + return cloned; + }; + + function Prefixer(name, prefixes, all) { + this.prefixes = prefixes; + this.name = name; + this.all = all; + } + /** + * Find prefix in node parents + */ + + + var _proto = Prefixer.prototype; + + _proto.parentPrefix = function parentPrefix(node) { + var prefix; + + if (typeof node._autoprefixerPrefix !== 'undefined') { + prefix = node._autoprefixerPrefix; + } else if (node.type === 'decl' && node.prop[0] === '-') { + prefix = vendor.prefix(node.prop); + } else if (node.type === 'root') { + prefix = false; + } else if (node.type === 'rule' && node.selector.includes(':-') && /:(-\w+-)/.test(node.selector)) { + prefix = node.selector.match(/:(-\w+-)/)[1]; + } else if (node.type === 'atrule' && node.name[0] === '-') { + prefix = vendor.prefix(node.name); + } else { + prefix = this.parentPrefix(node.parent); + } + + if (!Browsers.prefixes().includes(prefix)) { + prefix = false; + } + + node._autoprefixerPrefix = prefix; + return node._autoprefixerPrefix; + } + /** + * Clone node with prefixes + */ + ; + + _proto.process = function process(node, result) { + if (!this.check(node)) { + return undefined; + } + + var parent = this.parentPrefix(node); + var prefixes = this.prefixes.filter(function (prefix) { + return !parent || parent === utils.removeNote(prefix); + }); + var added = []; + + for (var _iterator = prefixes, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i2 >= _iterator.length) break; + _ref = _iterator[_i2++]; + } else { + _i2 = _iterator.next(); + if (_i2.done) break; + _ref = _i2.value; + } + + var prefix = _ref; + + if (this.add(node, prefix, added.concat([prefix]), result)) { + added.push(prefix); + } + } + + return added; + } + /** + * Shortcut for Prefixer.clone + */ + ; + + _proto.clone = function clone(node, overrides) { + return Prefixer.clone(node, overrides); + }; + + return Prefixer; +}(); + +module.exports = Prefixer;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/prefixes.js b/node_modules/autoprefixer/lib/prefixes.js new file mode 100644 index 0000000..ab696ae --- /dev/null +++ b/node_modules/autoprefixer/lib/prefixes.js @@ -0,0 +1,542 @@ +"use strict"; + +var vendor = require('postcss').vendor; + +var Declaration = require('./declaration'); + +var Resolution = require('./resolution'); + +var Transition = require('./transition'); + +var Processor = require('./processor'); + +var Supports = require('./supports'); + +var Browsers = require('./browsers'); + +var Selector = require('./selector'); + +var AtRule = require('./at-rule'); + +var Value = require('./value'); + +var utils = require('./utils'); + +Selector.hack(require('./hacks/fullscreen')); +Selector.hack(require('./hacks/placeholder')); +Declaration.hack(require('./hacks/flex')); +Declaration.hack(require('./hacks/order')); +Declaration.hack(require('./hacks/filter')); +Declaration.hack(require('./hacks/grid-end')); +Declaration.hack(require('./hacks/animation')); +Declaration.hack(require('./hacks/flex-flow')); +Declaration.hack(require('./hacks/flex-grow')); +Declaration.hack(require('./hacks/flex-wrap')); +Declaration.hack(require('./hacks/grid-area')); +Declaration.hack(require('./hacks/place-self')); +Declaration.hack(require('./hacks/grid-start')); +Declaration.hack(require('./hacks/align-self')); +Declaration.hack(require('./hacks/appearance')); +Declaration.hack(require('./hacks/flex-basis')); +Declaration.hack(require('./hacks/mask-border')); +Declaration.hack(require('./hacks/mask-composite')); +Declaration.hack(require('./hacks/align-items')); +Declaration.hack(require('./hacks/flex-shrink')); +Declaration.hack(require('./hacks/break-props')); +Declaration.hack(require('./hacks/color-adjust')); +Declaration.hack(require('./hacks/writing-mode')); +Declaration.hack(require('./hacks/border-image')); +Declaration.hack(require('./hacks/align-content')); +Declaration.hack(require('./hacks/border-radius')); +Declaration.hack(require('./hacks/block-logical')); +Declaration.hack(require('./hacks/grid-template')); +Declaration.hack(require('./hacks/inline-logical')); +Declaration.hack(require('./hacks/grid-row-align')); +Declaration.hack(require('./hacks/transform-decl')); +Declaration.hack(require('./hacks/flex-direction')); +Declaration.hack(require('./hacks/image-rendering')); +Declaration.hack(require('./hacks/backdrop-filter')); +Declaration.hack(require('./hacks/background-clip')); +Declaration.hack(require('./hacks/text-decoration')); +Declaration.hack(require('./hacks/justify-content')); +Declaration.hack(require('./hacks/background-size')); +Declaration.hack(require('./hacks/grid-row-column')); +Declaration.hack(require('./hacks/grid-rows-columns')); +Declaration.hack(require('./hacks/grid-column-align')); +Declaration.hack(require('./hacks/overscroll-behavior')); +Declaration.hack(require('./hacks/grid-template-areas')); +Declaration.hack(require('./hacks/text-emphasis-position')); +Declaration.hack(require('./hacks/text-decoration-skip-ink')); +Value.hack(require('./hacks/gradient')); +Value.hack(require('./hacks/intrinsic')); +Value.hack(require('./hacks/pixelated')); +Value.hack(require('./hacks/image-set')); +Value.hack(require('./hacks/cross-fade')); +Value.hack(require('./hacks/display-flex')); +Value.hack(require('./hacks/display-grid')); +Value.hack(require('./hacks/filter-value')); +var declsCache = {}; + +var Prefixes = +/*#__PURE__*/ +function () { + function Prefixes(data, browsers, options) { + if (options === void 0) { + options = {}; + } + + this.data = data; + this.browsers = browsers; + this.options = options; + + var _this$preprocess = this.preprocess(this.select(this.data)); + + this.add = _this$preprocess[0]; + this.remove = _this$preprocess[1]; + this.transition = new Transition(this); + this.processor = new Processor(this); + } + /** + * Return clone instance to remove all prefixes + */ + + + var _proto = Prefixes.prototype; + + _proto.cleaner = function cleaner() { + if (this.cleanerCache) { + return this.cleanerCache; + } + + if (this.browsers.selected.length) { + var empty = new Browsers(this.browsers.data, []); + this.cleanerCache = new Prefixes(this.data, empty, this.options); + } else { + return this; + } + + return this.cleanerCache; + } + /** + * Select prefixes from data, which is necessary for selected browsers + */ + ; + + _proto.select = function select(list) { + var _this = this; + + var selected = { + add: {}, + remove: {} + }; + + var _loop = function _loop(name) { + var data = list[name]; + var add = data.browsers.map(function (i) { + var params = i.split(' '); + return { + browser: params[0] + " " + params[1], + note: params[2] + }; + }); + var notes = add.filter(function (i) { + return i.note; + }).map(function (i) { + return _this.browsers.prefix(i.browser) + " " + i.note; + }); + notes = utils.uniq(notes); + add = add.filter(function (i) { + return _this.browsers.isSelected(i.browser); + }).map(function (i) { + var prefix = _this.browsers.prefix(i.browser); + + if (i.note) { + return prefix + " " + i.note; + } else { + return prefix; + } + }); + add = _this.sort(utils.uniq(add)); + + if (_this.options.flexbox === 'no-2009') { + add = add.filter(function (i) { + return !i.includes('2009'); + }); + } + + var all = data.browsers.map(function (i) { + return _this.browsers.prefix(i); + }); + + 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.includes(i); + }); + } + } else { + selected.remove[name] = all; + } + }; + + for (var name in list) { + _loop(name); + } + + return selected; + } + /** + * Sort vendor prefixes + */ + ; + + _proto.sort = function sort(prefixes) { + return prefixes.sort(function (a, b) { + var aLength = utils.removeNote(a).length; + var bLength = utils.removeNote(b).length; + + if (aLength === bLength) { + return b.length - a.length; + } else { + return bLength - aLength; + } + }); + } + /** + * Cache prefixes data to fast CSS processing + */ + ; + + _proto.preprocess = function preprocess(selected) { + var add = { + 'selectors': [], + '@supports': new Supports(Prefixes, this) + }; + + for (var name in selected.add) { + var prefixes = selected.add[name]; + + if (name === '@keyframes' || name === '@viewport') { + add[name] = new AtRule(name, prefixes, this); + } else if (name === '@resolution') { + add[name] = new Resolution(name, prefixes, this); + } else if (this.data[name].selector) { + add.selectors.push(Selector.load(name, prefixes, this)); + } else { + var props = this.data[name].props; + + if (props) { + var value = Value.load(name, prefixes, this); + + for (var _iterator = props, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prop = _ref; + + if (!add[prop]) { + add[prop] = { + values: [] + }; + } + + add[prop].values.push(value); + } + } else { + var values = add[name] && add[name].values || []; + add[name] = Declaration.load(name, prefixes, this); + add[name].values = values; + } + } + } + + var remove = { + selectors: [] + }; + + for (var _name in selected.remove) { + var _prefixes = selected.remove[_name]; + + if (this.data[_name].selector) { + var selector = Selector.load(_name, _prefixes); + + for (var _iterator2 = _prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var prefix = _ref2; + remove.selectors.push(selector.old(prefix)); + } + } else if (_name === '@keyframes' || _name === '@viewport') { + for (var _iterator3 = _prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var _prefix = _ref3; + + var prefixed = "@" + _prefix + _name.slice(1); + + remove[prefixed] = { + remove: true + }; + } + } else if (_name === '@resolution') { + remove[_name] = new Resolution(_name, _prefixes, this); + } else { + var _props = this.data[_name].props; + + if (_props) { + var _value = Value.load(_name, [], this); + + for (var _iterator4 = _prefixes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var _prefix2 = _ref4; + + var old = _value.old(_prefix2); + + if (old) { + for (var _iterator5 = _props, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var _prop = _ref5; + + if (!remove[_prop]) { + remove[_prop] = {}; + } + + if (!remove[_prop].values) { + remove[_prop].values = []; + } + + remove[_prop].values.push(old); + } + } + } + } else { + for (var _iterator6 = _prefixes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref6 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref6 = _i6.value; + } + + var p = _ref6; + var olds = this.decl(_name).old(_name, p); + + if (_name === 'align-self') { + var a = add[_name] && add[_name].prefixes; + + if (a) { + if (p === '-webkit- 2009' && a.includes('-webkit-')) { + continue; + } else if (p === '-webkit-' && a.includes('-webkit- 2009')) { + continue; + } + } + } + + for (var _iterator7 = olds, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) { + var _ref7; + + if (_isArray7) { + if (_i7 >= _iterator7.length) break; + _ref7 = _iterator7[_i7++]; + } else { + _i7 = _iterator7.next(); + if (_i7.done) break; + _ref7 = _i7.value; + } + + var _prefixed = _ref7; + + if (!remove[_prefixed]) { + remove[_prefixed] = {}; + } + + remove[_prefixed].remove = true; + } + } + } + } + } + + return [add, remove]; + } + /** + * Declaration loader with caching + */ + ; + + _proto.decl = function decl(prop) { + var decl = declsCache[prop]; + + if (decl) { + return decl; + } else { + declsCache[prop] = Declaration.load(prop); + return declsCache[prop]; + } + } + /** + * Return unprefixed version of property + */ + ; + + _proto.unprefixed = function unprefixed(prop) { + var value = this.normalize(vendor.unprefixed(prop)); + + if (value === 'flex-direction') { + value = 'flex-flow'; + } + + return value; + } + /** + * Normalize prefix for remover + */ + ; + + _proto.normalize = function normalize(prop) { + return this.decl(prop).normalize(prop); + } + /** + * Return prefixed version of property + */ + ; + + _proto.prefixed = function prefixed(prop, prefix) { + prop = vendor.unprefixed(prop); + return this.decl(prop).prefixed(prop, prefix); + } + /** + * Return values, which must be prefixed in selected property + */ + ; + + _proto.values = function values(type, prop) { + var data = this[type]; + var global = data['*'] && data['*'].values; + var values = data[prop] && data[prop].values; + + if (global && values) { + return utils.uniq(global.concat(values)); + } else { + return global || values || []; + } + } + /** + * Group declaration by unprefixed property to check them + */ + ; + + _proto.group = function group(decl) { + var _this2 = this; + + var rule = decl.parent; + var index = rule.index(decl); + var length = rule.nodes.length; + var unprefixed = this.unprefixed(decl.prop); + + var checker = function checker(step, callback) { + index += step; + + while (index >= 0 && index < length) { + var other = rule.nodes[index]; + + if (other.type === 'decl') { + if (step === -1 && other.prop === unprefixed) { + if (!Browsers.withPrefix(other.value)) { + break; + } + } + + if (_this2.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; + }; + + return { + up: function up(callback) { + return checker(-1, callback); + }, + down: function down(callback) { + return checker(+1, callback); + } + }; + }; + + return Prefixes; +}(); + +module.exports = Prefixes;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/processor.js b/node_modules/autoprefixer/lib/processor.js new file mode 100644 index 0000000..22c1076 --- /dev/null +++ b/node_modules/autoprefixer/lib/processor.js @@ -0,0 +1,754 @@ +"use strict"; + +var parser = require('postcss-value-parser'); + +var Value = require('./value'); + +var insertAreas = require('./hacks/grid-utils').insertAreas; + +var OLD_LINEAR = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i; +var OLD_RADIAL = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i; +var IGNORE_NEXT = /(!\s*)?autoprefixer:\s*ignore\s+next/i; +var GRID_REGEX = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i; +var SIZES = ['width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size']; + +function hasGridTemplate(decl) { + return decl.parent.some(function (i) { + return i.prop === 'grid-template' || i.prop === 'grid-template-areas'; + }); +} + +function hasRowsAndColumns(decl) { + var hasRows = decl.parent.some(function (i) { + return i.prop === 'grid-template-rows'; + }); + var hasColumns = decl.parent.some(function (i) { + return i.prop === 'grid-template-columns'; + }); + return hasRows && hasColumns; +} + +var Processor = +/*#__PURE__*/ +function () { + function Processor(prefixes) { + this.prefixes = prefixes; + } + /** + * Add necessary prefixes + */ + + + var _proto = Processor.prototype; + + _proto.add = function add(css, result) { + var _this = this; + + // At-rules + var resolution = this.prefixes.add['@resolution']; + var keyframes = this.prefixes.add['@keyframes']; + var viewport = this.prefixes.add['@viewport']; + var supports = this.prefixes.add['@supports']; + css.walkAtRules(function (rule) { + if (rule.name === 'keyframes') { + if (!_this.disabled(rule, result)) { + return keyframes && keyframes.process(rule); + } + } else if (rule.name === 'viewport') { + if (!_this.disabled(rule, result)) { + return viewport && viewport.process(rule); + } + } else if (rule.name === 'supports') { + if (_this.prefixes.options.supports !== false && !_this.disabled(rule, result)) { + return supports.process(rule); + } + } else if (rule.name === 'media' && rule.params.includes('-resolution')) { + if (!_this.disabled(rule, result)) { + return resolution && resolution.process(rule); + } + } + + return undefined; + }); // Selectors + + css.walkRules(function (rule) { + if (_this.disabled(rule, result)) return undefined; + return _this.prefixes.add.selectors.map(function (selector) { + return selector.process(rule, result); + }); + }); + + function insideGrid(decl) { + return decl.parent.nodes.some(function (node) { + if (node.type !== 'decl') return false; + var displayGrid = node.prop === 'display' && /(inline-)?grid/.test(node.value); + var gridTemplate = node.prop.startsWith('grid-template'); + var gridGap = /^grid-([A-z]+-)?gap/.test(node.prop); + return displayGrid || gridTemplate || gridGap; + }); + } + + function insideFlex(decl) { + return decl.parent.some(function (node) { + return node.prop === 'display' && /(inline-)?flex/.test(node.value); + }); + } + + var gridPrefixes = this.gridStatus(css, result) && this.prefixes.add['grid-area'] && this.prefixes.add['grid-area'].prefixes; + css.walkDecls(function (decl) { + if (_this.disabledDecl(decl, result)) return undefined; + var parent = decl.parent; + var prop = decl.prop; + var value = decl.value; + + if (prop === 'grid-row-span') { + result.warn('grid-row-span is not part of final Grid Layout. Use grid-row.', { + node: decl + }); + return undefined; + } else if (prop === 'grid-column-span') { + result.warn('grid-column-span is not part of final Grid Layout. Use grid-column.', { + node: decl + }); + return undefined; + } else if (prop === 'display' && value === 'box') { + result.warn('You should write display: flex by final spec ' + 'instead of display: box', { + node: decl + }); + return undefined; + } else if (prop === 'text-emphasis-position') { + if (value === 'under' || value === 'over') { + result.warn('You should use 2 values for text-emphasis-position ' + 'For example, `under left` instead of just `under`.', { + node: decl + }); + } + } else if (/^(align|justify|place)-(items|content)$/.test(prop) && insideFlex(decl)) { + if (value === 'start' || value === 'end') { + result.warn(value + " value has mixed support, consider using " + ("flex-" + value + " instead"), { + node: decl + }); + } + } else if (prop === 'text-decoration-skip' && value === 'ink') { + result.warn('Replace text-decoration-skip: ink to ' + 'text-decoration-skip-ink: auto, because spec had been changed', { + node: decl + }); + } else { + if (gridPrefixes) { + if (/^(align|justify|place)-items$/.test(prop) && insideGrid(decl)) { + var fixed = prop.replace('-items', '-self'); + result.warn("IE does not support " + prop + " on grid containers. " + ("Try using " + fixed + " on child elements instead: ") + (decl.parent.selector + " > * { " + fixed + ": " + decl.value + " }"), { + node: decl + }); + } else if (/^(align|justify|place)-content$/.test(prop) && insideGrid(decl)) { + result.warn("IE does not support " + decl.prop + " on grid containers", { + node: decl + }); + } else if (prop === 'display' && decl.value === 'contents') { + result.warn('Please do not use display: contents; ' + 'if you have grid setting enabled', { + node: decl + }); + return undefined; + } else if (decl.prop === 'grid-gap') { + var status = _this.gridStatus(decl, result); + + if (status === 'autoplace' && !hasRowsAndColumns(decl) && !hasGridTemplate(decl)) { + result.warn('grid-gap only works if grid-template(-areas) is being ' + 'used or both rows and columns have been declared ' + 'and cells have not been manually ' + 'placed inside the explicit grid', { + node: decl + }); + } else if ((status === true || status === 'no-autoplace') && !hasGridTemplate(decl)) { + result.warn('grid-gap only works if grid-template(-areas) is being used', { + node: decl + }); + } + } else if (prop === 'grid-auto-columns') { + result.warn('grid-auto-columns is not supported by IE', { + node: decl + }); + return undefined; + } else if (prop === 'grid-auto-rows') { + result.warn('grid-auto-rows is not supported by IE', { + node: decl + }); + return undefined; + } else if (prop === 'grid-auto-flow') { + var hasRows = parent.some(function (i) { + return i.prop === 'grid-template-rows'; + }); + var hasCols = parent.some(function (i) { + return i.prop === 'grid-template-columns'; + }); + + if (hasGridTemplate(decl)) { + result.warn('grid-auto-flow is not supported by IE', { + node: decl + }); + } else if (value.includes('dense')) { + result.warn('grid-auto-flow: dense is not supported by IE', { + node: decl + }); + } else if (!hasRows && !hasCols) { + result.warn('grid-auto-flow works only if grid-template-rows and ' + 'grid-template-columns are present in the same rule', { + node: decl + }); + } + + return undefined; + } else if (value.includes('auto-fit')) { + result.warn('auto-fit value is not supported by IE', { + node: decl, + word: 'auto-fit' + }); + return undefined; + } else if (value.includes('auto-fill')) { + result.warn('auto-fill value is not supported by IE', { + node: decl, + word: 'auto-fill' + }); + return undefined; + } else if (prop.startsWith('grid-template') && value.includes('[')) { + result.warn('Autoprefixer currently does not support line names. ' + 'Try using grid-template-areas instead.', { + node: decl, + word: '[' + }); + } + } + + if (value.includes('radial-gradient')) { + if (OLD_RADIAL.test(decl.value)) { + result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `closest-side at 0 0` ' + 'instead of `0 0, closest-side`.', { + node: decl + }); + } else { + var ast = parser(value); + + for (var _iterator = ast.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if (i.type === 'function' && i.value === 'radial-gradient') { + for (var _iterator2 = i.nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var word = _ref2; + + if (word.type === 'word') { + if (word.value === 'cover') { + result.warn('Gradient has outdated direction syntax. ' + 'Replace `cover` to `farthest-corner`.', { + node: decl + }); + } else if (word.value === 'contain') { + result.warn('Gradient has outdated direction syntax. ' + 'Replace `contain` to `closest-side`.', { + node: decl + }); + } + } + } + } + } + } + } + + if (value.includes('linear-gradient')) { + if (OLD_LINEAR.test(value)) { + result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `to left` instead of `right`.', { + node: decl + }); + } + } + } + + if (SIZES.includes(decl.prop)) { + if (!decl.value.includes('-fill-available')) { + if (decl.value.includes('fill-available')) { + result.warn('Replace fill-available to stretch, ' + 'because spec had been changed', { + node: decl + }); + } else if (decl.value.includes('fill')) { + var _ast = parser(value); + + if (_ast.nodes.some(function (i) { + return i.type === 'word' && i.value === 'fill'; + })) { + result.warn('Replace fill to stretch, because spec had been changed', { + node: decl + }); + } + } + } + } + + var prefixer; + + if (decl.prop === 'transition' || decl.prop === 'transition-property') { + // Transition + return _this.prefixes.transition.add(decl, result); + } else if (decl.prop === 'align-self') { + // align-self flexbox or grid + var display = _this.displayType(decl); + + if (display !== 'grid' && _this.prefixes.options.flexbox !== false) { + prefixer = _this.prefixes.add['align-self']; + + if (prefixer && prefixer.prefixes) { + prefixer.process(decl); + } + } + + if (display !== 'flex' && _this.gridStatus(decl, result) !== false) { + prefixer = _this.prefixes.add['grid-row-align']; + + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl, result); + } + } + } else if (decl.prop === 'justify-self') { + // justify-self flexbox or grid + var _display = _this.displayType(decl); + + if (_display !== 'flex' && _this.gridStatus(decl, result) !== false) { + prefixer = _this.prefixes.add['grid-column-align']; + + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl, result); + } + } + } else if (decl.prop === 'place-self') { + prefixer = _this.prefixes.add['place-self']; + + if (prefixer && prefixer.prefixes && _this.gridStatus(decl, result) !== false) { + return prefixer.process(decl, result); + } + } else { + // Properties + prefixer = _this.prefixes.add[decl.prop]; + + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl, result); + } + } + + return undefined; + }); // Insert grid-area prefixes. We need to be able to store the different + // rules as a data and hack API is not enough for this + + if (this.gridStatus(css, result)) { + insertAreas(css, this.disabled); + } // Values + + + return css.walkDecls(function (decl) { + if (_this.disabledValue(decl, result)) return; + + var unprefixed = _this.prefixes.unprefixed(decl.prop); + + for (var _iterator3 = _this.prefixes.values('add', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var value = _ref3; + value.process(decl, result); + } + + Value.save(_this.prefixes, decl); + }); + } + /** + * Remove unnecessary pefixes + */ + ; + + _proto.remove = function remove(css, result) { + var _this2 = this; + + // At-rules + var resolution = this.prefixes.remove['@resolution']; + css.walkAtRules(function (rule, i) { + if (_this2.prefixes.remove["@" + rule.name]) { + if (!_this2.disabled(rule, result)) { + rule.parent.removeChild(i); + } + } else if (rule.name === 'media' && rule.params.includes('-resolution') && resolution) { + resolution.clean(rule); + } + }); // Selectors + + var _loop = function _loop() { + if (_isArray4) { + if (_i4 >= _iterator4.length) return "break"; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) return "break"; + _ref4 = _i4.value; + } + + var checker = _ref4; + css.walkRules(function (rule, i) { + if (checker.check(rule)) { + if (!_this2.disabled(rule, result)) { + rule.parent.removeChild(i); + } + } + }); + }; + + for (var _iterator4 = this.prefixes.remove.selectors, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + var _ret = _loop(); + + if (_ret === "break") break; + } + + return css.walkDecls(function (decl, i) { + if (_this2.disabled(decl, result)) return; + var rule = decl.parent; + + var unprefixed = _this2.prefixes.unprefixed(decl.prop); // Transition + + + if (decl.prop === 'transition' || decl.prop === 'transition-property') { + _this2.prefixes.transition.remove(decl); + } // Properties + + + if (_this2.prefixes.remove[decl.prop] && _this2.prefixes.remove[decl.prop].remove) { + var notHack = _this2.prefixes.group(decl).down(function (other) { + return _this2.prefixes.normalize(other.prop) === unprefixed; + }); + + if (unprefixed === 'flex-flow') { + notHack = true; + } + + if (decl.prop === '-webkit-box-orient') { + var hacks = { + 'flex-direction': true, + 'flex-flow': true + }; + if (!decl.parent.some(function (j) { + return hacks[j.prop]; + })) return; + } + + if (notHack && !_this2.withHackValue(decl)) { + if (decl.raw('before').includes('\n')) { + _this2.reduceSpaces(decl); + } + + rule.removeChild(i); + return; + } + } // Values + + + for (var _iterator5 = _this2.prefixes.values('remove', unprefixed), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var checker = _ref5; + + if (!checker.check(decl.value)) { + continue; + } + + unprefixed = checker.unprefixed; + + var _notHack = _this2.prefixes.group(decl).down(function (other) { + return other.value.includes(unprefixed); + }); + + if (_notHack) { + rule.removeChild(i); + return; + } + } + }); + } + /** + * Some rare old values, which is not in standard + */ + ; + + _proto.withHackValue = function withHackValue(decl) { + return decl.prop === '-webkit-background-clip' && decl.value === 'text'; + } + /** + * Check for grid/flexbox options. + */ + ; + + _proto.disabledValue = function disabledValue(node, result) { + if (this.gridStatus(node, result) === false && node.type === 'decl') { + if (node.prop === 'display' && node.value.includes('grid')) { + return true; + } + } + + if (this.prefixes.options.flexbox === false && node.type === 'decl') { + if (node.prop === 'display' && node.value.includes('flex')) { + return true; + } + } + + return this.disabled(node, result); + } + /** + * Check for grid/flexbox options. + */ + ; + + _proto.disabledDecl = function disabledDecl(node, result) { + if (this.gridStatus(node, result) === false && node.type === 'decl') { + if (node.prop.includes('grid') || node.prop === 'justify-items') { + return true; + } + } + + if (this.prefixes.options.flexbox === false && node.type === 'decl') { + var other = ['order', 'justify-content', 'align-items', 'align-content']; + + if (node.prop.includes('flex') || other.includes(node.prop)) { + return true; + } + } + + return this.disabled(node, result); + } + /** + * Check for control comment and global options + */ + ; + + _proto.disabled = function disabled(node, result) { + if (!node) return false; + + if (node._autoprefixerDisabled !== undefined) { + return node._autoprefixerDisabled; + } + + if (node.parent) { + var p = node.prev(); + + if (p && p.type === 'comment' && IGNORE_NEXT.test(p.text)) { + node._autoprefixerDisabled = true; + node._autoprefixerSelfDisabled = true; + return true; + } + } + + var value = null; + + if (node.nodes) { + var status; + node.each(function (i) { + if (i.type !== 'comment') return; + + if (/(!\s*)?autoprefixer:\s*(off|on)/i.test(i.text)) { + if (typeof status !== 'undefined') { + result.warn('Second Autoprefixer control comment ' + 'was ignored. Autoprefixer applies control ' + 'comment to whole block, not to next rules.', { + node: i + }); + } else { + status = /on/i.test(i.text); + } + } + }); + + if (status !== undefined) { + value = !status; + } + } + + if (!node.nodes || value === null) { + if (node.parent) { + var isParentDisabled = this.disabled(node.parent, result); + + if (node.parent._autoprefixerSelfDisabled === true) { + value = false; + } else { + value = isParentDisabled; + } + } else { + value = false; + } + } + + node._autoprefixerDisabled = value; + return value; + } + /** + * Normalize spaces in cascade declaration group + */ + ; + + _proto.reduceSpaces = function reduceSpaces(decl) { + var stop = false; + this.prefixes.group(decl).up(function () { + stop = true; + return true; + }); + + if (stop) { + return; + } + + var parts = decl.raw('before').split('\n'); + var prevMin = parts[parts.length - 1].length; + var diff = false; + this.prefixes.group(decl).down(function (other) { + parts = other.raw('before').split('\n'); + var last = parts.length - 1; + + if (parts[last].length > prevMin) { + if (diff === false) { + diff = parts[last].length - prevMin; + } + + parts[last] = parts[last].slice(0, -diff); + other.raws.before = parts.join('\n'); + } + }); + } + /** + * Is it flebox or grid rule + */ + ; + + _proto.displayType = function displayType(decl) { + for (var _iterator6 = decl.parent.nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref6 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref6 = _i6.value; + } + + var i = _ref6; + + if (i.prop !== 'display') { + continue; + } + + if (i.value.includes('flex')) { + return 'flex'; + } + + if (i.value.includes('grid')) { + return 'grid'; + } + } + + return false; + } + /** + * Set grid option via control comment + */ + ; + + _proto.gridStatus = function gridStatus(node, result) { + if (!node) return false; + + if (node._autoprefixerGridStatus !== undefined) { + return node._autoprefixerGridStatus; + } + + var value = null; + + if (node.nodes) { + var status; + node.each(function (i) { + if (i.type !== 'comment') return; + + if (GRID_REGEX.test(i.text)) { + var hasAutoplace = /:\s*autoplace/i.test(i.text); + var noAutoplace = /no-autoplace/i.test(i.text); + + if (typeof status !== 'undefined') { + result.warn('Second Autoprefixer grid control comment was ' + 'ignored. Autoprefixer applies control comments to the whole ' + 'block, not to the next rules.', { + node: i + }); + } else if (hasAutoplace) { + status = 'autoplace'; + } else if (noAutoplace) { + status = true; + } else { + status = /on/i.test(i.text); + } + } + }); + + if (status !== undefined) { + value = status; + } + } + + if (node.type === 'atrule' && node.name === 'supports') { + var params = node.params; + + if (params.includes('grid') && params.includes('auto')) { + value = false; + } + } + + if (!node.nodes || value === null) { + if (node.parent) { + var isParentGrid = this.gridStatus(node.parent, result); + + if (node.parent._autoprefixerSelfDisabled === true) { + value = false; + } else { + value = isParentGrid; + } + } else { + value = this.prefixes.options.grid; + } + } + + node._autoprefixerGridStatus = value; + return value; + }; + + return Processor; +}(); + +module.exports = Processor;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/resolution.js b/node_modules/autoprefixer/lib/resolution.js new file mode 100644 index 0000000..4092e4e --- /dev/null +++ b/node_modules/autoprefixer/lib/resolution.js @@ -0,0 +1,156 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +var n2f = require('num2fraction'); + +var Prefixer = require('./prefixer'); + +var utils = require('./utils'); + +var REGEXP = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi|x)/gi; +var SPLIT = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi|x)/i; + +var Resolution = +/*#__PURE__*/ +function (_Prefixer) { + _inheritsLoose(Resolution, _Prefixer); + + function Resolution() { + return _Prefixer.apply(this, arguments) || this; + } + + var _proto = Resolution.prototype; + + /** + * Return prefixed query name + */ + _proto.prefixName = function prefixName(prefix, name) { + if (prefix === '-moz-') { + return name + '--moz-device-pixel-ratio'; + } else { + return prefix + name + '-device-pixel-ratio'; + } + } + /** + * Return prefixed query + */ + ; + + _proto.prefixQuery = function prefixQuery(prefix, name, colon, value, units) { + if (units === 'dpi') { + value = Number(value / 96); + } + + if (prefix === '-o-') { + value = n2f(value); + } + + return this.prefixName(prefix, name) + colon + value; + } + /** + * Remove prefixed queries + */ + ; + + _proto.clean = function clean(rule) { + var _this = this; + + if (!this.bad) { + this.bad = []; + + for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + this.bad.push(this.prefixName(prefix, 'min')); + this.bad.push(this.prefixName(prefix, 'max')); + } + } + + rule.params = utils.editList(rule.params, function (queries) { + return queries.filter(function (query) { + return _this.bad.every(function (i) { + return !query.includes(i); + }); + }); + }); + } + /** + * Add prefixed queries + */ + ; + + _proto.process = function process(rule) { + var _this2 = this; + + var parent = this.parentPrefix(rule); + var prefixes = parent ? [parent] : this.prefixes; + rule.params = utils.editList(rule.params, function (origin, prefixed) { + for (var _iterator2 = origin, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var query = _ref2; + + if (!query.includes('min-resolution') && !query.includes('max-resolution')) { + prefixed.push(query); + continue; + } + + var _loop = function _loop() { + if (_isArray3) { + if (_i3 >= _iterator3.length) return "break"; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) return "break"; + _ref3 = _i3.value; + } + + var prefix = _ref3; + var processed = query.replace(REGEXP, function (str) { + var parts = str.match(SPLIT); + return _this2.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]); + }); + prefixed.push(processed); + }; + + for (var _iterator3 = prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + var _ret = _loop(); + + if (_ret === "break") break; + } + + prefixed.push(query); + } + + return utils.uniq(prefixed); + }); + }; + + return Resolution; +}(Prefixer); + +module.exports = Resolution;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/selector.js b/node_modules/autoprefixer/lib/selector.js new file mode 100644 index 0000000..3770afb --- /dev/null +++ b/node_modules/autoprefixer/lib/selector.js @@ -0,0 +1,178 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +var OldSelector = require('./old-selector'); + +var Prefixer = require('./prefixer'); + +var Browsers = require('./browsers'); + +var utils = require('./utils'); + +var Selector = +/*#__PURE__*/ +function (_Prefixer) { + _inheritsLoose(Selector, _Prefixer); + + function Selector(name, prefixes, all) { + var _this; + + _this = _Prefixer.call(this, name, prefixes, all) || this; + _this.regexpCache = {}; + return _this; + } + /** + * Is rule selectors need to be prefixed + */ + + + var _proto = Selector.prototype; + + _proto.check = function check(rule) { + if (rule.selector.includes(this.name)) { + return !!rule.selector.match(this.regexp()); + } + + return false; + } + /** + * Return prefixed version of selector + */ + ; + + _proto.prefixed = function prefixed(prefix) { + return this.name.replace(/^([^\w]*)/, "$1" + prefix); + } + /** + * Lazy loadRegExp for name + */ + ; + + _proto.regexp = function regexp(prefix) { + if (this.regexpCache[prefix]) { + return this.regexpCache[prefix]; + } + + var name = prefix ? this.prefixed(prefix) : this.name; + this.regexpCache[prefix] = new RegExp("(^|[^:\"'=])" + utils.escapeRegexp(name), 'gi'); + return this.regexpCache[prefix]; + } + /** + * All possible prefixes + */ + ; + + _proto.possible = function possible() { + return Browsers.prefixes(); + } + /** + * Return all possible selector prefixes + */ + ; + + _proto.prefixeds = function prefixeds(rule) { + if (rule._autoprefixerPrefixeds) { + return rule._autoprefixerPrefixeds; + } + + var prefixeds = {}; + + for (var _iterator = this.possible(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + prefixeds[prefix] = this.replace(rule.selector, prefix); + } + + rule._autoprefixerPrefixeds = prefixeds; + return rule._autoprefixerPrefixeds; + } + /** + * Is rule already prefixed before + */ + ; + + _proto.already = function already(rule, prefixeds, prefix) { + var index = rule.parent.index(rule) - 1; + + while (index >= 0) { + var before = rule.parent.nodes[index]; + + if (before.type !== 'rule') { + return false; + } + + var some = false; + + for (var key in prefixeds) { + var prefixed = prefixeds[key]; + + if (before.selector === prefixed) { + if (prefix === key) { + return true; + } else { + some = true; + break; + } + } + } + + if (!some) { + return false; + } + + index -= 1; + } + + return false; + } + /** + * Replace selectors by prefixed one + */ + ; + + _proto.replace = function replace(selector, prefix) { + return selector.replace(this.regexp(), "$1" + this.prefixed(prefix)); + } + /** + * Clone and add prefixes for at-rule + */ + ; + + _proto.add = function add(rule, prefix) { + var prefixeds = this.prefixeds(rule); + + if (this.already(rule, prefixeds, prefix)) { + return; + } + + var cloned = this.clone(rule, { + selector: prefixeds[prefix] + }); + rule.parent.insertBefore(rule, cloned); + } + /** + * Return function to fast find prefixed selector + */ + ; + + _proto.old = function old(prefix) { + return new OldSelector(this, prefix); + }; + + return Selector; +}(Prefixer); + +module.exports = Selector;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/supports.js b/node_modules/autoprefixer/lib/supports.js new file mode 100644 index 0000000..431caa0 --- /dev/null +++ b/node_modules/autoprefixer/lib/supports.js @@ -0,0 +1,386 @@ +"use strict"; + +var postcss = require('postcss'); + +var data = require('caniuse-lite').feature(require('caniuse-lite/data/features/css-featurequeries.js')); + +var Browsers = require('./browsers'); + +var brackets = require('./brackets'); + +var Value = require('./value'); + +var utils = require('./utils'); + +var supported = []; + +for (var browser in data.stats) { + var versions = data.stats[browser]; + + for (var version in versions) { + var support = versions[version]; + + if (/y/.test(support)) { + supported.push(browser + ' ' + version); + } + } +} + +var Supports = +/*#__PURE__*/ +function () { + function Supports(Prefixes, all) { + this.Prefixes = Prefixes; + this.all = all; + } + /** + * Return prefixer only with @supports supported browsers + */ + + + var _proto = Supports.prototype; + + _proto.prefixer = function prefixer() { + if (this.prefixerCache) { + return this.prefixerCache; + } + + var filtered = this.all.browsers.selected.filter(function (i) { + return supported.includes(i); + }); + var browsers = new Browsers(this.all.browsers.data, filtered, this.all.options); + this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options); + return this.prefixerCache; + } + /** + * Parse string into declaration property and value + */ + ; + + _proto.parse = function parse(str) { + var parts = str.split(':'); + var prop = parts[0]; + var value = parts[1]; + if (!value) value = ''; + return [prop.trim(), value.trim()]; + } + /** + * Create virtual rule to process it by prefixer + */ + ; + + _proto.virtual = function virtual(str) { + var _this$parse = this.parse(str), + prop = _this$parse[0], + value = _this$parse[1]; + + var rule = postcss.parse('a{}').first; + rule.append({ + prop: prop, + value: value, + raws: { + before: '' + } + }); + return rule; + } + /** + * Return array of Declaration with all necessary prefixes + */ + ; + + _proto.prefixed = function prefixed(str) { + var rule = this.virtual(str); + + if (this.disabled(rule.first)) { + return rule.nodes; + } + + var result = { + warn: function warn() { + return null; + } + }; + var prefixer = this.prefixer().add[rule.first.prop]; + prefixer && prefixer.process && prefixer.process(rule.first, result); + + for (var _iterator = rule.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var decl = _ref; + + for (var _iterator2 = this.prefixer().values('add', rule.first.prop), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var value = _ref2; + value.process(decl); + } + + Value.save(this.all, decl); + } + + return rule.nodes; + } + /** + * Return true if brackets node is "not" word + */ + ; + + _proto.isNot = function isNot(node) { + return typeof node === 'string' && /not\s*/i.test(node); + } + /** + * Return true if brackets node is "or" word + */ + ; + + _proto.isOr = function isOr(node) { + return typeof node === 'string' && /\s*or\s*/i.test(node); + } + /** + * Return true if brackets node is (prop: value) + */ + ; + + _proto.isProp = function isProp(node) { + return typeof node === 'object' && node.length === 1 && typeof node[0] === 'string'; + } + /** + * Return true if prefixed property has no unprefixed + */ + ; + + _proto.isHack = function isHack(all, unprefixed) { + var check = new RegExp("(\\(|\\s)" + utils.escapeRegexp(unprefixed) + ":"); + return !check.test(all); + } + /** + * Return true if we need to remove node + */ + ; + + _proto.toRemove = function toRemove(str, all) { + var _this$parse2 = this.parse(str), + prop = _this$parse2[0], + value = _this$parse2[1]; + + var unprefixed = this.all.unprefixed(prop); + var cleaner = this.all.cleaner(); + + if (cleaner.remove[prop] && cleaner.remove[prop].remove && !this.isHack(all, unprefixed)) { + return true; + } + + for (var _iterator3 = cleaner.values('remove', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var checker = _ref3; + + if (checker.check(value)) { + return true; + } + } + + return false; + } + /** + * Remove all unnecessary prefixes + */ + ; + + _proto.remove = function remove(nodes, all) { + var i = 0; + + while (i < nodes.length) { + if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) { + if (this.toRemove(nodes[i][0], all)) { + nodes.splice(i, 2); + continue; + } + + i += 2; + continue; + } + + if (typeof nodes[i] === 'object') { + nodes[i] = this.remove(nodes[i], all); + } + + i += 1; + } + + return nodes; + } + /** + * Clean brackets with one child + */ + ; + + _proto.cleanBrackets = function cleanBrackets(nodes) { + var _this = this; + + return nodes.map(function (i) { + if (typeof i !== 'object') { + return i; + } + + if (i.length === 1 && typeof i[0] === 'object') { + return _this.cleanBrackets(i[0]); + } + + return _this.cleanBrackets(i); + }); + } + /** + * Add " or " between properties and convert it to brackets format + */ + ; + + _proto.convert = function convert(progress) { + var result = ['']; + + for (var _iterator4 = progress, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var i = _ref4; + result.push([i.prop + ": " + i.value]); + result.push(' or '); + } + + result[result.length - 1] = ''; + return result; + } + /** + * Compress value functions into a string nodes + */ + ; + + _proto.normalize = function normalize(nodes) { + var _this2 = this; + + if (typeof nodes !== 'object') { + return nodes; + } + + nodes = nodes.filter(function (i) { + return i !== ''; + }); + + if (typeof nodes[0] === 'string' && nodes[0].includes(':')) { + return [brackets.stringify(nodes)]; + } + + return nodes.map(function (i) { + return _this2.normalize(i); + }); + } + /** + * Add prefixes + */ + ; + + _proto.add = function add(nodes, all) { + var _this3 = this; + + return nodes.map(function (i) { + if (_this3.isProp(i)) { + var prefixed = _this3.prefixed(i[0]); + + if (prefixed.length > 1) { + return _this3.convert(prefixed); + } + + return i; + } + + if (typeof i === 'object') { + return _this3.add(i, all); + } + + return i; + }); + } + /** + * Add prefixed declaration + */ + ; + + _proto.process = function process(rule) { + var ast = brackets.parse(rule.params); + ast = this.normalize(ast); + ast = this.remove(ast, rule.params); + ast = this.add(ast, rule.params); + ast = this.cleanBrackets(ast); + rule.params = brackets.stringify(ast); + } + /** + * Check global options + */ + ; + + _proto.disabled = function disabled(node) { + if (!this.all.options.grid) { + if (node.prop === 'display' && node.value.includes('grid')) { + return true; + } + + if (node.prop.includes('grid') || node.prop === 'justify-items') { + return true; + } + } + + if (this.all.options.flexbox === false) { + if (node.prop === 'display' && node.value.includes('flex')) { + return true; + } + + var other = ['order', 'justify-content', 'align-items', 'align-content']; + + if (node.prop.includes('flex') || other.includes(node.prop)) { + return true; + } + } + + return false; + }; + + return Supports; +}(); + +module.exports = Supports;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/transition.js b/node_modules/autoprefixer/lib/transition.js new file mode 100644 index 0000000..8e9ce02 --- /dev/null +++ b/node_modules/autoprefixer/lib/transition.js @@ -0,0 +1,481 @@ +"use strict"; + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var parser = require('postcss-value-parser'); + +var vendor = require('postcss').vendor; + +var list = require('postcss').list; + +var Transition = +/*#__PURE__*/ +function () { + function Transition(prefixes) { + _defineProperty(this, "props", ['transition', 'transition-property']); + + this.prefixes = prefixes; + } + /** + * Process transition and add prefixes for all necessary properties + */ + + + var _proto = Transition.prototype; + + _proto.add = function add(decl, result) { + var _this = this; + + var prefix, prop; + var add = this.prefixes.add[decl.prop]; + var declPrefixes = add && add.prefixes || []; + var params = this.parse(decl.value); + var names = params.map(function (i) { + return _this.findProp(i); + }); + var added = []; + + if (names.some(function (i) { + return i[0] === '-'; + })) { + return; + } + + for (var _iterator = params, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var param = _ref; + prop = this.findProp(param); + if (prop[0] === '-') continue; + var prefixer = this.prefixes.add[prop]; + if (!prefixer || !prefixer.prefixes) continue; + + for (var _iterator3 = prefixer.prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + prefix = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + prefix = _i3.value; + } + + var prefixed = this.prefixes.prefixed(prop, prefix); + + if (prefixed !== '-ms-transform' && !names.includes(prefixed)) { + if (!this.disabled(prop, prefix)) { + added.push(this.clone(prop, prefixed, param)); + } + } + } + } + + params = params.concat(added); + var value = this.stringify(params); + var webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-')); + + if (declPrefixes.includes('-webkit-')) { + this.cloneBefore(decl, "-webkit-" + decl.prop, webkitClean); + } + + this.cloneBefore(decl, decl.prop, webkitClean); + + if (declPrefixes.includes('-o-')) { + var operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-')); + this.cloneBefore(decl, "-o-" + decl.prop, operaClean); + } + + for (var _iterator2 = declPrefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + prefix = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + prefix = _i2.value; + } + + if (prefix !== '-webkit-' && prefix !== '-o-') { + var prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix)); + this.cloneBefore(decl, prefix + decl.prop, prefixValue); + } + } + + if (value !== decl.value && !this.already(decl, decl.prop, value)) { + this.checkForWarning(result, decl); + decl.cloneBefore(); + decl.value = value; + } + } + /** + * Find property name + */ + ; + + _proto.findProp = function findProp(param) { + var prop = param[0].value; + + if (/^\d/.test(prop)) { + for (var _iterator4 = param.entries(), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref2; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref2 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref2 = _i4.value; + } + + var _ref3 = _ref2, + i = _ref3[0], + token = _ref3[1]; + + if (i !== 0 && token.type === 'word') { + return token.value; + } + } + } + + return prop; + } + /** + * Does we already have this declaration + */ + ; + + _proto.already = function already(decl, prop, value) { + return decl.parent.some(function (i) { + return i.prop === prop && i.value === value; + }); + } + /** + * Add declaration if it is not exist + */ + ; + + _proto.cloneBefore = function cloneBefore(decl, prop, value) { + if (!this.already(decl, prop, value)) { + decl.cloneBefore({ + prop: prop, + value: value + }); + } + } + /** + * Show transition-property warning + */ + ; + + _proto.checkForWarning = function checkForWarning(result, decl) { + if (decl.prop !== 'transition-property') { + return; + } + + decl.parent.each(function (i) { + if (i.type !== 'decl') { + return undefined; + } + + if (i.prop.indexOf('transition-') !== 0) { + return undefined; + } + + if (i.prop === 'transition-property') { + return undefined; + } + + if (list.comma(i.value).length > 1) { + decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*'); + } + + return false; + }); + } + /** + * Process transition and remove all unnecessary properties + */ + ; + + _proto.remove = function remove(decl) { + var _this2 = this; + + var params = this.parse(decl.value); + params = params.filter(function (i) { + var prop = _this2.prefixes.remove[_this2.findProp(i)]; + + return !prop || !prop.remove; + }); + var value = this.stringify(params); + + if (decl.value === value) { + return; + } + + if (params.length === 0) { + decl.remove(); + return; + } + + var _double = decl.parent.some(function (i) { + return i.prop === decl.prop && i.value === value; + }); + + var smaller = decl.parent.some(function (i) { + return i !== decl && i.prop === decl.prop && i.value.length > value.length; + }); + + if (_double || smaller) { + decl.remove(); + return; + } + + decl.value = value; + } + /** + * Parse properties list to array + */ + ; + + _proto.parse = function parse(value) { + var ast = parser(value); + var result = []; + var param = []; + + for (var _iterator5 = ast.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref4; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref4 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref4 = _i5.value; + } + + var node = _ref4; + param.push(node); + + if (node.type === 'div' && node.value === ',') { + result.push(param); + param = []; + } + } + + result.push(param); + return result.filter(function (i) { + return i.length > 0; + }); + } + /** + * Return properties string from array + */ + ; + + _proto.stringify = function stringify(params) { + if (params.length === 0) { + return ''; + } + + var nodes = []; + + for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref5; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref5 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref5 = _i6.value; + } + + var param = _ref5; + + if (param[param.length - 1].type !== 'div') { + param.push(this.div(params)); + } + + nodes = nodes.concat(param); + } + + if (nodes[0].type === 'div') { + nodes = nodes.slice(1); + } + + if (nodes[nodes.length - 1].type === 'div') { + nodes = nodes.slice(0, +-2 + 1 || undefined); + } + + return parser.stringify({ + nodes: nodes + }); + } + /** + * Return new param array with different name + */ + ; + + _proto.clone = function clone(origin, name, param) { + var result = []; + var changed = false; + + for (var _iterator7 = param, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) { + var _ref6; + + if (_isArray7) { + if (_i7 >= _iterator7.length) break; + _ref6 = _iterator7[_i7++]; + } else { + _i7 = _iterator7.next(); + if (_i7.done) break; + _ref6 = _i7.value; + } + + var i = _ref6; + + if (!changed && i.type === 'word' && i.value === origin) { + result.push({ + type: 'word', + value: name + }); + changed = true; + } else { + result.push(i); + } + } + + return result; + } + /** + * Find or create separator + */ + ; + + _proto.div = function div(params) { + for (var _iterator8 = params, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) { + var _ref7; + + if (_isArray8) { + if (_i8 >= _iterator8.length) break; + _ref7 = _iterator8[_i8++]; + } else { + _i8 = _iterator8.next(); + if (_i8.done) break; + _ref7 = _i8.value; + } + + var param = _ref7; + + for (var _iterator9 = param, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) { + var _ref8; + + if (_isArray9) { + if (_i9 >= _iterator9.length) break; + _ref8 = _iterator9[_i9++]; + } else { + _i9 = _iterator9.next(); + if (_i9.done) break; + _ref8 = _i9.value; + } + + var node = _ref8; + + if (node.type === 'div' && node.value === ',') { + return node; + } + } + } + + return { + type: 'div', + value: ',', + after: ' ' + }; + }; + + _proto.cleanOtherPrefixes = function cleanOtherPrefixes(params, prefix) { + var _this3 = this; + + return params.filter(function (param) { + var current = vendor.prefix(_this3.findProp(param)); + return current === '' || current === prefix; + }); + } + /** + * Remove all non-webkit prefixes and unprefixed params if we have prefixed + */ + ; + + _proto.cleanFromUnprefixed = function cleanFromUnprefixed(params, prefix) { + var _this4 = this; + + var remove = params.map(function (i) { + return _this4.findProp(i); + }).filter(function (i) { + return i.slice(0, prefix.length) === prefix; + }).map(function (i) { + return _this4.prefixes.unprefixed(i); + }); + var result = []; + + for (var _iterator10 = params, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) { + var _ref9; + + if (_isArray10) { + if (_i10 >= _iterator10.length) break; + _ref9 = _iterator10[_i10++]; + } else { + _i10 = _iterator10.next(); + if (_i10.done) break; + _ref9 = _i10.value; + } + + var param = _ref9; + var prop = this.findProp(param); + var p = vendor.prefix(prop); + + if (!remove.includes(prop) && (p === prefix || p === '')) { + result.push(param); + } + } + + return result; + } + /** + * Check property for disabled by option + */ + ; + + _proto.disabled = function disabled(prop, prefix) { + var other = ['order', 'justify-content', 'align-self', 'align-content']; + + if (prop.includes('flex') || other.includes(prop)) { + if (this.prefixes.options.flexbox === false) { + return true; + } + + if (this.prefixes.options.flexbox === 'no-2009') { + return prefix.includes('2009'); + } + } + + return undefined; + }; + + return Transition; +}(); + +module.exports = Transition;
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/utils.js b/node_modules/autoprefixer/lib/utils.js new file mode 100644 index 0000000..081da6d --- /dev/null +++ b/node_modules/autoprefixer/lib/utils.js @@ -0,0 +1,108 @@ +"use strict"; + +var list = require('postcss').list; + +module.exports = { + /** + * Throw special error, to tell beniary, + * that this error is from Autoprefixer. + */ + error: function error(text) { + var err = new Error(text); + err.autoprefixer = true; + throw err; + }, + + /** + * Return array, that doesn’t contain duplicates. + */ + uniq: function uniq(array) { + var filtered = []; + + for (var _iterator = array, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if (!filtered.includes(i)) { + filtered.push(i); + } + } + + return filtered; + }, + + /** + * Return "-webkit-" on "-webkit- old" + */ + removeNote: function removeNote(string) { + if (!string.includes(' ')) { + return string; + } + + return string.split(' ')[0]; + }, + + /** + * Escape RegExp symbols + */ + escapeRegexp: function escapeRegexp(string) { + return string.replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&'); + }, + + /** + * Return regexp to check, that CSS string contain word + */ + regexp: function regexp(word, escape) { + if (escape === void 0) { + escape = true; + } + + if (escape) { + word = this.escapeRegexp(word); + } + + return new RegExp("(^|[\\s,(])(" + word + "($|[\\s(,]))", 'gi'); + }, + + /** + * Change comma list + */ + editList: function editList(value, callback) { + var origin = list.comma(value); + var changed = callback(origin, []); + + if (origin === changed) { + return value; + } + + var join = value.match(/,\s*/); + join = join ? join[0] : ', '; + return changed.join(join); + }, + + /** + * Split the selector into parts. + * It returns 3 level deep array because selectors can be comma + * separated (1), space separated (2), and combined (3) + * @param {String} selector selector string + * @return {Array<Array<Array>>} 3 level deep array of split selector + * @see utils.test.js for examples + */ + splitSelector: function splitSelector(selector) { + return list.comma(selector).map(function (i) { + return list.space(i).map(function (k) { + return k.split(/(?=\.|#)/g); + }); + }); + } +};
\ No newline at end of file diff --git a/node_modules/autoprefixer/lib/value.js b/node_modules/autoprefixer/lib/value.js new file mode 100644 index 0000000..1139a6b --- /dev/null +++ b/node_modules/autoprefixer/lib/value.js @@ -0,0 +1,166 @@ +"use strict"; + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); } + +var vendor = require('postcss').vendor; + +var Prefixer = require('./prefixer'); + +var OldValue = require('./old-value'); + +var utils = require('./utils'); + +var Value = +/*#__PURE__*/ +function (_Prefixer) { + _inheritsLoose(Value, _Prefixer); + + function Value() { + return _Prefixer.apply(this, arguments) || this; + } + + /** + * Clone decl for each prefixed values + */ + Value.save = function save(prefixes, decl) { + var _this = this; + + var prop = decl.prop; + var result = []; + + var _loop = function _loop(prefix) { + var value = decl._autoprefixerValues[prefix]; + + if (value === decl.value) { + return "continue"; + } + + var item = void 0; + var propPrefix = vendor.prefix(prop); + + if (propPrefix === '-pie-') { + return "continue"; + } + + if (propPrefix === prefix) { + item = decl.value = value; + result.push(item); + return "continue"; + } + + var prefixed = prefixes.prefixed(prop, prefix); + var rule = decl.parent; + + if (!rule.every(function (i) { + return i.prop !== prefixed; + })) { + result.push(item); + return "continue"; + } + + var trimmed = value.replace(/\s+/, ' '); + var already = rule.some(function (i) { + return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed; + }); + + if (already) { + result.push(item); + return "continue"; + } + + var cloned = _this.clone(decl, { + value: value + }); + + item = decl.parent.insertBefore(decl, cloned); + result.push(item); + }; + + for (var prefix in decl._autoprefixerValues) { + var _ret = _loop(prefix); + + if (_ret === "continue") continue; + } + + return result; + } + /** + * Is declaration need to be prefixed + */ + ; + + var _proto = Value.prototype; + + _proto.check = function check(decl) { + var value = decl.value; + + if (!value.includes(this.name)) { + return false; + } + + return !!value.match(this.regexp()); + } + /** + * Lazy regexp loading + */ + ; + + _proto.regexp = function regexp() { + return this.regexpCache || (this.regexpCache = utils.regexp(this.name)); + } + /** + * Add prefix to values in string + */ + ; + + _proto.replace = function replace(string, prefix) { + return string.replace(this.regexp(), "$1" + prefix + "$2"); + } + /** + * Get value with comments if it was not changed + */ + ; + + _proto.value = function value(decl) { + if (decl.raws.value && decl.raws.value.value === decl.value) { + return decl.raws.value.raw; + } else { + return decl.value; + } + } + /** + * Save values with next prefixed token + */ + ; + + _proto.add = function add(decl, prefix) { + if (!decl._autoprefixerValues) { + decl._autoprefixerValues = {}; + } + + var value = decl._autoprefixerValues[prefix] || this.value(decl); + var before; + + do { + before = value; + value = this.replace(value, prefix); + if (value === false) return; + } while (value !== before); + + decl._autoprefixerValues[prefix] = value; + } + /** + * Return function to fast find prefixed value + */ + ; + + _proto.old = function old(prefix) { + return new OldValue(this.name, prefix + this.name); + }; + + return Value; +}(Prefixer); + +module.exports = Value;
\ No newline at end of file |