From 3c51c3be85bb0d1bdb87ea0d6632f1c256912f27 Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Sun, 6 Oct 2019 21:37:45 +0200 Subject: build: Add some required modules for node --- .../autoprefixer/lib/hacks/align-content.js | 81 ++ node_modules/autoprefixer/lib/hacks/align-items.js | 78 ++ node_modules/autoprefixer/lib/hacks/align-self.js | 86 ++ node_modules/autoprefixer/lib/hacks/animation.js | 37 + node_modules/autoprefixer/lib/hacks/appearance.js | 41 + .../autoprefixer/lib/hacks/backdrop-filter.js | 37 + .../autoprefixer/lib/hacks/background-clip.js | 43 + .../autoprefixer/lib/hacks/background-size.js | 40 + .../autoprefixer/lib/hacks/block-logical.js | 50 + .../autoprefixer/lib/hacks/border-image.js | 35 + .../autoprefixer/lib/hacks/border-radius.js | 64 ++ node_modules/autoprefixer/lib/hacks/break-props.js | 78 ++ .../autoprefixer/lib/hacks/color-adjust.js | 42 + node_modules/autoprefixer/lib/hacks/cross-fade.js | 56 + .../autoprefixer/lib/hacks/display-flex.js | 96 ++ .../autoprefixer/lib/hacks/display-grid.js | 43 + .../autoprefixer/lib/hacks/filter-value.js | 33 + node_modules/autoprefixer/lib/hacks/filter.js | 35 + node_modules/autoprefixer/lib/hacks/flex-basis.js | 74 ++ .../autoprefixer/lib/hacks/flex-direction.js | 110 ++ node_modules/autoprefixer/lib/hacks/flex-flow.js | 83 ++ node_modules/autoprefixer/lib/hacks/flex-grow.js | 59 + node_modules/autoprefixer/lib/hacks/flex-shrink.js | 74 ++ node_modules/autoprefixer/lib/hacks/flex-spec.js | 22 + node_modules/autoprefixer/lib/hacks/flex-wrap.js | 42 + node_modules/autoprefixer/lib/hacks/flex.js | 87 ++ node_modules/autoprefixer/lib/hacks/fullscreen.js | 42 + node_modules/autoprefixer/lib/hacks/gradient.js | 581 ++++++++++ node_modules/autoprefixer/lib/hacks/grid-area.js | 54 + .../autoprefixer/lib/hacks/grid-column-align.js | 50 + node_modules/autoprefixer/lib/hacks/grid-end.js | 64 ++ .../autoprefixer/lib/hacks/grid-row-align.js | 50 + .../autoprefixer/lib/hacks/grid-row-column.js | 54 + .../autoprefixer/lib/hacks/grid-rows-columns.js | 149 +++ node_modules/autoprefixer/lib/hacks/grid-start.js | 57 + .../autoprefixer/lib/hacks/grid-template-areas.js | 103 ++ .../autoprefixer/lib/hacks/grid-template.js | 92 ++ node_modules/autoprefixer/lib/hacks/grid-utils.js | 1150 ++++++++++++++++++++ .../autoprefixer/lib/hacks/image-rendering.js | 73 ++ node_modules/autoprefixer/lib/hacks/image-set.js | 40 + .../autoprefixer/lib/hacks/inline-logical.js | 42 + node_modules/autoprefixer/lib/hacks/intrinsic.js | 76 ++ .../autoprefixer/lib/hacks/justify-content.js | 87 ++ node_modules/autoprefixer/lib/hacks/mask-border.js | 48 + .../autoprefixer/lib/hacks/mask-composite.js | 106 ++ node_modules/autoprefixer/lib/hacks/order.js | 74 ++ .../autoprefixer/lib/hacks/overscroll-behavior.js | 56 + node_modules/autoprefixer/lib/hacks/pixelated.js | 60 + node_modules/autoprefixer/lib/hacks/place-self.js | 57 + node_modules/autoprefixer/lib/hacks/placeholder.js | 58 + .../lib/hacks/text-decoration-skip-ink.js | 40 + .../autoprefixer/lib/hacks/text-decoration.js | 38 + .../lib/hacks/text-emphasis-position.js | 35 + .../autoprefixer/lib/hacks/transform-decl.js | 112 ++ .../autoprefixer/lib/hacks/writing-mode.js | 61 ++ 55 files changed, 5035 insertions(+) create mode 100644 node_modules/autoprefixer/lib/hacks/align-content.js create mode 100644 node_modules/autoprefixer/lib/hacks/align-items.js create mode 100644 node_modules/autoprefixer/lib/hacks/align-self.js create mode 100644 node_modules/autoprefixer/lib/hacks/animation.js create mode 100644 node_modules/autoprefixer/lib/hacks/appearance.js create mode 100644 node_modules/autoprefixer/lib/hacks/backdrop-filter.js create mode 100644 node_modules/autoprefixer/lib/hacks/background-clip.js create mode 100644 node_modules/autoprefixer/lib/hacks/background-size.js create mode 100644 node_modules/autoprefixer/lib/hacks/block-logical.js create mode 100644 node_modules/autoprefixer/lib/hacks/border-image.js create mode 100644 node_modules/autoprefixer/lib/hacks/border-radius.js create mode 100644 node_modules/autoprefixer/lib/hacks/break-props.js create mode 100644 node_modules/autoprefixer/lib/hacks/color-adjust.js create mode 100644 node_modules/autoprefixer/lib/hacks/cross-fade.js create mode 100644 node_modules/autoprefixer/lib/hacks/display-flex.js create mode 100644 node_modules/autoprefixer/lib/hacks/display-grid.js create mode 100644 node_modules/autoprefixer/lib/hacks/filter-value.js create mode 100644 node_modules/autoprefixer/lib/hacks/filter.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-basis.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-direction.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-flow.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-grow.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-shrink.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-spec.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex-wrap.js create mode 100644 node_modules/autoprefixer/lib/hacks/flex.js create mode 100644 node_modules/autoprefixer/lib/hacks/fullscreen.js create mode 100644 node_modules/autoprefixer/lib/hacks/gradient.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-area.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-column-align.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-end.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-row-align.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-row-column.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-rows-columns.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-start.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-template-areas.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-template.js create mode 100644 node_modules/autoprefixer/lib/hacks/grid-utils.js create mode 100644 node_modules/autoprefixer/lib/hacks/image-rendering.js create mode 100644 node_modules/autoprefixer/lib/hacks/image-set.js create mode 100644 node_modules/autoprefixer/lib/hacks/inline-logical.js create mode 100644 node_modules/autoprefixer/lib/hacks/intrinsic.js create mode 100644 node_modules/autoprefixer/lib/hacks/justify-content.js create mode 100644 node_modules/autoprefixer/lib/hacks/mask-border.js create mode 100644 node_modules/autoprefixer/lib/hacks/mask-composite.js create mode 100644 node_modules/autoprefixer/lib/hacks/order.js create mode 100644 node_modules/autoprefixer/lib/hacks/overscroll-behavior.js create mode 100644 node_modules/autoprefixer/lib/hacks/pixelated.js create mode 100644 node_modules/autoprefixer/lib/hacks/place-self.js create mode 100644 node_modules/autoprefixer/lib/hacks/placeholder.js create mode 100644 node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js create mode 100644 node_modules/autoprefixer/lib/hacks/text-decoration.js create mode 100644 node_modules/autoprefixer/lib/hacks/text-emphasis-position.js create mode 100644 node_modules/autoprefixer/lib/hacks/transform-decl.js create mode 100644 node_modules/autoprefixer/lib/hacks/writing-mode.js (limited to 'node_modules/autoprefixer/lib/hacks') 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} + */ + + +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} rules + * @param {Array} templateSelectors + * @return {Array} 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 -- cgit v1.2.3