diff options
Diffstat (limited to 'node_modules/postcss/lib')
26 files changed, 7224 insertions, 0 deletions
diff --git a/node_modules/postcss/lib/at-rule.js b/node_modules/postcss/lib/at-rule.js new file mode 100644 index 00000000..460c52dd --- /dev/null +++ b/node_modules/postcss/lib/at-rule.js @@ -0,0 +1,159 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Represents an at-rule. + * + * If it’s followed in the CSS by a {} block, this node will have + * a nodes property representing its children. + * + * @extends Container + * + * @example + * const root = postcss.parse('@charset "UTF-8"; @media print {}'); + * + * const charset = root.first; + * charset.type //=> 'atrule' + * charset.nodes //=> undefined + * + * const media = root.last; + * media.nodes //=> [] + */ +var AtRule = function (_Container) { + _inherits(AtRule, _Container); + + function AtRule(defaults) { + _classCallCheck(this, AtRule); + + var _this = _possibleConstructorReturn(this, _Container.call(this, defaults)); + + _this.type = 'atrule'; + return _this; + } + + AtRule.prototype.append = function append() { + var _Container$prototype$; + + if (!this.nodes) this.nodes = []; + + for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) { + children[_key] = arguments[_key]; + } + + return (_Container$prototype$ = _Container.prototype.append).call.apply(_Container$prototype$, [this].concat(children)); + }; + + AtRule.prototype.prepend = function prepend() { + var _Container$prototype$2; + + if (!this.nodes) this.nodes = []; + + for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + children[_key2] = arguments[_key2]; + } + + return (_Container$prototype$2 = _Container.prototype.prepend).call.apply(_Container$prototype$2, [this].concat(children)); + }; + + _createClass(AtRule, [{ + key: 'afterName', + get: function get() { + (0, _warnOnce2.default)('AtRule#afterName was deprecated. Use AtRule#raws.afterName'); + return this.raws.afterName; + }, + set: function set(val) { + (0, _warnOnce2.default)('AtRule#afterName was deprecated. Use AtRule#raws.afterName'); + this.raws.afterName = val; + } + }, { + key: '_params', + get: function get() { + (0, _warnOnce2.default)('AtRule#_params was deprecated. Use AtRule#raws.params'); + return this.raws.params; + }, + set: function set(val) { + (0, _warnOnce2.default)('AtRule#_params was deprecated. Use AtRule#raws.params'); + this.raws.params = val; + } + + /** + * @memberof AtRule# + * @member {string} name - the at-rule’s name immediately follows the `@` + * + * @example + * const root = postcss.parse('@media print {}'); + * media.name //=> 'media' + * const media = root.first; + */ + + /** + * @memberof AtRule# + * @member {string} params - the at-rule’s parameters, the values + * that follow the at-rule’s name but precede + * any {} block + * + * @example + * const root = postcss.parse('@media print, screen {}'); + * const media = root.first; + * media.params //=> 'print, screen' + */ + + /** + * @memberof AtRule# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * * `afterName`: the space between the at-rule name and its parameters. + * + * PostCSS cleans at-rule parameters from comments and extra spaces, + * but it stores origin content in raws properties. + * As such, if you don’t change a declaration’s value, + * PostCSS will use the raw value with comments. + * + * @example + * const root = postcss.parse(' @media\nprint {\n}') + * root.first.first.raws //=> { before: ' ', + * // between: ' ', + * // afterName: '\n', + * // after: '\n' } + */ + + }]); + + return AtRule; +}(_container2.default); + +exports.default = AtRule; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/comment.js b/node_modules/postcss/lib/comment.js new file mode 100644 index 00000000..fdf54f5c --- /dev/null +++ b/node_modules/postcss/lib/comment.js @@ -0,0 +1,89 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Represents a comment between declarations or statements (rule and at-rules). + * + * Comments inside selectors, at-rule parameters, or declaration values + * will be stored in the `raws` properties explained above. + * + * @extends Node + */ +var Comment = function (_Node) { + _inherits(Comment, _Node); + + function Comment(defaults) { + _classCallCheck(this, Comment); + + var _this = _possibleConstructorReturn(this, _Node.call(this, defaults)); + + _this.type = 'comment'; + return _this; + } + + _createClass(Comment, [{ + key: 'left', + get: function get() { + (0, _warnOnce2.default)('Comment#left was deprecated. Use Comment#raws.left'); + return this.raws.left; + }, + set: function set(val) { + (0, _warnOnce2.default)('Comment#left was deprecated. Use Comment#raws.left'); + this.raws.left = val; + } + }, { + key: 'right', + get: function get() { + (0, _warnOnce2.default)('Comment#right was deprecated. Use Comment#raws.right'); + return this.raws.right; + }, + set: function set(val) { + (0, _warnOnce2.default)('Comment#right was deprecated. Use Comment#raws.right'); + this.raws.right = val; + } + + /** + * @memberof Comment# + * @member {string} text - the comment’s text + */ + + /** + * @memberof Comment# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `before`: the space symbols before the node. + * * `left`: the space symbols between `/*` and the comment’s text. + * * `right`: the space symbols between the comment’s text. + */ + + }]); + + return Comment; +}(_node2.default); + +exports.default = Comment; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/container.js b/node_modules/postcss/lib/container.js new file mode 100644 index 00000000..276b9b63 --- /dev/null +++ b/node_modules/postcss/lib/container.js @@ -0,0 +1,935 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _declaration = require('./declaration'); + +var _declaration2 = _interopRequireDefault(_declaration); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +var _comment = require('./comment'); + +var _comment2 = _interopRequireDefault(_comment); + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +function cleanSource(nodes) { + return nodes.map(function (i) { + if (i.nodes) i.nodes = cleanSource(i.nodes); + delete i.source; + return i; + }); +} + +/** + * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes + * inherit some common methods to help work with their children. + * + * Note that all containers can store any content. If you write a rule inside + * a rule, PostCSS will parse it. + * + * @extends Node + * @abstract + */ + +var Container = function (_Node) { + _inherits(Container, _Node); + + function Container() { + _classCallCheck(this, Container); + + return _possibleConstructorReturn(this, _Node.apply(this, arguments)); + } + + Container.prototype.push = function push(child) { + child.parent = this; + this.nodes.push(child); + return this; + }; + + /** + * Iterates through the container’s immediate children, + * calling `callback` for each child. + * + * Returning `false` in the callback will break iteration. + * + * This method only iterates through the container’s immediate children. + * If you need to recursively iterate through all the container’s descendant + * nodes, use {@link Container#walk}. + * + * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe + * if you are mutating the array of child nodes during iteration. + * PostCSS will adjust the current index to match the mutations. + * + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * const root = postcss.parse('a { color: black; z-index: 1 }'); + * const rule = root.first; + * + * for ( let decl of rule.nodes ) { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }); + * // Cycle will be infinite, because cloneBefore moves the current node + * // to the next index + * } + * + * rule.each(decl => { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }); + * // Will be executed only for color and z-index + * }); + */ + + + Container.prototype.each = function each(callback) { + if (!this.lastEach) this.lastEach = 0; + if (!this.indexes) this.indexes = {}; + + this.lastEach += 1; + var id = this.lastEach; + this.indexes[id] = 0; + + if (!this.nodes) return undefined; + + var index = void 0, + result = void 0; + while (this.indexes[id] < this.nodes.length) { + index = this.indexes[id]; + result = callback(this.nodes[index], index); + if (result === false) break; + + this.indexes[id] += 1; + } + + delete this.indexes[id]; + + return result; + }; + + /** + * Traverses the container’s descendant nodes, calling callback + * for each node. + * + * Like container.each(), this method is safe to use + * if you are mutating arrays during iteration. + * + * If you only need to iterate through the container’s immediate children, + * use {@link Container#each}. + * + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * root.walk(node => { + * // Traverses all descendant nodes. + * }); + */ + + + Container.prototype.walk = function walk(callback) { + return this.each(function (child, i) { + var result = callback(child, i); + if (result !== false && child.walk) { + result = child.walk(callback); + } + return result; + }); + }; + + /** + * Traverses the container’s descendant nodes, calling callback + * for each declaration node. + * + * If you pass a filter, iteration will only happen over declarations + * with matching properties. + * + * Like {@link Container#each}, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param {string|RegExp} [prop] - string or regular expression + * to filter declarations by property name + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * root.walkDecls(decl => { + * checkPropertySupport(decl.prop); + * }); + * + * root.walkDecls('border-radius', decl => { + * decl.remove(); + * }); + * + * root.walkDecls(/^background/, decl => { + * decl.value = takeFirstColorFromGradient(decl.value); + * }); + */ + + + Container.prototype.walkDecls = function walkDecls(prop, callback) { + if (!callback) { + callback = prop; + return this.walk(function (child, i) { + if (child.type === 'decl') { + return callback(child, i); + } + }); + } else if (prop instanceof RegExp) { + return this.walk(function (child, i) { + if (child.type === 'decl' && prop.test(child.prop)) { + return callback(child, i); + } + }); + } else { + return this.walk(function (child, i) { + if (child.type === 'decl' && child.prop === prop) { + return callback(child, i); + } + }); + } + }; + + /** + * Traverses the container’s descendant nodes, calling callback + * for each rule node. + * + * If you pass a filter, iteration will only happen over rules + * with matching selectors. + * + * Like {@link Container#each}, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param {string|RegExp} [selector] - string or regular expression + * to filter rules by selector + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * const selectors = []; + * root.walkRules(rule => { + * selectors.push(rule.selector); + * }); + * console.log(`Your CSS uses ${selectors.length} selectors`); + */ + + + Container.prototype.walkRules = function walkRules(selector, callback) { + if (!callback) { + callback = selector; + + return this.walk(function (child, i) { + if (child.type === 'rule') { + return callback(child, i); + } + }); + } else if (selector instanceof RegExp) { + return this.walk(function (child, i) { + if (child.type === 'rule' && selector.test(child.selector)) { + return callback(child, i); + } + }); + } else { + return this.walk(function (child, i) { + if (child.type === 'rule' && child.selector === selector) { + return callback(child, i); + } + }); + } + }; + + /** + * Traverses the container’s descendant nodes, calling callback + * for each at-rule node. + * + * If you pass a filter, iteration will only happen over at-rules + * that have matching names. + * + * Like {@link Container#each}, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param {string|RegExp} [name] - string or regular expression + * to filter at-rules by name + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * root.walkAtRules(rule => { + * if ( isOld(rule.name) ) rule.remove(); + * }); + * + * let first = false; + * root.walkAtRules('charset', rule => { + * if ( !first ) { + * first = true; + * } else { + * rule.remove(); + * } + * }); + */ + + + Container.prototype.walkAtRules = function walkAtRules(name, callback) { + if (!callback) { + callback = name; + return this.walk(function (child, i) { + if (child.type === 'atrule') { + return callback(child, i); + } + }); + } else if (name instanceof RegExp) { + return this.walk(function (child, i) { + if (child.type === 'atrule' && name.test(child.name)) { + return callback(child, i); + } + }); + } else { + return this.walk(function (child, i) { + if (child.type === 'atrule' && child.name === name) { + return callback(child, i); + } + }); + } + }; + + /** + * Traverses the container’s descendant nodes, calling callback + * for each comment node. + * + * Like {@link Container#each}, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param {childIterator} callback - iterator receives each node and index + * + * @return {false|undefined} returns `false` if iteration was broke + * + * @example + * root.walkComments(comment => { + * comment.remove(); + * }); + */ + + + Container.prototype.walkComments = function walkComments(callback) { + return this.walk(function (child, i) { + if (child.type === 'comment') { + return callback(child, i); + } + }); + }; + + /** + * Inserts new nodes to the end of the container. + * + * @param {...(Node|object|string|Node[])} children - new nodes + * + * @return {Node} this node for methods chain + * + * @example + * const decl1 = postcss.decl({ prop: 'color', value: 'black' }); + * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' }); + * rule.append(decl1, decl2); + * + * root.append({ name: 'charset', params: '"UTF-8"' }); // at-rule + * root.append({ selector: 'a' }); // rule + * rule.append({ prop: 'color', value: 'black' }); // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}'); + * root.first.append('color: black; z-index: 1'); + */ + + + Container.prototype.append = function append() { + for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) { + children[_key] = arguments[_key]; + } + + for (var _iterator = children, _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 child = _ref; + + var nodes = this.normalize(child, this.last); + for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var node = _ref2; + this.nodes.push(node); + } + } + return this; + }; + + /** + * Inserts new nodes to the start of the container. + * + * @param {...(Node|object|string|Node[])} children - new nodes + * + * @return {Node} this node for methods chain + * + * @example + * const decl1 = postcss.decl({ prop: 'color', value: 'black' }); + * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' }); + * rule.prepend(decl1, decl2); + * + * root.append({ name: 'charset', params: '"UTF-8"' }); // at-rule + * root.append({ selector: 'a' }); // rule + * rule.append({ prop: 'color', value: 'black' }); // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}'); + * root.first.append('color: black; z-index: 1'); + */ + + + Container.prototype.prepend = function prepend() { + for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + children[_key2] = arguments[_key2]; + } + + children = children.reverse(); + for (var _iterator3 = children, _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 child = _ref3; + + var nodes = this.normalize(child, this.first, 'prepend').reverse(); + 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 node = _ref4; + this.nodes.unshift(node); + }for (var id in this.indexes) { + this.indexes[id] = this.indexes[id] + nodes.length; + } + } + return this; + }; + + Container.prototype.cleanRaws = function cleanRaws(keepBetween) { + _Node.prototype.cleanRaws.call(this, keepBetween); + if (this.nodes) { + for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var node = _ref5; + node.cleanRaws(keepBetween); + } + } + }; + + /** + * Insert new node before old node within the container. + * + * @param {Node|number} exist - child or child’s index. + * @param {Node|object|string|Node[]} add - new node + * + * @return {Node} this node for methods chain + * + * @example + * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop })); + */ + + + Container.prototype.insertBefore = function insertBefore(exist, add) { + exist = this.index(exist); + + var type = exist === 0 ? 'prepend' : false; + var nodes = this.normalize(add, this.nodes[exist], type).reverse(); + for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref6 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref6 = _i6.value; + } + + var node = _ref6; + this.nodes.splice(exist, 0, node); + }var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (exist <= index) { + this.indexes[id] = index + nodes.length; + } + } + + return this; + }; + + /** + * Insert new node after old node within the container. + * + * @param {Node|number} exist - child or child’s index + * @param {Node|object|string|Node[]} add - new node + * + * @return {Node} this node for methods chain + */ + + + Container.prototype.insertAfter = function insertAfter(exist, add) { + exist = this.index(exist); + + var nodes = this.normalize(add, this.nodes[exist]).reverse(); + for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) { + var _ref7; + + if (_isArray7) { + if (_i7 >= _iterator7.length) break; + _ref7 = _iterator7[_i7++]; + } else { + _i7 = _iterator7.next(); + if (_i7.done) break; + _ref7 = _i7.value; + } + + var node = _ref7; + this.nodes.splice(exist + 1, 0, node); + }var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (exist < index) { + this.indexes[id] = index + nodes.length; + } + } + + return this; + }; + + Container.prototype.remove = function remove(child) { + if (typeof child !== 'undefined') { + (0, _warnOnce2.default)('Container#remove is deprecated. ' + 'Use Container#removeChild'); + this.removeChild(child); + } else { + _Node.prototype.remove.call(this); + } + return this; + }; + + /** + * Removes node from the container and cleans the parent properties + * from the node and its children. + * + * @param {Node|number} child - child or child’s index + * + * @return {Node} this node for methods chain + * + * @example + * rule.nodes.length //=> 5 + * rule.removeChild(decl); + * rule.nodes.length //=> 4 + * decl.parent //=> undefined + */ + + + Container.prototype.removeChild = function removeChild(child) { + child = this.index(child); + this.nodes[child].parent = undefined; + this.nodes.splice(child, 1); + + var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (index >= child) { + this.indexes[id] = index - 1; + } + } + + return this; + }; + + /** + * Removes all children from the container + * and cleans their parent properties. + * + * @return {Node} this node for methods chain + * + * @example + * rule.removeAll(); + * rule.nodes.length //=> 0 + */ + + + Container.prototype.removeAll = function removeAll() { + for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) { + var _ref8; + + if (_isArray8) { + if (_i8 >= _iterator8.length) break; + _ref8 = _iterator8[_i8++]; + } else { + _i8 = _iterator8.next(); + if (_i8.done) break; + _ref8 = _i8.value; + } + + var node = _ref8; + node.parent = undefined; + }this.nodes = []; + return this; + }; + + /** + * Passes all declaration values within the container that match pattern + * through callback, replacing those values with the returned result + * of callback. + * + * This method is useful if you are using a custom unit or function + * and need to iterate through all values. + * + * @param {string|RegExp} pattern - replace pattern + * @param {object} opts - options to speed up the search + * @param {string|string[]} opts.props - an array of property names + * @param {string} opts.fast - string that’s used + * to narrow down values and speed up + the regexp search + * @param {function|string} callback - string to replace pattern + * or callback that returns a new + * value. + * The callback will receive + * the same arguments as those + * passed to a function parameter + * of `String#replace`. + * + * @return {Node} this node for methods chain + * + * @example + * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => { + * return 15 * parseInt(string) + 'px'; + * }); + */ + + + Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) { + if (!callback) { + callback = opts; + opts = {}; + } + + this.walkDecls(function (decl) { + if (opts.props && opts.props.indexOf(decl.prop) === -1) return; + if (opts.fast && decl.value.indexOf(opts.fast) === -1) return; + + decl.value = decl.value.replace(pattern, callback); + }); + + return this; + }; + + /** + * Returns `true` if callback returns `true` + * for all of the container’s children. + * + * @param {childCondition} condition - iterator returns true or false. + * + * @return {boolean} is every child pass condition + * + * @example + * const noPrefixes = rule.every(i => i.prop[0] !== '-'); + */ + + + Container.prototype.every = function every(condition) { + return this.nodes.every(condition); + }; + + /** + * Returns `true` if callback returns `true` for (at least) one + * of the container’s children. + * + * @param {childCondition} condition - iterator returns true or false. + * + * @return {boolean} is some child pass condition + * + * @example + * const hasPrefix = rule.some(i => i.prop[0] === '-'); + */ + + + Container.prototype.some = function some(condition) { + return this.nodes.some(condition); + }; + + /** + * Returns a `child`’s index within the {@link Container#nodes} array. + * + * @param {Node} child - child of the current container. + * + * @return {number} child index + * + * @example + * rule.index( rule.nodes[2] ) //=> 2 + */ + + + Container.prototype.index = function index(child) { + if (typeof child === 'number') { + return child; + } else { + return this.nodes.indexOf(child); + } + }; + + /** + * The container’s first child. + * + * @type {Node} + * + * @example + * rule.first == rules.nodes[0]; + */ + + + Container.prototype.normalize = function normalize(nodes, sample) { + var _this2 = this; + + if (typeof nodes === 'string') { + var parse = require('./parse'); + nodes = cleanSource(parse(nodes).nodes); + } else if (!Array.isArray(nodes)) { + if (nodes.type === 'root') { + nodes = nodes.nodes; + } else if (nodes.type) { + nodes = [nodes]; + } else if (nodes.prop) { + if (typeof nodes.value === 'undefined') { + throw new Error('Value field is missed in node creation'); + } else if (typeof nodes.value !== 'string') { + nodes.value = String(nodes.value); + } + nodes = [new _declaration2.default(nodes)]; + } else if (nodes.selector) { + var Rule = require('./rule'); + nodes = [new Rule(nodes)]; + } else if (nodes.name) { + var AtRule = require('./at-rule'); + nodes = [new AtRule(nodes)]; + } else if (nodes.text) { + nodes = [new _comment2.default(nodes)]; + } else { + throw new Error('Unknown node type in node creation'); + } + } + + var processed = nodes.map(function (i) { + if (typeof i.raws === 'undefined') i = _this2.rebuild(i); + + if (i.parent) i = i.clone(); + if (typeof i.raws.before === 'undefined') { + if (sample && typeof sample.raws.before !== 'undefined') { + i.raws.before = sample.raws.before.replace(/[^\s]/g, ''); + } + } + i.parent = _this2; + return i; + }); + + return processed; + }; + + Container.prototype.rebuild = function rebuild(node, parent) { + var _this3 = this; + + var fix = void 0; + if (node.type === 'root') { + var Root = require('./root'); + fix = new Root(); + } else if (node.type === 'atrule') { + var AtRule = require('./at-rule'); + fix = new AtRule(); + } else if (node.type === 'rule') { + var Rule = require('./rule'); + fix = new Rule(); + } else if (node.type === 'decl') { + fix = new _declaration2.default(); + } else if (node.type === 'comment') { + fix = new _comment2.default(); + } + + for (var i in node) { + if (i === 'nodes') { + fix.nodes = node.nodes.map(function (j) { + return _this3.rebuild(j, fix); + }); + } else if (i === 'parent' && parent) { + fix.parent = parent; + } else if (node.hasOwnProperty(i)) { + fix[i] = node[i]; + } + } + + return fix; + }; + + Container.prototype.eachInside = function eachInside(callback) { + (0, _warnOnce2.default)('Container#eachInside is deprecated. ' + 'Use Container#walk instead.'); + return this.walk(callback); + }; + + Container.prototype.eachDecl = function eachDecl(prop, callback) { + (0, _warnOnce2.default)('Container#eachDecl is deprecated. ' + 'Use Container#walkDecls instead.'); + return this.walkDecls(prop, callback); + }; + + Container.prototype.eachRule = function eachRule(selector, callback) { + (0, _warnOnce2.default)('Container#eachRule is deprecated. ' + 'Use Container#walkRules instead.'); + return this.walkRules(selector, callback); + }; + + Container.prototype.eachAtRule = function eachAtRule(name, callback) { + (0, _warnOnce2.default)('Container#eachAtRule is deprecated. ' + 'Use Container#walkAtRules instead.'); + return this.walkAtRules(name, callback); + }; + + Container.prototype.eachComment = function eachComment(callback) { + (0, _warnOnce2.default)('Container#eachComment is deprecated. ' + 'Use Container#walkComments instead.'); + return this.walkComments(callback); + }; + + _createClass(Container, [{ + key: 'first', + get: function get() { + if (!this.nodes) return undefined; + return this.nodes[0]; + } + + /** + * The container’s last child. + * + * @type {Node} + * + * @example + * rule.last == rule.nodes[rule.nodes.length - 1]; + */ + + }, { + key: 'last', + get: function get() { + if (!this.nodes) return undefined; + return this.nodes[this.nodes.length - 1]; + } + }, { + key: 'semicolon', + get: function get() { + (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon'); + return this.raws.semicolon; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon'); + this.raws.semicolon = val; + } + }, { + key: 'after', + get: function get() { + (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after'); + return this.raws.after; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after'); + this.raws.after = val; + } + + /** + * @memberof Container# + * @member {Node[]} nodes - an array containing the container’s children + * + * @example + * const root = postcss.parse('a { color: black }'); + * root.nodes.length //=> 1 + * root.nodes[0].selector //=> 'a' + * root.nodes[0].nodes[0].prop //=> 'color' + */ + + }]); + + return Container; +}(_node2.default); + +exports.default = Container; + +/** + * @callback childCondition + * @param {Node} node - container child + * @param {number} index - child index + * @param {Node[]} nodes - all container children + * @return {boolean} + */ + +/** + * @callback childIterator + * @param {Node} node - container child + * @param {number} index - child index + * @return {false|undefined} returning `false` will break iteration + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["container.es6"],"names":["cleanSource","nodes","map","i","source","Container","push","child","parent","each","callback","lastEach","indexes","id","undefined","index","result","length","walk","walkDecls","prop","type","RegExp","test","walkRules","selector","walkAtRules","name","walkComments","append","children","normalize","last","node","prepend","reverse","first","unshift","cleanRaws","keepBetween","insertBefore","exist","add","splice","insertAfter","remove","removeChild","removeAll","replaceValues","pattern","opts","props","indexOf","decl","fast","value","replace","every","condition","some","sample","parse","require","Array","isArray","Error","String","Rule","AtRule","text","processed","raws","rebuild","clone","before","fix","Root","j","hasOwnProperty","eachInside","eachDecl","eachRule","eachAtRule","eachComment","semicolon","val","after"],"mappings":"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","file":"container.js","sourcesContent":["import Declaration from './declaration';\nimport warnOnce    from './warn-once';\nimport Comment     from './comment';\nimport Node        from './node';\n\nfunction cleanSource(nodes) {\n    return nodes.map( i => {\n        if ( i.nodes ) i.nodes = cleanSource(i.nodes);\n        delete i.source;\n        return i;\n    });\n}\n\n/**\n * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes\n * inherit some common methods to help work with their children.\n *\n * Note that all containers can store any content. If you write a rule inside\n * a rule, PostCSS will parse it.\n *\n * @extends Node\n * @abstract\n */\nclass Container extends Node {\n\n    push(child) {\n        child.parent = this;\n        this.nodes.push(child);\n        return this;\n    }\n\n    /**\n     * Iterates through the container’s immediate children,\n     * calling `callback` for each child.\n     *\n     * Returning `false` in the callback will break iteration.\n     *\n     * This method only iterates through the container’s immediate children.\n     * If you need to recursively iterate through all the container’s descendant\n     * nodes, use {@link Container#walk}.\n     *\n     * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe\n     * if you are mutating the array of child nodes during iteration.\n     * PostCSS will adjust the current index to match the mutations.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * const root = postcss.parse('a { color: black; z-index: 1 }');\n     * const rule = root.first;\n     *\n     * for ( let decl of rule.nodes ) {\n     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });\n     *     // Cycle will be infinite, because cloneBefore moves the current node\n     *     // to the next index\n     * }\n     *\n     * rule.each(decl => {\n     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });\n     *     // Will be executed only for color and z-index\n     * });\n     */\n    each(callback) {\n        if ( !this.lastEach ) this.lastEach = 0;\n        if ( !this.indexes ) this.indexes = { };\n\n        this.lastEach += 1;\n        let id = this.lastEach;\n        this.indexes[id] = 0;\n\n        if ( !this.nodes ) return undefined;\n\n        let index, result;\n        while ( this.indexes[id] < this.nodes.length ) {\n            index  = this.indexes[id];\n            result = callback(this.nodes[index], index);\n            if ( result === false ) break;\n\n            this.indexes[id] += 1;\n        }\n\n        delete this.indexes[id];\n\n        return result;\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each node.\n     *\n     * Like container.each(), this method is safe to use\n     * if you are mutating arrays during iteration.\n     *\n     * If you only need to iterate through the container’s immediate children,\n     * use {@link Container#each}.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walk(node => {\n     *   // Traverses all descendant nodes.\n     * });\n     */\n    walk(callback) {\n        return this.each( (child, i) => {\n            let result = callback(child, i);\n            if ( result !== false && child.walk ) {\n                result = child.walk(callback);\n            }\n            return result;\n        });\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each declaration node.\n     *\n     * If you pass a filter, iteration will only happen over declarations\n     * with matching properties.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [prop]   - string or regular expression\n     *                                   to filter declarations by property name\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkDecls(decl => {\n     *   checkPropertySupport(decl.prop);\n     * });\n     *\n     * root.walkDecls('border-radius', decl => {\n     *   decl.remove();\n     * });\n     *\n     * root.walkDecls(/^background/, decl => {\n     *   decl.value = takeFirstColorFromGradient(decl.value);\n     * });\n     */\n    walkDecls(prop, callback) {\n        if ( !callback ) {\n            callback = prop;\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( prop instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' && prop.test(child.prop) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' && child.prop === prop ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each rule node.\n     *\n     * If you pass a filter, iteration will only happen over rules\n     * with matching selectors.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [selector] - string or regular expression\n     *                                     to filter rules by selector\n     * @param {childIterator} callback   - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * const selectors = [];\n     * root.walkRules(rule => {\n     *   selectors.push(rule.selector);\n     * });\n     * console.log(`Your CSS uses ${selectors.length} selectors`);\n     */\n    walkRules(selector, callback) {\n        if ( !callback ) {\n            callback = selector;\n\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( selector instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' && selector.test(child.selector) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' && child.selector === selector ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each at-rule node.\n     *\n     * If you pass a filter, iteration will only happen over at-rules\n     * that have matching names.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [name]   - string or regular expression\n     *                                   to filter at-rules by name\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkAtRules(rule => {\n     *   if ( isOld(rule.name) ) rule.remove();\n     * });\n     *\n     * let first = false;\n     * root.walkAtRules('charset', rule => {\n     *   if ( !first ) {\n     *     first = true;\n     *   } else {\n     *     rule.remove();\n     *   }\n     * });\n     */\n    walkAtRules(name, callback) {\n        if ( !callback ) {\n            callback = name;\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( name instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' && name.test(child.name) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' && child.name === name ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each comment node.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkComments(comment => {\n     *   comment.remove();\n     * });\n     */\n    walkComments(callback) {\n        return this.walk( (child, i) => {\n            if ( child.type === 'comment' ) {\n                return callback(child, i);\n            }\n        });\n    }\n\n    /**\n     * Inserts new nodes to the end of the container.\n     *\n     * @param {...(Node|object|string|Node[])} children - new nodes\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });\n     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });\n     * rule.append(decl1, decl2);\n     *\n     * root.append({ name: 'charset', params: '\"UTF-8\"' });  // at-rule\n     * root.append({ selector: 'a' });                       // rule\n     * rule.append({ prop: 'color', value: 'black' });       // declaration\n     * rule.append({ text: 'Comment' })                      // comment\n     *\n     * root.append('a {}');\n     * root.first.append('color: black; z-index: 1');\n     */\n    append(...children) {\n        for ( let child of children ) {\n            let nodes = this.normalize(child, this.last);\n            for ( let node of nodes ) this.nodes.push(node);\n        }\n        return this;\n    }\n\n    /**\n     * Inserts new nodes to the start of the container.\n     *\n     * @param {...(Node|object|string|Node[])} children - new nodes\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });\n     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });\n     * rule.prepend(decl1, decl2);\n     *\n     * root.append({ name: 'charset', params: '\"UTF-8\"' });  // at-rule\n     * root.append({ selector: 'a' });                       // rule\n     * rule.append({ prop: 'color', value: 'black' });       // declaration\n     * rule.append({ text: 'Comment' })                      // comment\n     *\n     * root.append('a {}');\n     * root.first.append('color: black; z-index: 1');\n     */\n    prepend(...children) {\n        children = children.reverse();\n        for ( let child of children ) {\n            let nodes = this.normalize(child, this.first, 'prepend').reverse();\n            for ( let node of nodes ) this.nodes.unshift(node);\n            for ( let id in this.indexes ) {\n                this.indexes[id] = this.indexes[id] + nodes.length;\n            }\n        }\n        return this;\n    }\n\n    cleanRaws(keepBetween) {\n        super.cleanRaws(keepBetween);\n        if ( this.nodes ) {\n            for ( let node of this.nodes ) node.cleanRaws(keepBetween);\n        }\n    }\n\n    /**\n     * Insert new node before old node within the container.\n     *\n     * @param {Node|number} exist             - child or child’s index.\n     * @param {Node|object|string|Node[]} add - new node\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));\n     */\n    insertBefore(exist, add) {\n        exist = this.index(exist);\n\n        let type  = exist === 0 ? 'prepend' : false;\n        let nodes = this.normalize(add, this.nodes[exist], type).reverse();\n        for ( let node of nodes ) this.nodes.splice(exist, 0, node);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( exist <= index ) {\n                this.indexes[id] = index + nodes.length;\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Insert new node after old node within the container.\n     *\n     * @param {Node|number} exist             - child or child’s index\n     * @param {Node|object|string|Node[]} add - new node\n     *\n     * @return {Node} this node for methods chain\n     */\n    insertAfter(exist, add) {\n        exist = this.index(exist);\n\n        let nodes = this.normalize(add, this.nodes[exist]).reverse();\n        for ( let node of nodes ) this.nodes.splice(exist + 1, 0, node);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( exist < index ) {\n                this.indexes[id] = index + nodes.length;\n            }\n        }\n\n        return this;\n    }\n\n    remove(child) {\n        if ( typeof child !== 'undefined' ) {\n            warnOnce('Container#remove is deprecated. ' +\n                     'Use Container#removeChild');\n            this.removeChild(child);\n        } else {\n            super.remove();\n        }\n        return this;\n    }\n\n    /**\n     * Removes node from the container and cleans the parent properties\n     * from the node and its children.\n     *\n     * @param {Node|number} child - child or child’s index\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.nodes.length  //=> 5\n     * rule.removeChild(decl);\n     * rule.nodes.length  //=> 4\n     * decl.parent        //=> undefined\n     */\n    removeChild(child) {\n        child = this.index(child);\n        this.nodes[child].parent = undefined;\n        this.nodes.splice(child, 1);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( index >= child ) {\n                this.indexes[id] = index - 1;\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Removes all children from the container\n     * and cleans their parent properties.\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.removeAll();\n     * rule.nodes.length //=> 0\n     */\n    removeAll() {\n        for ( let node of this.nodes ) node.parent = undefined;\n        this.nodes = [];\n        return this;\n    }\n\n    /**\n     * Passes all declaration values within the container that match pattern\n     * through callback, replacing those values with the returned result\n     * of callback.\n     *\n     * This method is useful if you are using a custom unit or function\n     * and need to iterate through all values.\n     *\n     * @param {string|RegExp} pattern      - replace pattern\n     * @param {object} opts                - options to speed up the search\n     * @param {string|string[]} opts.props - an array of property names\n     * @param {string} opts.fast           - string that’s used\n     *                                       to narrow down values and speed up\n                                             the regexp search\n     * @param {function|string} callback   - string to replace pattern\n     *                                       or callback that returns a new\n     *                                       value.\n     *                                       The callback will receive\n     *                                       the same arguments as those\n     *                                       passed to a function parameter\n     *                                       of `String#replace`.\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * root.replaceValues(/\\d+rem/, { fast: 'rem' }, string => {\n     *   return 15 * parseInt(string) + 'px';\n     * });\n     */\n    replaceValues(pattern, opts, callback) {\n        if ( !callback ) {\n            callback = opts;\n            opts = { };\n        }\n\n        this.walkDecls( decl => {\n            if ( opts.props && opts.props.indexOf(decl.prop) === -1 ) return;\n            if ( opts.fast  && decl.value.indexOf(opts.fast) === -1 ) return;\n\n            decl.value = decl.value.replace(pattern, callback);\n        });\n\n        return this;\n    }\n\n    /**\n     * Returns `true` if callback returns `true`\n     * for all of the container’s children.\n     *\n     * @param {childCondition} condition - iterator returns true or false.\n     *\n     * @return {boolean} is every child pass condition\n     *\n     * @example\n     * const noPrefixes = rule.every(i => i.prop[0] !== '-');\n     */\n    every(condition) {\n        return this.nodes.every(condition);\n    }\n\n    /**\n     * Returns `true` if callback returns `true` for (at least) one\n     * of the container’s children.\n     *\n     * @param {childCondition} condition - iterator returns true or false.\n     *\n     * @return {boolean} is some child pass condition\n     *\n     * @example\n     * const hasPrefix = rule.some(i => i.prop[0] === '-');\n     */\n    some(condition) {\n        return this.nodes.some(condition);\n    }\n\n    /**\n     * Returns a `child`’s index within the {@link Container#nodes} array.\n     *\n     * @param {Node} child - child of the current container.\n     *\n     * @return {number} child index\n     *\n     * @example\n     * rule.index( rule.nodes[2] ) //=> 2\n     */\n    index(child) {\n        if ( typeof child === 'number' ) {\n            return child;\n        } else {\n            return this.nodes.indexOf(child);\n        }\n    }\n\n    /**\n     * The container’s first child.\n     *\n     * @type {Node}\n     *\n     * @example\n     * rule.first == rules.nodes[0];\n     */\n    get first() {\n        if ( !this.nodes ) return undefined;\n        return this.nodes[0];\n    }\n\n    /**\n     * The container’s last child.\n     *\n     * @type {Node}\n     *\n     * @example\n     * rule.last == rule.nodes[rule.nodes.length - 1];\n     */\n    get last() {\n        if ( !this.nodes ) return undefined;\n        return this.nodes[this.nodes.length - 1];\n    }\n\n    normalize(nodes, sample) {\n        if ( typeof nodes === 'string' ) {\n            let parse = require('./parse');\n            nodes = cleanSource(parse(nodes).nodes);\n        } else if ( !Array.isArray(nodes) ) {\n            if ( nodes.type === 'root' ) {\n                nodes = nodes.nodes;\n            } else if ( nodes.type ) {\n                nodes = [nodes];\n            } else if ( nodes.prop ) {\n                if ( typeof nodes.value === 'undefined' ) {\n                    throw new Error('Value field is missed in node creation');\n                } else if ( typeof nodes.value !== 'string' ) {\n                    nodes.value = String(nodes.value);\n                }\n                nodes = [new Declaration(nodes)];\n            } else if ( nodes.selector ) {\n                let Rule = require('./rule');\n                nodes = [new Rule(nodes)];\n            } else if ( nodes.name ) {\n                let AtRule = require('./at-rule');\n                nodes = [new AtRule(nodes)];\n            } else if ( nodes.text ) {\n                nodes = [new Comment(nodes)];\n            } else {\n                throw new Error('Unknown node type in node creation');\n            }\n        }\n\n        let processed = nodes.map( i => {\n            if ( typeof i.raws === 'undefined' ) i = this.rebuild(i);\n\n            if ( i.parent ) i = i.clone();\n            if ( typeof i.raws.before === 'undefined' ) {\n                if ( sample && typeof sample.raws.before !== 'undefined' ) {\n                    i.raws.before = sample.raws.before.replace(/[^\\s]/g, '');\n                }\n            }\n            i.parent = this;\n            return i;\n        });\n\n        return processed;\n    }\n\n    rebuild(node, parent) {\n        let fix;\n        if ( node.type === 'root' ) {\n            let Root = require('./root');\n            fix = new Root();\n        } else if ( node.type === 'atrule' ) {\n            let AtRule = require('./at-rule');\n            fix = new AtRule();\n        } else if ( node.type === 'rule' ) {\n            let Rule = require('./rule');\n            fix = new Rule();\n        } else if ( node.type === 'decl' ) {\n            fix = new Declaration();\n        } else if ( node.type === 'comment' ) {\n            fix = new Comment();\n        }\n\n        for ( let i in node ) {\n            if ( i === 'nodes' ) {\n                fix.nodes = node.nodes.map( j => this.rebuild(j, fix) );\n            } else if ( i === 'parent' && parent ) {\n                fix.parent = parent;\n            } else if ( node.hasOwnProperty(i) ) {\n                fix[i] = node[i];\n            }\n        }\n\n        return fix;\n    }\n\n    eachInside(callback) {\n        warnOnce('Container#eachInside is deprecated. ' +\n                 'Use Container#walk instead.');\n        return this.walk(callback);\n    }\n\n    eachDecl(prop, callback) {\n        warnOnce('Container#eachDecl is deprecated. ' +\n                 'Use Container#walkDecls instead.');\n        return this.walkDecls(prop, callback);\n    }\n\n    eachRule(selector, callback) {\n        warnOnce('Container#eachRule is deprecated. ' +\n                 'Use Container#walkRules instead.');\n        return this.walkRules(selector, callback);\n    }\n\n    eachAtRule(name, callback) {\n        warnOnce('Container#eachAtRule is deprecated. ' +\n                 'Use Container#walkAtRules instead.');\n        return this.walkAtRules(name, callback);\n    }\n\n    eachComment(callback) {\n        warnOnce('Container#eachComment is deprecated. ' +\n                 'Use Container#walkComments instead.');\n        return this.walkComments(callback);\n    }\n\n    get semicolon() {\n        warnOnce('Node#semicolon is deprecated. Use Node#raws.semicolon');\n        return this.raws.semicolon;\n    }\n\n    set semicolon(val) {\n        warnOnce('Node#semicolon is deprecated. Use Node#raws.semicolon');\n        this.raws.semicolon = val;\n    }\n\n    get after() {\n        warnOnce('Node#after is deprecated. Use Node#raws.after');\n        return this.raws.after;\n    }\n\n    set after(val) {\n        warnOnce('Node#after is deprecated. Use Node#raws.after');\n        this.raws.after = val;\n    }\n\n    /**\n     * @memberof Container#\n     * @member {Node[]} nodes - an array containing the container’s children\n     *\n     * @example\n     * const root = postcss.parse('a { color: black }');\n     * root.nodes.length           //=> 1\n     * root.nodes[0].selector      //=> 'a'\n     * root.nodes[0].nodes[0].prop //=> 'color'\n     */\n\n}\n\nexport default Container;\n\n\n/**\n * @callback childCondition\n * @param {Node} node    - container child\n * @param {number} index - child index\n * @param {Node[]} nodes - all container children\n * @return {boolean}\n */\n\n/**\n * @callback childIterator\n * @param {Node} node    - container child\n * @param {number} index - child index\n * @return {false|undefined} returning `false` will break iteration\n */\n"]} diff --git a/node_modules/postcss/lib/css-syntax-error.js b/node_modules/postcss/lib/css-syntax-error.js new file mode 100644 index 00000000..d2ea7989 --- /dev/null +++ b/node_modules/postcss/lib/css-syntax-error.js @@ -0,0 +1,272 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _supportsColor = require('supports-color'); + +var _supportsColor2 = _interopRequireDefault(_supportsColor); + +var _chalk = require('chalk'); + +var _chalk2 = _interopRequireDefault(_chalk); + +var _terminalHighlight = require('./terminal-highlight'); + +var _terminalHighlight2 = _interopRequireDefault(_terminalHighlight); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * The CSS parser throws this error for broken CSS. + * + * Custom parsers can throw this error for broken custom syntax using + * the {@link Node#error} method. + * + * PostCSS will use the input source map to detect the original error location. + * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS, + * PostCSS will show the original position in the Sass file. + * + * If you need the position in the PostCSS input + * (e.g., to debug the previous compiler), use `error.input.file`. + * + * @example + * // Catching and checking syntax error + * try { + * postcss.parse('a{') + * } catch (error) { + * if ( error.name === 'CssSyntaxError' ) { + * error //=> CssSyntaxError + * } + * } + * + * @example + * // Raising error from plugin + * throw node.error('Unknown variable', { plugin: 'postcss-vars' }); + */ +var CssSyntaxError = function () { + + /** + * @param {string} message - error message + * @param {number} [line] - source line of the error + * @param {number} [column] - source column of the error + * @param {string} [source] - source code of the broken file + * @param {string} [file] - absolute path to the broken file + * @param {string} [plugin] - PostCSS plugin name, if error came from plugin + */ + function CssSyntaxError(message, line, column, source, file, plugin) { + _classCallCheck(this, CssSyntaxError); + + /** + * @member {string} - Always equal to `'CssSyntaxError'`. You should + * always check error type + * by `error.name === 'CssSyntaxError'` instead of + * `error instanceof CssSyntaxError`, because + * npm could have several PostCSS versions. + * + * @example + * if ( error.name === 'CssSyntaxError' ) { + * error //=> CssSyntaxError + * } + */ + this.name = 'CssSyntaxError'; + /** + * @member {string} - Error message. + * + * @example + * error.message //=> 'Unclosed block' + */ + this.reason = message; + + if (file) { + /** + * @member {string} - Absolute path to the broken file. + * + * @example + * error.file //=> 'a.sass' + * error.input.file //=> 'a.css' + */ + this.file = file; + } + if (source) { + /** + * @member {string} - Source code of the broken file. + * + * @example + * error.source //=> 'a { b {} }' + * error.input.column //=> 'a b { }' + */ + this.source = source; + } + if (plugin) { + /** + * @member {string} - Plugin name, if error came from plugin. + * + * @example + * error.plugin //=> 'postcss-vars' + */ + this.plugin = plugin; + } + if (typeof line !== 'undefined' && typeof column !== 'undefined') { + /** + * @member {number} - Source line of the error. + * + * @example + * error.line //=> 2 + * error.input.line //=> 4 + */ + this.line = line; + /** + * @member {number} - Source column of the error. + * + * @example + * error.column //=> 1 + * error.input.column //=> 4 + */ + this.column = column; + } + + this.setMessage(); + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CssSyntaxError); + } + } + + CssSyntaxError.prototype.setMessage = function setMessage() { + /** + * @member {string} - Full error text in the GNU error format + * with plugin, file, line and column. + * + * @example + * error.message //=> 'a.css:1:1: Unclosed block' + */ + this.message = this.plugin ? this.plugin + ': ' : ''; + this.message += this.file ? this.file : '<css input>'; + if (typeof this.line !== 'undefined') { + this.message += ':' + this.line + ':' + this.column; + } + this.message += ': ' + this.reason; + }; + + /** + * Returns a few lines of CSS source that caused the error. + * + * If the CSS has an input source map without `sourceContent`, + * this method will return an empty string. + * + * @param {boolean} [color] whether arrow will be colored red by terminal + * color codes. By default, PostCSS will detect + * color support by `process.stdout.isTTY` + * and `process.env.NODE_DISABLE_COLORS`. + * + * @example + * error.showSourceCode() //=> " 4 | } + * // 5 | a { + * // > 6 | bad + * // | ^ + * // 7 | } + * // 8 | b {" + * + * @return {string} few lines of CSS source that caused the error + */ + + + CssSyntaxError.prototype.showSourceCode = function showSourceCode(color) { + var _this = this; + + if (!this.source) return ''; + + var css = this.source; + if (typeof color === 'undefined') color = _supportsColor2.default; + if (color) css = (0, _terminalHighlight2.default)(css); + + var lines = css.split(/\r?\n/); + var start = Math.max(this.line - 3, 0); + var end = Math.min(this.line + 2, lines.length); + + var maxWidth = String(end).length; + var colors = new _chalk2.default.constructor({ enabled: true }); + + function mark(text) { + if (color) { + return colors.red.bold(text); + } else { + return text; + } + } + function aside(text) { + if (color) { + return colors.gray(text); + } else { + return text; + } + } + + return lines.slice(start, end).map(function (line, index) { + var number = start + 1 + index; + var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '; + if (number === _this.line) { + var spacing = aside(gutter.replace(/\d/g, ' ')) + line.slice(0, _this.column - 1).replace(/[^\t]/g, ' '); + return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^'); + } else { + return ' ' + aside(gutter) + line; + } + }).join('\n'); + }; + + /** + * Returns error position, message and source code of the broken part. + * + * @example + * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block + * // > 1 | a { + * // | ^" + * + * @return {string} error position, message and source code + */ + + + CssSyntaxError.prototype.toString = function toString() { + var code = this.showSourceCode(); + if (code) { + code = '\n\n' + code + '\n'; + } + return this.name + ': ' + this.message + code; + }; + + _createClass(CssSyntaxError, [{ + key: 'generated', + get: function get() { + (0, _warnOnce2.default)('CssSyntaxError#generated is deprecated. Use input instead.'); + return this.input; + } + + /** + * @memberof CssSyntaxError# + * @member {Input} input - Input object with PostCSS internal information + * about input file. If input has source map + * from previous tool, PostCSS will use origin + * (for example, Sass) source. You can use this + * object to get PostCSS input source. + * + * @example + * error.input.file //=> 'a.css' + * error.file //=> 'a.sass' + */ + + }]); + + return CssSyntaxError; +}(); + +exports.default = CssSyntaxError; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["css-syntax-error.es6"],"names":["CssSyntaxError","message","line","column","source","file","plugin","name","reason","setMessage","Error","captureStackTrace","showSourceCode","color","css","lines","split","start","Math","max","end","min","length","maxWidth","String","colors","constructor","enabled","mark","text","red","bold","aside","gray","slice","map","index","number","gutter","spacing","replace","join","toString","code","input"],"mappings":";;;;;;AAAA;;;;AACA;;;;AAEA;;;;AACA;;;;;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BMA,c;;AAEF;;;;;;;;AAQA,4BAAYC,OAAZ,EAAqBC,IAArB,EAA2BC,MAA3B,EAAmCC,MAAnC,EAA2CC,IAA3C,EAAiDC,MAAjD,EAAyD;AAAA;;AACrD;;;;;;;;;;;;AAYA,aAAKC,IAAL,GAAc,gBAAd;AACA;;;;;;AAMA,aAAKC,MAAL,GAAcP,OAAd;;AAEA,YAAKI,IAAL,EAAY;AACR;;;;;;;AAOA,iBAAKA,IAAL,GAAYA,IAAZ;AACH;AACD,YAAKD,MAAL,EAAc;AACV;;;;;;;AAOA,iBAAKA,MAAL,GAAcA,MAAd;AACH;AACD,YAAKE,MAAL,EAAc;AACV;;;;;;AAMA,iBAAKA,MAAL,GAAcA,MAAd;AACH;AACD,YAAK,OAAOJ,IAAP,KAAgB,WAAhB,IAA+B,OAAOC,MAAP,KAAkB,WAAtD,EAAoE;AAChE;;;;;;;AAOA,iBAAKD,IAAL,GAAcA,IAAd;AACA;;;;;;;AAOA,iBAAKC,MAAL,GAAcA,MAAd;AACH;;AAED,aAAKM,UAAL;;AAEA,YAAKC,MAAMC,iBAAX,EAA+B;AAC3BD,kBAAMC,iBAAN,CAAwB,IAAxB,EAA8BX,cAA9B;AACH;AACJ;;6BAEDS,U,yBAAa;AACT;;;;;;;AAOA,aAAKR,OAAL,GAAgB,KAAKK,MAAL,GAAc,KAAKA,MAAL,GAAc,IAA5B,GAAmC,EAAnD;AACA,aAAKL,OAAL,IAAgB,KAAKI,IAAL,GAAY,KAAKA,IAAjB,GAAwB,aAAxC;AACA,YAAK,OAAO,KAAKH,IAAZ,KAAqB,WAA1B,EAAwC;AACpC,iBAAKD,OAAL,IAAgB,MAAM,KAAKC,IAAX,GAAkB,GAAlB,GAAwB,KAAKC,MAA7C;AACH;AACD,aAAKF,OAAL,IAAgB,OAAO,KAAKO,MAA5B;AACH,K;;AAED;;;;;;;;;;;;;;;;;;;;;;;6BAqBAI,c,2BAAeC,K,EAAO;AAAA;;AAClB,YAAK,CAAC,KAAKT,MAAX,EAAoB,OAAO,EAAP;;AAEpB,YAAIU,MAAM,KAAKV,MAAf;AACA,YAAK,OAAOS,KAAP,KAAiB,WAAtB,EAAoCA;AACpC,YAAKA,KAAL,EAAaC,MAAM,iCAAkBA,GAAlB,CAAN;;AAEb,YAAIC,QAAQD,IAAIE,KAAJ,CAAU,OAAV,CAAZ;AACA,YAAIC,QAAQC,KAAKC,GAAL,CAAS,KAAKjB,IAAL,GAAY,CAArB,EAAwB,CAAxB,CAAZ;AACA,YAAIkB,MAAQF,KAAKG,GAAL,CAAS,KAAKnB,IAAL,GAAY,CAArB,EAAwBa,MAAMO,MAA9B,CAAZ;;AAEA,YAAIC,WAAWC,OAAOJ,GAAP,EAAYE,MAA3B;AACA,YAAIG,SAAS,IAAI,gBAAMC,WAAV,CAAsB,EAAEC,SAAS,IAAX,EAAtB,CAAb;;AAEA,iBAASC,IAAT,CAAcC,IAAd,EAAoB;AAChB,gBAAKhB,KAAL,EAAa;AACT,uBAAOY,OAAOK,GAAP,CAAWC,IAAX,CAAgBF,IAAhB,CAAP;AACH,aAFD,MAEO;AACH,uBAAOA,IAAP;AACH;AACJ;AACD,iBAASG,KAAT,CAAeH,IAAf,EAAqB;AACjB,gBAAKhB,KAAL,EAAa;AACT,uBAAOY,OAAOQ,IAAP,CAAYJ,IAAZ,CAAP;AACH,aAFD,MAEO;AACH,uBAAOA,IAAP;AACH;AACJ;;AAED,eAAOd,MAAMmB,KAAN,CAAYjB,KAAZ,EAAmBG,GAAnB,EAAwBe,GAAxB,CAA6B,UAACjC,IAAD,EAAOkC,KAAP,EAAiB;AACjD,gBAAIC,SAASpB,QAAQ,CAAR,GAAYmB,KAAzB;AACA,gBAAIE,SAAS,MAAM,CAAC,MAAMD,MAAP,EAAeH,KAAf,CAAqB,CAACX,QAAtB,CAAN,GAAwC,KAArD;AACA,gBAAKc,WAAW,MAAKnC,IAArB,EAA4B;AACxB,oBAAIqC,UACAP,MAAMM,OAAOE,OAAP,CAAe,KAAf,EAAsB,GAAtB,CAAN,IACAtC,KAAKgC,KAAL,CAAW,CAAX,EAAc,MAAK/B,MAAL,GAAc,CAA5B,EAA+BqC,OAA/B,CAAuC,QAAvC,EAAiD,GAAjD,CAFJ;AAGA,uBAAOZ,KAAK,GAAL,IAAYI,MAAMM,MAAN,CAAZ,GAA4BpC,IAA5B,GAAmC,KAAnC,GACAqC,OADA,GACUX,KAAK,GAAL,CADjB;AAEH,aAND,MAMO;AACH,uBAAO,MAAMI,MAAMM,MAAN,CAAN,GAAsBpC,IAA7B;AACH;AACJ,SAZM,EAYJuC,IAZI,CAYC,IAZD,CAAP;AAaH,K;;AAED;;;;;;;;;;;;6BAUAC,Q,uBAAW;AACP,YAAIC,OAAO,KAAK/B,cAAL,EAAX;AACA,YAAK+B,IAAL,EAAY;AACRA,mBAAO,SAASA,IAAT,GAAgB,IAAvB;AACH;AACD,eAAO,KAAKpC,IAAL,GAAY,IAAZ,GAAmB,KAAKN,OAAxB,GAAkC0C,IAAzC;AACH,K;;;;4BAEe;AACZ,oCAAS,4DAAT;AACA,mBAAO,KAAKC,KAAZ;AACH;;AAED;;;;;;;;;;;;;;;;;;kBAeW5C,c","file":"css-syntax-error.js","sourcesContent":["import supportsColor from 'supports-color';\nimport chalk         from 'chalk';\n\nimport terminalHighlight from './terminal-highlight';\nimport warnOnce          from './warn-once';\n\n/**\n * The CSS parser throws this error for broken CSS.\n *\n * Custom parsers can throw this error for broken custom syntax using\n * the {@link Node#error} method.\n *\n * PostCSS will use the input source map to detect the original error location.\n * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,\n * PostCSS will show the original position in the Sass file.\n *\n * If you need the position in the PostCSS input\n * (e.g., to debug the previous compiler), use `error.input.file`.\n *\n * @example\n * // Catching and checking syntax error\n * try {\n *   postcss.parse('a{')\n * } catch (error) {\n *   if ( error.name === 'CssSyntaxError' ) {\n *     error //=> CssSyntaxError\n *   }\n * }\n *\n * @example\n * // Raising error from plugin\n * throw node.error('Unknown variable', { plugin: 'postcss-vars' });\n */\nclass CssSyntaxError {\n\n    /**\n     * @param {string} message  - error message\n     * @param {number} [line]   - source line of the error\n     * @param {number} [column] - source column of the error\n     * @param {string} [source] - source code of the broken file\n     * @param {string} [file]   - absolute path to the broken file\n     * @param {string} [plugin] - PostCSS plugin name, if error came from plugin\n     */\n    constructor(message, line, column, source, file, plugin) {\n        /**\n         * @member {string} - Always equal to `'CssSyntaxError'`. You should\n         *                    always check error type\n         *                    by `error.name === 'CssSyntaxError'` instead of\n         *                    `error instanceof CssSyntaxError`, because\n         *                    npm could have several PostCSS versions.\n         *\n         * @example\n         * if ( error.name === 'CssSyntaxError' ) {\n         *   error //=> CssSyntaxError\n         * }\n         */\n        this.name   = 'CssSyntaxError';\n        /**\n         * @member {string} - Error message.\n         *\n         * @example\n         * error.message //=> 'Unclosed block'\n         */\n        this.reason = message;\n\n        if ( file ) {\n            /**\n             * @member {string} - Absolute path to the broken file.\n             *\n             * @example\n             * error.file       //=> 'a.sass'\n             * error.input.file //=> 'a.css'\n             */\n            this.file = file;\n        }\n        if ( source ) {\n            /**\n             * @member {string} - Source code of the broken file.\n             *\n             * @example\n             * error.source       //=> 'a { b {} }'\n             * error.input.column //=> 'a b { }'\n             */\n            this.source = source;\n        }\n        if ( plugin ) {\n            /**\n             * @member {string} - Plugin name, if error came from plugin.\n             *\n             * @example\n             * error.plugin //=> 'postcss-vars'\n             */\n            this.plugin = plugin;\n        }\n        if ( typeof line !== 'undefined' && typeof column !== 'undefined' ) {\n            /**\n             * @member {number} - Source line of the error.\n             *\n             * @example\n             * error.line       //=> 2\n             * error.input.line //=> 4\n             */\n            this.line   = line;\n            /**\n             * @member {number} - Source column of the error.\n             *\n             * @example\n             * error.column       //=> 1\n             * error.input.column //=> 4\n             */\n            this.column = column;\n        }\n\n        this.setMessage();\n\n        if ( Error.captureStackTrace ) {\n            Error.captureStackTrace(this, CssSyntaxError);\n        }\n    }\n\n    setMessage() {\n        /**\n         * @member {string} - Full error text in the GNU error format\n         *                    with plugin, file, line and column.\n         *\n         * @example\n         * error.message //=> 'a.css:1:1: Unclosed block'\n         */\n        this.message  = this.plugin ? this.plugin + ': ' : '';\n        this.message += this.file ? this.file : '<css input>';\n        if ( typeof this.line !== 'undefined' ) {\n            this.message += ':' + this.line + ':' + this.column;\n        }\n        this.message += ': ' + this.reason;\n    }\n\n    /**\n     * Returns a few lines of CSS source that caused the error.\n     *\n     * If the CSS has an input source map without `sourceContent`,\n     * this method will return an empty string.\n     *\n     * @param {boolean} [color] whether arrow will be colored red by terminal\n     *                          color codes. By default, PostCSS will detect\n     *                          color support by `process.stdout.isTTY`\n     *                          and `process.env.NODE_DISABLE_COLORS`.\n     *\n     * @example\n     * error.showSourceCode() //=> \"  4 | }\n     *                        //      5 | a {\n     *                        //    > 6 |   bad\n     *                        //        |   ^\n     *                        //      7 | }\n     *                        //      8 | b {\"\n     *\n     * @return {string} few lines of CSS source that caused the error\n     */\n    showSourceCode(color) {\n        if ( !this.source ) return '';\n\n        let css = this.source;\n        if ( typeof color === 'undefined' ) color = supportsColor;\n        if ( color ) css = terminalHighlight(css);\n\n        let lines = css.split(/\\r?\\n/);\n        let start = Math.max(this.line - 3, 0);\n        let end   = Math.min(this.line + 2, lines.length);\n\n        let maxWidth = String(end).length;\n        let colors = new chalk.constructor({ enabled: true });\n\n        function mark(text) {\n            if ( color ) {\n                return colors.red.bold(text);\n            } else {\n                return text;\n            }\n        }\n        function aside(text) {\n            if ( color ) {\n                return colors.gray(text);\n            } else {\n                return text;\n            }\n        }\n\n        return lines.slice(start, end).map( (line, index) => {\n            let number = start + 1 + index;\n            let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';\n            if ( number === this.line ) {\n                let spacing =\n                    aside(gutter.replace(/\\d/g, ' ')) +\n                    line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ');\n                return mark('>') + aside(gutter) + line + '\\n ' +\n                       spacing + mark('^');\n            } else {\n                return ' ' + aside(gutter) + line;\n            }\n        }).join('\\n');\n    }\n\n    /**\n     * Returns error position, message and source code of the broken part.\n     *\n     * @example\n     * error.toString() //=> \"CssSyntaxError: app.css:1:1: Unclosed block\n     *                  //    > 1 | a {\n     *                  //        | ^\"\n     *\n     * @return {string} error position, message and source code\n     */\n    toString() {\n        let code = this.showSourceCode();\n        if ( code ) {\n            code = '\\n\\n' + code + '\\n';\n        }\n        return this.name + ': ' + this.message + code;\n    }\n\n    get generated() {\n        warnOnce('CssSyntaxError#generated is deprecated. Use input instead.');\n        return this.input;\n    }\n\n    /**\n     * @memberof CssSyntaxError#\n     * @member {Input} input - Input object with PostCSS internal information\n     *                         about input file. If input has source map\n     *                         from previous tool, PostCSS will use origin\n     *                         (for example, Sass) source. You can use this\n     *                         object to get PostCSS input source.\n     *\n     * @example\n     * error.input.file //=> 'a.css'\n     * error.file       //=> 'a.sass'\n     */\n\n}\n\nexport default CssSyntaxError;\n"]} diff --git a/node_modules/postcss/lib/declaration.js b/node_modules/postcss/lib/declaration.js new file mode 100644 index 00000000..a09b0eff --- /dev/null +++ b/node_modules/postcss/lib/declaration.js @@ -0,0 +1,130 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Represents a CSS declaration. + * + * @extends Node + * + * @example + * const root = postcss.parse('a { color: black }'); + * const decl = root.first.first; + * decl.type //=> 'decl' + * decl.toString() //=> ' color: black' + */ +var Declaration = function (_Node) { + _inherits(Declaration, _Node); + + function Declaration(defaults) { + _classCallCheck(this, Declaration); + + var _this = _possibleConstructorReturn(this, _Node.call(this, defaults)); + + _this.type = 'decl'; + return _this; + } + + _createClass(Declaration, [{ + key: '_value', + get: function get() { + (0, _warnOnce2.default)('Node#_value was deprecated. Use Node#raws.value'); + return this.raws.value; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#_value was deprecated. Use Node#raws.value'); + this.raws.value = val; + } + }, { + key: '_important', + get: function get() { + (0, _warnOnce2.default)('Node#_important was deprecated. Use Node#raws.important'); + return this.raws.important; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#_important was deprecated. Use Node#raws.important'); + this.raws.important = val; + } + + /** + * @memberof Declaration# + * @member {string} prop - the declaration’s property name + * + * @example + * const root = postcss.parse('a { color: black }'); + * const decl = root.first.first; + * decl.prop //=> 'color' + */ + + /** + * @memberof Declaration# + * @member {string} value - the declaration’s value + * + * @example + * const root = postcss.parse('a { color: black }'); + * const decl = root.first.first; + * decl.value //=> 'black' + */ + + /** + * @memberof Declaration# + * @member {boolean} important - `true` if the declaration + * has an !important annotation. + * + * @example + * const root = postcss.parse('a { color: black !important; color: red }'); + * root.first.first.important //=> true + * root.first.last.important //=> undefined + */ + + /** + * @memberof Declaration# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `between`: the symbols between the property and value + * for declarations. + * * `important`: the content of the important statement, + * if it is not just `!important`. + * + * PostCSS cleans declaration from comments and extra spaces, + * but it stores origin content in raws properties. + * As such, if you don’t change a declaration’s value, + * PostCSS will use the raw value with comments. + * + * @example + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '\n ', between: ':' } + */ + + }]); + + return Declaration; +}(_node2.default); + +exports.default = Declaration; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/input.js b/node_modules/postcss/lib/input.js new file mode 100644 index 00000000..7f9949f0 --- /dev/null +++ b/node_modules/postcss/lib/input.js @@ -0,0 +1,198 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _cssSyntaxError = require('./css-syntax-error'); + +var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError); + +var _previousMap = require('./previous-map'); + +var _previousMap2 = _interopRequireDefault(_previousMap); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var sequence = 0; + +/** + * Represents the source CSS. + * + * @example + * const root = postcss.parse(css, { from: file }); + * const input = root.source.input; + */ + +var Input = function () { + + /** + * @param {string} css - input CSS source + * @param {object} [opts] - {@link Processor#process} options + */ + function Input(css) { + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + _classCallCheck(this, Input); + + /** + * @member {string} - input CSS source + * + * @example + * const input = postcss.parse('a{}', { from: file }).input; + * input.css //=> "a{}"; + */ + this.css = css.toString(); + + if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { + this.css = this.css.slice(1); + } + + if (opts.from) { + if (/^\w+:\/\//.test(opts.from)) { + /** + * @member {string} - The absolute path to the CSS source file + * defined with the `from` option. + * + * @example + * const root = postcss.parse(css, { from: 'a.css' }); + * root.source.input.file //=> '/home/ai/a.css' + */ + this.file = opts.from; + } else { + this.file = _path2.default.resolve(opts.from); + } + } + + var map = new _previousMap2.default(this.css, opts); + if (map.text) { + /** + * @member {PreviousMap} - The input source map passed from + * a compilation step before PostCSS + * (for example, from Sass compiler). + * + * @example + * root.source.input.map.consumer().sources //=> ['a.sass'] + */ + this.map = map; + var file = map.consumer().file; + if (!this.file && file) this.file = this.mapResolve(file); + } + + if (!this.file) { + sequence += 1; + /** + * @member {string} - The unique ID of the CSS source. It will be + * created if `from` option is not provided + * (because PostCSS does not know the file path). + * + * @example + * const root = postcss.parse(css); + * root.source.input.file //=> undefined + * root.source.input.id //=> "<input css 1>" + */ + this.id = '<input css ' + sequence + '>'; + } + if (this.map) this.map.file = this.from; + } + + Input.prototype.error = function error(message, line, column) { + var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {}; + + var result = void 0; + var origin = this.origin(line, column); + if (origin) { + result = new _cssSyntaxError2.default(message, origin.line, origin.column, origin.source, origin.file, opts.plugin); + } else { + result = new _cssSyntaxError2.default(message, line, column, this.css, this.file, opts.plugin); + } + + result.input = { line: line, column: column, source: this.css }; + if (this.file) result.input.file = this.file; + + return result; + }; + + /** + * Reads the input source map and returns a symbol position + * in the input source (e.g., in a Sass file that was compiled + * to CSS before being passed to PostCSS). + * + * @param {number} line - line in input CSS + * @param {number} column - column in input CSS + * + * @return {filePosition} position in input source + * + * @example + * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 } + */ + + + Input.prototype.origin = function origin(line, column) { + if (!this.map) return false; + var consumer = this.map.consumer(); + + var from = consumer.originalPositionFor({ line: line, column: column }); + if (!from.source) return false; + + var result = { + file: this.mapResolve(from.source), + line: from.line, + column: from.column + }; + + var source = consumer.sourceContentFor(from.source); + if (source) result.source = source; + + return result; + }; + + Input.prototype.mapResolve = function mapResolve(file) { + if (/^\w+:\/\//.test(file)) { + return file; + } else { + return _path2.default.resolve(this.map.consumer().sourceRoot || '.', file); + } + }; + + /** + * The CSS source identifier. Contains {@link Input#file} if the user + * set the `from` option, or {@link Input#id} if they did not. + * @type {string} + * + * @example + * const root = postcss.parse(css, { from: 'a.css' }); + * root.source.input.from //=> "/home/ai/a.css" + * + * const root = postcss.parse(css); + * root.source.input.from //=> "<input css 1>" + */ + + + _createClass(Input, [{ + key: 'from', + get: function get() { + return this.file || this.id; + } + }]); + + return Input; +}(); + +exports.default = Input; + +/** + * @typedef {object} filePosition + * @property {string} file - path to file + * @property {number} line - source line in file + * @property {number} column - source column in file + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["input.es6"],"names":["sequence","Input","css","opts","toString","slice","from","test","file","resolve","map","text","consumer","mapResolve","id","error","message","line","column","result","origin","source","plugin","input","originalPositionFor","sourceContentFor","sourceRoot"],"mappings":"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","file":"input.js","sourcesContent":["import CssSyntaxError from './css-syntax-error';\nimport PreviousMap    from './previous-map';\n\nimport path from 'path';\n\nlet sequence = 0;\n\n/**\n * Represents the source CSS.\n *\n * @example\n * const root  = postcss.parse(css, { from: file });\n * const input = root.source.input;\n */\nclass Input {\n\n    /**\n     * @param {string} css    - input CSS source\n     * @param {object} [opts] - {@link Processor#process} options\n     */\n    constructor(css, opts = { }) {\n        /**\n         * @member {string} - input CSS source\n         *\n         * @example\n         * const input = postcss.parse('a{}', { from: file }).input;\n         * input.css //=> \"a{}\";\n         */\n        this.css = css.toString();\n\n        if ( this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE' ) {\n            this.css = this.css.slice(1);\n        }\n\n        if ( opts.from ) {\n            if ( /^\\w+:\\/\\//.test(opts.from) ) {\n                /**\n                 * @member {string} - The absolute path to the CSS source file\n                 *                    defined with the `from` option.\n                 *\n                 * @example\n                 * const root = postcss.parse(css, { from: 'a.css' });\n                 * root.source.input.file //=> '/home/ai/a.css'\n                 */\n                this.file = opts.from;\n            } else {\n                this.file = path.resolve(opts.from);\n            }\n        }\n\n        let map = new PreviousMap(this.css, opts);\n        if ( map.text ) {\n            /**\n             * @member {PreviousMap} - The input source map passed from\n             *                         a compilation step before PostCSS\n             *                         (for example, from Sass compiler).\n             *\n             * @example\n             * root.source.input.map.consumer().sources //=> ['a.sass']\n             */\n            this.map = map;\n            let file = map.consumer().file;\n            if ( !this.file && file ) this.file = this.mapResolve(file);\n        }\n\n        if ( !this.file ) {\n            sequence += 1;\n            /**\n             * @member {string} - The unique ID of the CSS source. It will be\n             *                    created if `from` option is not provided\n             *                    (because PostCSS does not know the file path).\n             *\n             * @example\n             * const root = postcss.parse(css);\n             * root.source.input.file //=> undefined\n             * root.source.input.id   //=> \"<input css 1>\"\n             */\n            this.id   = '<input css ' + sequence + '>';\n        }\n        if ( this.map ) this.map.file = this.from;\n    }\n\n    error(message, line, column, opts = { }) {\n        let result;\n        let origin = this.origin(line, column);\n        if ( origin ) {\n            result = new CssSyntaxError(message, origin.line, origin.column,\n                origin.source, origin.file, opts.plugin);\n        } else {\n            result = new CssSyntaxError(message, line, column,\n                this.css, this.file, opts.plugin);\n        }\n\n        result.input = { line, column, source: this.css };\n        if ( this.file ) result.input.file = this.file;\n\n        return result;\n    }\n\n    /**\n     * Reads the input source map and returns a symbol position\n     * in the input source (e.g., in a Sass file that was compiled\n     * to CSS before being passed to PostCSS).\n     *\n     * @param {number} line   - line in input CSS\n     * @param {number} column - column in input CSS\n     *\n     * @return {filePosition} position in input source\n     *\n     * @example\n     * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }\n     */\n    origin(line, column) {\n        if ( !this.map ) return false;\n        let consumer = this.map.consumer();\n\n        let from = consumer.originalPositionFor({ line, column });\n        if ( !from.source ) return false;\n\n        let result = {\n            file:   this.mapResolve(from.source),\n            line:   from.line,\n            column: from.column\n        };\n\n        let source = consumer.sourceContentFor(from.source);\n        if ( source ) result.source = source;\n\n        return result;\n    }\n\n    mapResolve(file) {\n        if ( /^\\w+:\\/\\//.test(file) ) {\n            return file;\n        } else {\n            return path.resolve(this.map.consumer().sourceRoot || '.', file);\n        }\n    }\n\n    /**\n     * The CSS source identifier. Contains {@link Input#file} if the user\n     * set the `from` option, or {@link Input#id} if they did not.\n     * @type {string}\n     *\n     * @example\n     * const root = postcss.parse(css, { from: 'a.css' });\n     * root.source.input.from //=> \"/home/ai/a.css\"\n     *\n     * const root = postcss.parse(css);\n     * root.source.input.from //=> \"<input css 1>\"\n     */\n    get from() {\n        return this.file || this.id;\n    }\n\n}\n\nexport default Input;\n\n/**\n * @typedef  {object} filePosition\n * @property {string} file   - path to file\n * @property {number} line   - source line in file\n * @property {number} column - source column in file\n */\n"]} diff --git a/node_modules/postcss/lib/lazy-result.js b/node_modules/postcss/lib/lazy-result.js new file mode 100644 index 00000000..6fbd9bd7 --- /dev/null +++ b/node_modules/postcss/lib/lazy-result.js @@ -0,0 +1,432 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _mapGenerator = require('./map-generator'); + +var _mapGenerator2 = _interopRequireDefault(_mapGenerator); + +var _stringify2 = require('./stringify'); + +var _stringify3 = _interopRequireDefault(_stringify2); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +var _result = require('./result'); + +var _result2 = _interopRequireDefault(_result); + +var _parse = require('./parse'); + +var _parse2 = _interopRequireDefault(_parse); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function isPromise(obj) { + return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function'; +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * + * A `LazyResult` instance is returned by {@link Processor#process}. + * + * @example + * const lazy = postcss([cssnext]).process(css); + */ + +var LazyResult = function () { + function LazyResult(processor, css, opts) { + _classCallCheck(this, LazyResult); + + this.stringified = false; + this.processed = false; + + var root = void 0; + if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css.type === 'root') { + root = css; + } else if (css instanceof LazyResult || css instanceof _result2.default) { + root = css.root; + if (css.map) { + if (typeof opts.map === 'undefined') opts.map = {}; + if (!opts.map.inline) opts.map.inline = false; + opts.map.prev = css.map; + } + } else { + var parser = _parse2.default; + if (opts.syntax) parser = opts.syntax.parse; + if (opts.parser) parser = opts.parser; + if (parser.parse) parser = parser.parse; + + try { + root = parser(css, opts); + } catch (error) { + this.error = error; + } + } + + this.result = new _result2.default(processor, root, opts); + } + + /** + * Returns a {@link Processor} instance, which will be used + * for CSS transformations. + * @type {Processor} + */ + + + /** + * Processes input CSS through synchronous plugins + * and calls {@link Result#warnings()}. + * + * @return {Warning[]} warnings from plugins + */ + LazyResult.prototype.warnings = function warnings() { + return this.sync().warnings(); + }; + + /** + * Alias for the {@link LazyResult#css} property. + * + * @example + * lazy + '' === lazy.css; + * + * @return {string} output CSS + */ + + + LazyResult.prototype.toString = function toString() { + return this.css; + }; + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls `onFulfilled` with a Result instance. If a plugin throws + * an error, the `onRejected` callback will be executed. + * + * It implements standard Promise API. + * + * @param {onFulfilled} onFulfilled - callback will be executed + * when all plugins will finish work + * @param {onRejected} onRejected - callback will be executed on any error + * + * @return {Promise} Promise API to make queue + * + * @example + * postcss([cssnext]).process(css).then(result => { + * console.log(result.css); + * }); + */ + + + LazyResult.prototype.then = function then(onFulfilled, onRejected) { + return this.async().then(onFulfilled, onRejected); + }; + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onRejected for each error thrown in any plugin. + * + * It implements standard Promise API. + * + * @param {onRejected} onRejected - callback will be executed on any error + * + * @return {Promise} Promise API to make queue + * + * @example + * postcss([cssnext]).process(css).then(result => { + * console.log(result.css); + * }).catch(error => { + * console.error(error); + * }); + */ + + + LazyResult.prototype.catch = function _catch(onRejected) { + return this.async().catch(onRejected); + }; + + LazyResult.prototype.handleError = function handleError(error, plugin) { + try { + this.error = error; + if (error.name === 'CssSyntaxError' && !error.plugin) { + error.plugin = plugin.postcssPlugin; + error.setMessage(); + } else if (plugin.postcssVersion) { + var pluginName = plugin.postcssPlugin; + var pluginVer = plugin.postcssVersion; + var runtimeVer = this.result.processor.version; + var a = pluginVer.split('.'); + var b = runtimeVer.split('.'); + + if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) { + (0, _warnOnce2.default)('Your current PostCSS version ' + 'is ' + runtimeVer + ', but ' + pluginName + ' ' + 'uses ' + pluginVer + '. Perhaps this is ' + 'the source of the error below.'); + } + } + } catch (err) { + if (console && console.error) console.error(err); + } + }; + + LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) { + var _this = this; + + if (this.plugin >= this.processor.plugins.length) { + this.processed = true; + return resolve(); + } + + try { + var plugin = this.processor.plugins[this.plugin]; + var promise = this.run(plugin); + this.plugin += 1; + + if (isPromise(promise)) { + promise.then(function () { + _this.asyncTick(resolve, reject); + }).catch(function (error) { + _this.handleError(error, plugin); + _this.processed = true; + reject(error); + }); + } else { + this.asyncTick(resolve, reject); + } + } catch (error) { + this.processed = true; + reject(error); + } + }; + + LazyResult.prototype.async = function async() { + var _this2 = this; + + if (this.processed) { + return new Promise(function (resolve, reject) { + if (_this2.error) { + reject(_this2.error); + } else { + resolve(_this2.stringify()); + } + }); + } + if (this.processing) { + return this.processing; + } + + this.processing = new Promise(function (resolve, reject) { + if (_this2.error) return reject(_this2.error); + _this2.plugin = 0; + _this2.asyncTick(resolve, reject); + }).then(function () { + _this2.processed = true; + return _this2.stringify(); + }); + + return this.processing; + }; + + LazyResult.prototype.sync = function sync() { + if (this.processed) return this.result; + this.processed = true; + + if (this.processing) { + throw new Error('Use process(css).then(cb) to work with async plugins'); + } + + if (this.error) throw this.error; + + for (var _iterator = this.result.processor.plugins, _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 plugin = _ref; + + var promise = this.run(plugin); + if (isPromise(promise)) { + throw new Error('Use process(css).then(cb) to work with async plugins'); + } + } + + return this.result; + }; + + LazyResult.prototype.run = function run(plugin) { + this.result.lastPlugin = plugin; + + try { + return plugin(this.result.root, this.result); + } catch (error) { + this.handleError(error, plugin); + throw error; + } + }; + + LazyResult.prototype.stringify = function stringify() { + if (this.stringified) return this.result; + this.stringified = true; + + this.sync(); + + var opts = this.result.opts; + var str = _stringify3.default; + if (opts.syntax) str = opts.syntax.stringify; + if (opts.stringifier) str = opts.stringifier; + if (str.stringify) str = str.stringify; + + var map = new _mapGenerator2.default(str, this.result.root, this.result.opts); + var data = map.generate(); + this.result.css = data[0]; + this.result.map = data[1]; + + return this.result; + }; + + _createClass(LazyResult, [{ + key: 'processor', + get: function get() { + return this.result.processor; + } + + /** + * Options from the {@link Processor#process} call. + * @type {processOptions} + */ + + }, { + key: 'opts', + get: function get() { + return this.result.opts; + } + + /** + * Processes input CSS through synchronous plugins, converts `Root` + * to a CSS string and returns {@link Result#css}. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. This is why this method is only + * for debug purpose, you should always use {@link LazyResult#then}. + * + * @type {string} + * @see Result#css + */ + + }, { + key: 'css', + get: function get() { + return this.stringify().css; + } + + /** + * An alias for the `css` property. Use it with syntaxes + * that generate non-CSS output. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. This is why this method is only + * for debug purpose, you should always use {@link LazyResult#then}. + * + * @type {string} + * @see Result#content + */ + + }, { + key: 'content', + get: function get() { + return this.stringify().content; + } + + /** + * Processes input CSS through synchronous plugins + * and returns {@link Result#map}. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. This is why this method is only + * for debug purpose, you should always use {@link LazyResult#then}. + * + * @type {SourceMapGenerator} + * @see Result#map + */ + + }, { + key: 'map', + get: function get() { + return this.stringify().map; + } + + /** + * Processes input CSS through synchronous plugins + * and returns {@link Result#root}. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * This is why this method is only for debug purpose, + * you should always use {@link LazyResult#then}. + * + * @type {Root} + * @see Result#root + */ + + }, { + key: 'root', + get: function get() { + return this.sync().root; + } + + /** + * Processes input CSS through synchronous plugins + * and returns {@link Result#messages}. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * This is why this method is only for debug purpose, + * you should always use {@link LazyResult#then}. + * + * @type {Message[]} + * @see Result#messages + */ + + }, { + key: 'messages', + get: function get() { + return this.sync().messages; + } + }]); + + return LazyResult; +}(); + +exports.default = LazyResult; + +/** + * @callback onFulfilled + * @param {Result} result + */ + +/** + * @callback onRejected + * @param {Error} error + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","map","inline","prev","parser","syntax","parse","error","result","warnings","sync","toString","onFulfilled","onRejected","async","catch","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","err","console","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","data","generate","content","messages"],"mappings":"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","file":"lazy-result.js","sourcesContent":["import MapGenerator from './map-generator';\nimport stringify    from './stringify';\nimport warnOnce     from './warn-once';\nimport Result       from './result';\nimport parse        from './parse';\n\nfunction isPromise(obj) {\n    return typeof obj === 'object' && typeof obj.then === 'function';\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css);\n */\nclass LazyResult {\n\n    constructor(processor, css, opts) {\n        this.stringified = false;\n        this.processed   = false;\n\n        let root;\n        if ( typeof css === 'object' && css.type === 'root' ) {\n            root = css;\n        } else if ( css instanceof LazyResult || css instanceof Result ) {\n            root = css.root;\n            if ( css.map ) {\n                if ( typeof opts.map === 'undefined' ) opts.map = { };\n                if ( !opts.map.inline ) opts.map.inline = false;\n                opts.map.prev = css.map;\n            }\n        } else {\n            let parser = parse;\n            if ( opts.syntax )  parser = opts.syntax.parse;\n            if ( opts.parser )  parser = opts.parser;\n            if ( parser.parse ) parser = parser.parse;\n\n            try {\n                root = parser(css, opts);\n            } catch (error) {\n                this.error = error;\n            }\n        }\n\n        this.result = new Result(processor, root, opts);\n    }\n\n    /**\n     * Returns a {@link Processor} instance, which will be used\n     * for CSS transformations.\n     * @type {Processor}\n     */\n    get processor() {\n        return this.result.processor;\n    }\n\n    /**\n     * Options from the {@link Processor#process} call.\n     * @type {processOptions}\n     */\n    get opts() {\n        return this.result.opts;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins, converts `Root`\n     * to a CSS string and returns {@link Result#css}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#css\n     */\n    get css() {\n        return this.stringify().css;\n    }\n\n    /**\n     * An alias for the `css` property. Use it with syntaxes\n     * that generate non-CSS output.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#content\n     */\n    get content() {\n        return this.stringify().content;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#map}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {SourceMapGenerator}\n     * @see Result#map\n     */\n    get map() {\n        return this.stringify().map;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#root}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Root}\n     * @see Result#root\n     */\n    get root() {\n        return this.sync().root;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#messages}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Message[]}\n     * @see Result#messages\n     */\n    get messages() {\n        return this.sync().messages;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and calls {@link Result#warnings()}.\n     *\n     * @return {Warning[]} warnings from plugins\n     */\n    warnings() {\n        return this.sync().warnings();\n    }\n\n    /**\n     * Alias for the {@link LazyResult#css} property.\n     *\n     * @example\n     * lazy + '' === lazy.css;\n     *\n     * @return {string} output CSS\n     */\n    toString() {\n        return this.css;\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls `onFulfilled` with a Result instance. If a plugin throws\n     * an error, the `onRejected` callback will be executed.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onFulfilled} onFulfilled - callback will be executed\n     *                                    when all plugins will finish work\n     * @param {onRejected}  onRejected  - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css).then(result => {\n     *   console.log(result.css);\n     * });\n     */\n    then(onFulfilled, onRejected) {\n        return this.async().then(onFulfilled, onRejected);\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls onRejected for each error thrown in any plugin.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onRejected} onRejected - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css).then(result => {\n     *   console.log(result.css);\n     * }).catch(error => {\n     *   console.error(error);\n     * });\n     */\n    catch(onRejected) {\n        return this.async().catch(onRejected);\n    }\n\n    handleError(error, plugin) {\n        try {\n            this.error = error;\n            if ( error.name === 'CssSyntaxError' && !error.plugin ) {\n                error.plugin = plugin.postcssPlugin;\n                error.setMessage();\n            } else if ( plugin.postcssVersion ) {\n                let pluginName = plugin.postcssPlugin;\n                let pluginVer  = plugin.postcssVersion;\n                let runtimeVer = this.result.processor.version;\n                let a = pluginVer.split('.');\n                let b = runtimeVer.split('.');\n\n                if ( a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1]) ) {\n                    warnOnce('Your current PostCSS version ' +\n                             'is ' + runtimeVer + ', but ' + pluginName + ' ' +\n                             'uses ' + pluginVer + '. Perhaps this is ' +\n                             'the source of the error below.');\n                }\n            }\n        } catch (err) {\n            if ( console && console.error ) console.error(err);\n        }\n    }\n\n    asyncTick(resolve, reject) {\n        if ( this.plugin >= this.processor.plugins.length ) {\n            this.processed = true;\n            return resolve();\n        }\n\n        try {\n            let plugin  = this.processor.plugins[this.plugin];\n            let promise = this.run(plugin);\n            this.plugin += 1;\n\n            if ( isPromise(promise) ) {\n                promise.then( () => {\n                    this.asyncTick(resolve, reject);\n                }).catch( error => {\n                    this.handleError(error, plugin);\n                    this.processed = true;\n                    reject(error);\n                });\n            } else {\n                this.asyncTick(resolve, reject);\n            }\n\n        } catch (error) {\n            this.processed = true;\n            reject(error);\n        }\n    }\n\n    async() {\n        if ( this.processed ) {\n            return new Promise( (resolve, reject) => {\n                if ( this.error ) {\n                    reject(this.error);\n                } else {\n                    resolve(this.stringify());\n                }\n            });\n        }\n        if ( this.processing ) {\n            return this.processing;\n        }\n\n        this.processing = new Promise( (resolve, reject) => {\n            if ( this.error ) return reject(this.error);\n            this.plugin = 0;\n            this.asyncTick(resolve, reject);\n        }).then( () => {\n            this.processed = true;\n            return this.stringify();\n        });\n\n        return this.processing;\n    }\n\n    sync() {\n        if ( this.processed ) return this.result;\n        this.processed = true;\n\n        if ( this.processing ) {\n            throw new Error(\n                'Use process(css).then(cb) to work with async plugins');\n        }\n\n        if ( this.error ) throw this.error;\n\n        for ( let plugin of this.result.processor.plugins ) {\n            let promise = this.run(plugin);\n            if ( isPromise(promise) ) {\n                throw new Error(\n                    'Use process(css).then(cb) to work with async plugins');\n            }\n        }\n\n        return this.result;\n    }\n\n    run(plugin) {\n        this.result.lastPlugin = plugin;\n\n        try {\n            return plugin(this.result.root, this.result);\n        } catch (error) {\n            this.handleError(error, plugin);\n            throw error;\n        }\n    }\n\n    stringify() {\n        if ( this.stringified ) return this.result;\n        this.stringified = true;\n\n        this.sync();\n\n        let opts = this.result.opts;\n        let str  = stringify;\n        if ( opts.syntax )      str = opts.syntax.stringify;\n        if ( opts.stringifier ) str = opts.stringifier;\n        if ( str.stringify )    str = str.stringify;\n\n        let map  = new MapGenerator(str, this.result.root, this.result.opts);\n        let data = map.generate();\n        this.result.css = data[0];\n        this.result.map = data[1];\n\n        return this.result;\n    }\n\n}\n\nexport default LazyResult;\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"]} diff --git a/node_modules/postcss/lib/list.js b/node_modules/postcss/lib/list.js new file mode 100644 index 00000000..ac1e9d63 --- /dev/null +++ b/node_modules/postcss/lib/list.js @@ -0,0 +1,95 @@ +'use strict'; + +exports.__esModule = true; +/** + * Contains helpers for safely splitting lists of CSS values, + * preserving parentheses and quotes. + * + * @example + * const list = postcss.list; + * + * @namespace list + */ +var list = { + split: function split(string, separators, last) { + var array = []; + var current = ''; + var split = false; + + var func = 0; + var quote = false; + var escape = false; + + for (var i = 0; i < string.length; i++) { + var letter = string[i]; + + if (quote) { + if (escape) { + escape = false; + } else if (letter === '\\') { + escape = true; + } else if (letter === quote) { + quote = false; + } + } else if (letter === '"' || letter === '\'') { + quote = letter; + } else if (letter === '(') { + func += 1; + } else if (letter === ')') { + if (func > 0) func -= 1; + } else if (func === 0) { + if (separators.indexOf(letter) !== -1) split = true; + } + + if (split) { + if (current !== '') array.push(current.trim()); + current = ''; + split = false; + } else { + current += letter; + } + } + + if (last || current !== '') array.push(current.trim()); + return array; + }, + + + /** + * Safely splits space-separated values (such as those for `background`, + * `border-radius`, and other shorthand properties). + * + * @param {string} string - space-separated values + * + * @return {string[]} split values + * + * @example + * postcss.list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)'] + */ + space: function space(string) { + var spaces = [' ', '\n', '\t']; + return list.split(string, spaces); + }, + + + /** + * Safely splits comma-separated values (such as those for `transition-*` + * and `background` properties). + * + * @param {string} string - comma-separated values + * + * @return {string[]} split values + * + * @example + * postcss.list.comma('black, linear-gradient(white, black)') + * //=> ['black', 'linear-gradient(white, black)'] + */ + comma: function comma(string) { + var comma = ','; + return list.split(string, [comma], true); + } +}; + +exports.default = list; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/map-generator.js b/node_modules/postcss/lib/map-generator.js new file mode 100644 index 00000000..93c4029f --- /dev/null +++ b/node_modules/postcss/lib/map-generator.js @@ -0,0 +1,312 @@ +'use strict'; + +exports.__esModule = true; + +var _jsBase = require('js-base64'); + +var _sourceMap = require('source-map'); + +var _sourceMap2 = _interopRequireDefault(_sourceMap); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var MapGenerator = function () { + function MapGenerator(stringify, root, opts) { + _classCallCheck(this, MapGenerator); + + this.stringify = stringify; + this.mapOpts = opts.map || {}; + this.root = root; + this.opts = opts; + } + + MapGenerator.prototype.isMap = function isMap() { + if (typeof this.opts.map !== 'undefined') { + return !!this.opts.map; + } else { + return this.previous().length > 0; + } + }; + + MapGenerator.prototype.previous = function previous() { + var _this = this; + + if (!this.previousMaps) { + this.previousMaps = []; + this.root.walk(function (node) { + if (node.source && node.source.input.map) { + var map = node.source.input.map; + if (_this.previousMaps.indexOf(map) === -1) { + _this.previousMaps.push(map); + } + } + }); + } + + return this.previousMaps; + }; + + MapGenerator.prototype.isInline = function isInline() { + if (typeof this.mapOpts.inline !== 'undefined') { + return this.mapOpts.inline; + } + + var annotation = this.mapOpts.annotation; + if (typeof annotation !== 'undefined' && annotation !== true) { + return false; + } + + if (this.previous().length) { + return this.previous().some(function (i) { + return i.inline; + }); + } else { + return true; + } + }; + + MapGenerator.prototype.isSourcesContent = function isSourcesContent() { + if (typeof this.mapOpts.sourcesContent !== 'undefined') { + return this.mapOpts.sourcesContent; + } + if (this.previous().length) { + return this.previous().some(function (i) { + return i.withContent(); + }); + } else { + return true; + } + }; + + MapGenerator.prototype.clearAnnotation = function clearAnnotation() { + if (this.mapOpts.annotation === false) return; + + var node = void 0; + for (var i = this.root.nodes.length - 1; i >= 0; i--) { + node = this.root.nodes[i]; + if (node.type !== 'comment') continue; + if (node.text.indexOf('# sourceMappingURL=') === 0) { + this.root.removeChild(i); + } + } + }; + + MapGenerator.prototype.setSourcesContent = function setSourcesContent() { + var _this2 = this; + + var already = {}; + this.root.walk(function (node) { + if (node.source) { + var from = node.source.input.from; + if (from && !already[from]) { + already[from] = true; + var relative = _this2.relative(from); + _this2.map.setSourceContent(relative, node.source.input.css); + } + } + }); + }; + + MapGenerator.prototype.applyPrevMaps = function applyPrevMaps() { + for (var _iterator = this.previous(), _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 prev = _ref; + + var from = this.relative(prev.file); + var root = prev.root || _path2.default.dirname(prev.file); + var map = void 0; + + if (this.mapOpts.sourcesContent === false) { + map = new _sourceMap2.default.SourceMapConsumer(prev.text); + if (map.sourcesContent) { + map.sourcesContent = map.sourcesContent.map(function () { + return null; + }); + } + } else { + map = prev.consumer(); + } + + this.map.applySourceMap(map, from, this.relative(root)); + } + }; + + MapGenerator.prototype.isAnnotation = function isAnnotation() { + if (this.isInline()) { + return true; + } else if (typeof this.mapOpts.annotation !== 'undefined') { + return this.mapOpts.annotation; + } else if (this.previous().length) { + return this.previous().some(function (i) { + return i.annotation; + }); + } else { + return true; + } + }; + + MapGenerator.prototype.addAnnotation = function addAnnotation() { + var content = void 0; + + if (this.isInline()) { + content = 'data:application/json;base64,' + _jsBase.Base64.encode(this.map.toString()); + } else if (typeof this.mapOpts.annotation === 'string') { + content = this.mapOpts.annotation; + } else { + content = this.outputFile() + '.map'; + } + + var eol = '\n'; + if (this.css.indexOf('\r\n') !== -1) eol = '\r\n'; + + this.css += eol + '/*# sourceMappingURL=' + content + ' */'; + }; + + MapGenerator.prototype.outputFile = function outputFile() { + if (this.opts.to) { + return this.relative(this.opts.to); + } else if (this.opts.from) { + return this.relative(this.opts.from); + } else { + return 'to.css'; + } + }; + + MapGenerator.prototype.generateMap = function generateMap() { + this.generateString(); + if (this.isSourcesContent()) this.setSourcesContent(); + if (this.previous().length > 0) this.applyPrevMaps(); + if (this.isAnnotation()) this.addAnnotation(); + + if (this.isInline()) { + return [this.css]; + } else { + return [this.css, this.map]; + } + }; + + MapGenerator.prototype.relative = function relative(file) { + if (file.indexOf('<') === 0) return file; + if (/^\w+:\/\//.test(file)) return file; + + var from = this.opts.to ? _path2.default.dirname(this.opts.to) : '.'; + + if (typeof this.mapOpts.annotation === 'string') { + from = _path2.default.dirname(_path2.default.resolve(from, this.mapOpts.annotation)); + } + + file = _path2.default.relative(from, file); + if (_path2.default.sep === '\\') { + return file.replace(/\\/g, '/'); + } else { + return file; + } + }; + + MapGenerator.prototype.sourcePath = function sourcePath(node) { + if (this.mapOpts.from) { + return this.mapOpts.from; + } else { + return this.relative(node.source.input.from); + } + }; + + MapGenerator.prototype.generateString = function generateString() { + var _this3 = this; + + this.css = ''; + this.map = new _sourceMap2.default.SourceMapGenerator({ file: this.outputFile() }); + + var line = 1; + var column = 1; + + var lines = void 0, + last = void 0; + this.stringify(this.root, function (str, node, type) { + _this3.css += str; + + if (node && type !== 'end') { + if (node.source && node.source.start) { + _this3.map.addMapping({ + source: _this3.sourcePath(node), + generated: { line: line, column: column - 1 }, + original: { + line: node.source.start.line, + column: node.source.start.column - 1 + } + }); + } else { + _this3.map.addMapping({ + source: '<no source>', + original: { line: 1, column: 0 }, + generated: { line: line, column: column - 1 } + }); + } + } + + lines = str.match(/\n/g); + if (lines) { + line += lines.length; + last = str.lastIndexOf('\n'); + column = str.length - last; + } else { + column += str.length; + } + + if (node && type !== 'start') { + if (node.source && node.source.end) { + _this3.map.addMapping({ + source: _this3.sourcePath(node), + generated: { line: line, column: column - 1 }, + original: { + line: node.source.end.line, + column: node.source.end.column + } + }); + } else { + _this3.map.addMapping({ + source: '<no source>', + original: { line: 1, column: 0 }, + generated: { line: line, column: column - 1 } + }); + } + } + }); + }; + + MapGenerator.prototype.generate = function generate() { + this.clearAnnotation(); + + if (this.isMap()) { + return this.generateMap(); + } else { + var result = ''; + this.stringify(this.root, function (i) { + result += i; + }); + return [result]; + } + }; + + return MapGenerator; +}(); + +exports.default = MapGenerator; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["map-generator.es6"],"names":["MapGenerator","stringify","root","opts","mapOpts","map","isMap","previous","length","previousMaps","walk","node","source","input","indexOf","push","isInline","inline","annotation","some","i","isSourcesContent","sourcesContent","withContent","clearAnnotation","nodes","type","text","removeChild","setSourcesContent","already","from","relative","setSourceContent","css","applyPrevMaps","prev","file","dirname","SourceMapConsumer","consumer","applySourceMap","isAnnotation","addAnnotation","content","encode","toString","outputFile","eol","to","generateMap","generateString","test","resolve","sep","replace","sourcePath","SourceMapGenerator","line","column","lines","last","str","start","addMapping","generated","original","match","lastIndexOf","end","generate","result"],"mappings":";;;;AAAA;;AACA;;;;AACA;;;;;;;;IAEqBA,Y;AAEjB,0BAAYC,SAAZ,EAAuBC,IAAvB,EAA6BC,IAA7B,EAAmC;AAAA;;AAC/B,aAAKF,SAAL,GAAiBA,SAAjB;AACA,aAAKG,OAAL,GAAiBD,KAAKE,GAAL,IAAY,EAA7B;AACA,aAAKH,IAAL,GAAiBA,IAAjB;AACA,aAAKC,IAAL,GAAiBA,IAAjB;AACH;;2BAEDG,K,oBAAQ;AACJ,YAAK,OAAO,KAAKH,IAAL,CAAUE,GAAjB,KAAyB,WAA9B,EAA4C;AACxC,mBAAO,CAAC,CAAC,KAAKF,IAAL,CAAUE,GAAnB;AACH,SAFD,MAEO;AACH,mBAAO,KAAKE,QAAL,GAAgBC,MAAhB,GAAyB,CAAhC;AACH;AACJ,K;;2BAEDD,Q,uBAAW;AAAA;;AACP,YAAK,CAAC,KAAKE,YAAX,EAA0B;AACtB,iBAAKA,YAAL,GAAoB,EAApB;AACA,iBAAKP,IAAL,CAAUQ,IAAV,CAAgB,gBAAQ;AACpB,oBAAKC,KAAKC,MAAL,IAAeD,KAAKC,MAAL,CAAYC,KAAZ,CAAkBR,GAAtC,EAA4C;AACxC,wBAAIA,MAAMM,KAAKC,MAAL,CAAYC,KAAZ,CAAkBR,GAA5B;AACA,wBAAK,MAAKI,YAAL,CAAkBK,OAAlB,CAA0BT,GAA1B,MAAmC,CAAC,CAAzC,EAA6C;AACzC,8BAAKI,YAAL,CAAkBM,IAAlB,CAAuBV,GAAvB;AACH;AACJ;AACJ,aAPD;AAQH;;AAED,eAAO,KAAKI,YAAZ;AACH,K;;2BAEDO,Q,uBAAW;AACP,YAAK,OAAO,KAAKZ,OAAL,CAAaa,MAApB,KAA+B,WAApC,EAAkD;AAC9C,mBAAO,KAAKb,OAAL,CAAaa,MAApB;AACH;;AAED,YAAIC,aAAa,KAAKd,OAAL,CAAac,UAA9B;AACA,YAAK,OAAOA,UAAP,KAAsB,WAAtB,IAAqCA,eAAe,IAAzD,EAAgE;AAC5D,mBAAO,KAAP;AACH;;AAED,YAAK,KAAKX,QAAL,GAAgBC,MAArB,EAA8B;AAC1B,mBAAO,KAAKD,QAAL,GAAgBY,IAAhB,CAAsB;AAAA,uBAAKC,EAAEH,MAAP;AAAA,aAAtB,CAAP;AACH,SAFD,MAEO;AACH,mBAAO,IAAP;AACH;AACJ,K;;2BAEDI,gB,+BAAmB;AACf,YAAK,OAAO,KAAKjB,OAAL,CAAakB,cAApB,KAAuC,WAA5C,EAA0D;AACtD,mBAAO,KAAKlB,OAAL,CAAakB,cAApB;AACH;AACD,YAAK,KAAKf,QAAL,GAAgBC,MAArB,EAA8B;AAC1B,mBAAO,KAAKD,QAAL,GAAgBY,IAAhB,CAAsB;AAAA,uBAAKC,EAAEG,WAAF,EAAL;AAAA,aAAtB,CAAP;AACH,SAFD,MAEO;AACH,mBAAO,IAAP;AACH;AACJ,K;;2BAEDC,e,8BAAkB;AACd,YAAK,KAAKpB,OAAL,CAAac,UAAb,KAA4B,KAAjC,EAAyC;;AAEzC,YAAIP,aAAJ;AACA,aAAM,IAAIS,IAAI,KAAKlB,IAAL,CAAUuB,KAAV,CAAgBjB,MAAhB,GAAyB,CAAvC,EAA0CY,KAAK,CAA/C,EAAkDA,GAAlD,EAAwD;AACpDT,mBAAO,KAAKT,IAAL,CAAUuB,KAAV,CAAgBL,CAAhB,CAAP;AACA,gBAAKT,KAAKe,IAAL,KAAc,SAAnB,EAA+B;AAC/B,gBAAKf,KAAKgB,IAAL,CAAUb,OAAV,CAAkB,qBAAlB,MAA6C,CAAlD,EAAsD;AAClD,qBAAKZ,IAAL,CAAU0B,WAAV,CAAsBR,CAAtB;AACH;AACJ;AACJ,K;;2BAEDS,iB,gCAAoB;AAAA;;AAChB,YAAIC,UAAU,EAAd;AACA,aAAK5B,IAAL,CAAUQ,IAAV,CAAgB,gBAAQ;AACpB,gBAAKC,KAAKC,MAAV,EAAmB;AACf,oBAAImB,OAAOpB,KAAKC,MAAL,CAAYC,KAAZ,CAAkBkB,IAA7B;AACA,oBAAKA,QAAQ,CAACD,QAAQC,IAAR,CAAd,EAA8B;AAC1BD,4BAAQC,IAAR,IAAgB,IAAhB;AACA,wBAAIC,WAAW,OAAKA,QAAL,CAAcD,IAAd,CAAf;AACA,2BAAK1B,GAAL,CAAS4B,gBAAT,CAA0BD,QAA1B,EAAoCrB,KAAKC,MAAL,CAAYC,KAAZ,CAAkBqB,GAAtD;AACH;AACJ;AACJ,SATD;AAUH,K;;2BAEDC,a,4BAAgB;AACZ,6BAAkB,KAAK5B,QAAL,EAAlB,kHAAoC;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,gBAA1B6B,IAA0B;;AAChC,gBAAIL,OAAO,KAAKC,QAAL,CAAcI,KAAKC,IAAnB,CAAX;AACA,gBAAInC,OAAOkC,KAAKlC,IAAL,IAAa,eAAKoC,OAAL,CAAaF,KAAKC,IAAlB,CAAxB;AACA,gBAAIhC,YAAJ;;AAEA,gBAAK,KAAKD,OAAL,CAAakB,cAAb,KAAgC,KAArC,EAA6C;AACzCjB,sBAAM,IAAI,oBAAQkC,iBAAZ,CAA8BH,KAAKT,IAAnC,CAAN;AACA,oBAAKtB,IAAIiB,cAAT,EAA0B;AACtBjB,wBAAIiB,cAAJ,GAAqBjB,IAAIiB,cAAJ,CAAmBjB,GAAnB,CAAwB;AAAA,+BAAM,IAAN;AAAA,qBAAxB,CAArB;AACH;AACJ,aALD,MAKO;AACHA,sBAAM+B,KAAKI,QAAL,EAAN;AACH;;AAED,iBAAKnC,GAAL,CAASoC,cAAT,CAAwBpC,GAAxB,EAA6B0B,IAA7B,EAAmC,KAAKC,QAAL,CAAc9B,IAAd,CAAnC;AACH;AACJ,K;;2BAEDwC,Y,2BAAe;AACX,YAAK,KAAK1B,QAAL,EAAL,EAAuB;AACnB,mBAAO,IAAP;AACH,SAFD,MAEO,IAAK,OAAO,KAAKZ,OAAL,CAAac,UAApB,KAAmC,WAAxC,EAAsD;AACzD,mBAAO,KAAKd,OAAL,CAAac,UAApB;AACH,SAFM,MAEA,IAAK,KAAKX,QAAL,GAAgBC,MAArB,EAA8B;AACjC,mBAAO,KAAKD,QAAL,GAAgBY,IAAhB,CAAsB;AAAA,uBAAKC,EAAEF,UAAP;AAAA,aAAtB,CAAP;AACH,SAFM,MAEA;AACH,mBAAO,IAAP;AACH;AACJ,K;;2BAEDyB,a,4BAAgB;AACZ,YAAIC,gBAAJ;;AAEA,YAAK,KAAK5B,QAAL,EAAL,EAAuB;AACnB4B,sBAAU,kCACC,eAAOC,MAAP,CAAe,KAAKxC,GAAL,CAASyC,QAAT,EAAf,CADX;AAGH,SAJD,MAIO,IAAK,OAAO,KAAK1C,OAAL,CAAac,UAApB,KAAmC,QAAxC,EAAmD;AACtD0B,sBAAU,KAAKxC,OAAL,CAAac,UAAvB;AAEH,SAHM,MAGA;AACH0B,sBAAU,KAAKG,UAAL,KAAoB,MAA9B;AACH;;AAED,YAAIC,MAAQ,IAAZ;AACA,YAAK,KAAKd,GAAL,CAASpB,OAAT,CAAiB,MAAjB,MAA6B,CAAC,CAAnC,EAAuCkC,MAAM,MAAN;;AAEvC,aAAKd,GAAL,IAAYc,MAAM,uBAAN,GAAgCJ,OAAhC,GAA0C,KAAtD;AACH,K;;2BAEDG,U,yBAAa;AACT,YAAK,KAAK5C,IAAL,CAAU8C,EAAf,EAAoB;AAChB,mBAAO,KAAKjB,QAAL,CAAc,KAAK7B,IAAL,CAAU8C,EAAxB,CAAP;AACH,SAFD,MAEO,IAAK,KAAK9C,IAAL,CAAU4B,IAAf,EAAsB;AACzB,mBAAO,KAAKC,QAAL,CAAc,KAAK7B,IAAL,CAAU4B,IAAxB,CAAP;AACH,SAFM,MAEA;AACH,mBAAO,QAAP;AACH;AACJ,K;;2BAEDmB,W,0BAAc;AACV,aAAKC,cAAL;AACA,YAAK,KAAK9B,gBAAL,EAAL,EAAkC,KAAKQ,iBAAL;AAClC,YAAK,KAAKtB,QAAL,GAAgBC,MAAhB,GAAyB,CAA9B,EAAkC,KAAK2B,aAAL;AAClC,YAAK,KAAKO,YAAL,EAAL,EAAkC,KAAKC,aAAL;;AAElC,YAAK,KAAK3B,QAAL,EAAL,EAAuB;AACnB,mBAAO,CAAC,KAAKkB,GAAN,CAAP;AACH,SAFD,MAEO;AACH,mBAAO,CAAC,KAAKA,GAAN,EAAW,KAAK7B,GAAhB,CAAP;AACH;AACJ,K;;2BAED2B,Q,qBAASK,I,EAAM;AACX,YAAKA,KAAKvB,OAAL,CAAa,GAAb,MAAsB,CAA3B,EAA+B,OAAOuB,IAAP;AAC/B,YAAK,YAAYe,IAAZ,CAAiBf,IAAjB,CAAL,EAA8B,OAAOA,IAAP;;AAE9B,YAAIN,OAAO,KAAK5B,IAAL,CAAU8C,EAAV,GAAe,eAAKX,OAAL,CAAa,KAAKnC,IAAL,CAAU8C,EAAvB,CAAf,GAA4C,GAAvD;;AAEA,YAAK,OAAO,KAAK7C,OAAL,CAAac,UAApB,KAAmC,QAAxC,EAAmD;AAC/Ca,mBAAO,eAAKO,OAAL,CAAc,eAAKe,OAAL,CAAatB,IAAb,EAAmB,KAAK3B,OAAL,CAAac,UAAhC,CAAd,CAAP;AACH;;AAEDmB,eAAO,eAAKL,QAAL,CAAcD,IAAd,EAAoBM,IAApB,CAAP;AACA,YAAK,eAAKiB,GAAL,KAAa,IAAlB,EAAyB;AACrB,mBAAOjB,KAAKkB,OAAL,CAAa,KAAb,EAAoB,GAApB,CAAP;AACH,SAFD,MAEO;AACH,mBAAOlB,IAAP;AACH;AACJ,K;;2BAEDmB,U,uBAAW7C,I,EAAM;AACb,YAAK,KAAKP,OAAL,CAAa2B,IAAlB,EAAyB;AACrB,mBAAO,KAAK3B,OAAL,CAAa2B,IAApB;AACH,SAFD,MAEO;AACH,mBAAO,KAAKC,QAAL,CAAcrB,KAAKC,MAAL,CAAYC,KAAZ,CAAkBkB,IAAhC,CAAP;AACH;AACJ,K;;2BAEDoB,c,6BAAiB;AAAA;;AACb,aAAKjB,GAAL,GAAW,EAAX;AACA,aAAK7B,GAAL,GAAW,IAAI,oBAAQoD,kBAAZ,CAA+B,EAAEpB,MAAM,KAAKU,UAAL,EAAR,EAA/B,CAAX;;AAEA,YAAIW,OAAS,CAAb;AACA,YAAIC,SAAS,CAAb;;AAEA,YAAIC,cAAJ;AAAA,YAAWC,aAAX;AACA,aAAK5D,SAAL,CAAe,KAAKC,IAApB,EAA0B,UAAC4D,GAAD,EAAMnD,IAAN,EAAYe,IAAZ,EAAqB;AAC3C,mBAAKQ,GAAL,IAAY4B,GAAZ;;AAEA,gBAAKnD,QAAQe,SAAS,KAAtB,EAA8B;AAC1B,oBAAKf,KAAKC,MAAL,IAAeD,KAAKC,MAAL,CAAYmD,KAAhC,EAAwC;AACpC,2BAAK1D,GAAL,CAAS2D,UAAT,CAAoB;AAChBpD,gCAAW,OAAK4C,UAAL,CAAgB7C,IAAhB,CADK;AAEhBsD,mCAAW,EAAEP,UAAF,EAAQC,QAAQA,SAAS,CAAzB,EAFK;AAGhBO,kCAAW;AACPR,kCAAQ/C,KAAKC,MAAL,CAAYmD,KAAZ,CAAkBL,IADnB;AAEPC,oCAAQhD,KAAKC,MAAL,CAAYmD,KAAZ,CAAkBJ,MAAlB,GAA2B;AAF5B;AAHK,qBAApB;AAQH,iBATD,MASO;AACH,2BAAKtD,GAAL,CAAS2D,UAAT,CAAoB;AAChBpD,gCAAW,aADK;AAEhBsD,kCAAW,EAAER,MAAM,CAAR,EAAWC,QAAQ,CAAnB,EAFK;AAGhBM,mCAAW,EAAEP,UAAF,EAAQC,QAAQA,SAAS,CAAzB;AAHK,qBAApB;AAKH;AACJ;;AAEDC,oBAAQE,IAAIK,KAAJ,CAAU,KAAV,CAAR;AACA,gBAAKP,KAAL,EAAa;AACTF,wBAASE,MAAMpD,MAAf;AACAqD,uBAASC,IAAIM,WAAJ,CAAgB,IAAhB,CAAT;AACAT,yBAASG,IAAItD,MAAJ,GAAaqD,IAAtB;AACH,aAJD,MAIO;AACHF,0BAAUG,IAAItD,MAAd;AACH;;AAED,gBAAKG,QAAQe,SAAS,OAAtB,EAAgC;AAC5B,oBAAKf,KAAKC,MAAL,IAAeD,KAAKC,MAAL,CAAYyD,GAAhC,EAAsC;AAClC,2BAAKhE,GAAL,CAAS2D,UAAT,CAAoB;AAChBpD,gCAAW,OAAK4C,UAAL,CAAgB7C,IAAhB,CADK;AAEhBsD,mCAAW,EAAEP,UAAF,EAAQC,QAAQA,SAAS,CAAzB,EAFK;AAGhBO,kCAAW;AACPR,kCAAQ/C,KAAKC,MAAL,CAAYyD,GAAZ,CAAgBX,IADjB;AAEPC,oCAAQhD,KAAKC,MAAL,CAAYyD,GAAZ,CAAgBV;AAFjB;AAHK,qBAApB;AAQH,iBATD,MASO;AACH,2BAAKtD,GAAL,CAAS2D,UAAT,CAAoB;AAChBpD,gCAAW,aADK;AAEhBsD,kCAAW,EAAER,MAAM,CAAR,EAAWC,QAAQ,CAAnB,EAFK;AAGhBM,mCAAW,EAAEP,UAAF,EAAQC,QAAQA,SAAS,CAAzB;AAHK,qBAApB;AAKH;AACJ;AACJ,SAjDD;AAkDH,K;;2BAEDW,Q,uBAAW;AACP,aAAK9C,eAAL;;AAEA,YAAK,KAAKlB,KAAL,EAAL,EAAoB;AAChB,mBAAO,KAAK4C,WAAL,EAAP;AACH,SAFD,MAEO;AACH,gBAAIqB,SAAS,EAAb;AACA,iBAAKtE,SAAL,CAAe,KAAKC,IAApB,EAA0B,aAAK;AAC3BqE,0BAAUnD,CAAV;AACH,aAFD;AAGA,mBAAO,CAACmD,MAAD,CAAP;AACH;AACJ,K;;;;;kBApQgBvE,Y","file":"map-generator.js","sourcesContent":["import { Base64 } from 'js-base64';\nimport   mozilla  from 'source-map';\nimport   path     from 'path';\n\nexport default class MapGenerator {\n\n    constructor(stringify, root, opts) {\n        this.stringify = stringify;\n        this.mapOpts   = opts.map || { };\n        this.root      = root;\n        this.opts      = opts;\n    }\n\n    isMap() {\n        if ( typeof this.opts.map !== 'undefined' ) {\n            return !!this.opts.map;\n        } else {\n            return this.previous().length > 0;\n        }\n    }\n\n    previous() {\n        if ( !this.previousMaps ) {\n            this.previousMaps = [];\n            this.root.walk( node => {\n                if ( node.source && node.source.input.map ) {\n                    let map = node.source.input.map;\n                    if ( this.previousMaps.indexOf(map) === -1 ) {\n                        this.previousMaps.push(map);\n                    }\n                }\n            });\n        }\n\n        return this.previousMaps;\n    }\n\n    isInline() {\n        if ( typeof this.mapOpts.inline !== 'undefined' ) {\n            return this.mapOpts.inline;\n        }\n\n        let annotation = this.mapOpts.annotation;\n        if ( typeof annotation !== 'undefined' && annotation !== true ) {\n            return false;\n        }\n\n        if ( this.previous().length ) {\n            return this.previous().some( i => i.inline );\n        } else {\n            return true;\n        }\n    }\n\n    isSourcesContent() {\n        if ( typeof this.mapOpts.sourcesContent !== 'undefined' ) {\n            return this.mapOpts.sourcesContent;\n        }\n        if ( this.previous().length ) {\n            return this.previous().some( i => i.withContent() );\n        } else {\n            return true;\n        }\n    }\n\n    clearAnnotation() {\n        if ( this.mapOpts.annotation === false ) return;\n\n        let node;\n        for ( let i = this.root.nodes.length - 1; i >= 0; i-- ) {\n            node = this.root.nodes[i];\n            if ( node.type !== 'comment' ) continue;\n            if ( node.text.indexOf('# sourceMappingURL=') === 0 ) {\n                this.root.removeChild(i);\n            }\n        }\n    }\n\n    setSourcesContent() {\n        let already = { };\n        this.root.walk( node => {\n            if ( node.source ) {\n                let from = node.source.input.from;\n                if ( from && !already[from] ) {\n                    already[from] = true;\n                    let relative = this.relative(from);\n                    this.map.setSourceContent(relative, node.source.input.css);\n                }\n            }\n        });\n    }\n\n    applyPrevMaps() {\n        for ( let prev of this.previous() ) {\n            let from = this.relative(prev.file);\n            let root = prev.root || path.dirname(prev.file);\n            let map;\n\n            if ( this.mapOpts.sourcesContent === false ) {\n                map = new mozilla.SourceMapConsumer(prev.text);\n                if ( map.sourcesContent ) {\n                    map.sourcesContent = map.sourcesContent.map( () => null );\n                }\n            } else {\n                map = prev.consumer();\n            }\n\n            this.map.applySourceMap(map, from, this.relative(root));\n        }\n    }\n\n    isAnnotation() {\n        if ( this.isInline() ) {\n            return true;\n        } else if ( typeof this.mapOpts.annotation !== 'undefined' ) {\n            return this.mapOpts.annotation;\n        } else if ( this.previous().length ) {\n            return this.previous().some( i => i.annotation );\n        } else {\n            return true;\n        }\n    }\n\n    addAnnotation() {\n        let content;\n\n        if ( this.isInline() ) {\n            content = 'data:application/json;base64,' +\n                       Base64.encode( this.map.toString() );\n\n        } else if ( typeof this.mapOpts.annotation === 'string' ) {\n            content = this.mapOpts.annotation;\n\n        } else {\n            content = this.outputFile() + '.map';\n        }\n\n        let eol   = '\\n';\n        if ( this.css.indexOf('\\r\\n') !== -1 ) eol = '\\r\\n';\n\n        this.css += eol + '/*# sourceMappingURL=' + content + ' */';\n    }\n\n    outputFile() {\n        if ( this.opts.to ) {\n            return this.relative(this.opts.to);\n        } else if ( this.opts.from ) {\n            return this.relative(this.opts.from);\n        } else {\n            return 'to.css';\n        }\n    }\n\n    generateMap() {\n        this.generateString();\n        if ( this.isSourcesContent() )    this.setSourcesContent();\n        if ( this.previous().length > 0 ) this.applyPrevMaps();\n        if ( this.isAnnotation() )        this.addAnnotation();\n\n        if ( this.isInline() ) {\n            return [this.css];\n        } else {\n            return [this.css, this.map];\n        }\n    }\n\n    relative(file) {\n        if ( file.indexOf('<') === 0 ) return file;\n        if ( /^\\w+:\\/\\//.test(file) ) return file;\n\n        let from = this.opts.to ? path.dirname(this.opts.to) : '.';\n\n        if ( typeof this.mapOpts.annotation === 'string' ) {\n            from = path.dirname( path.resolve(from, this.mapOpts.annotation) );\n        }\n\n        file = path.relative(from, file);\n        if ( path.sep === '\\\\' ) {\n            return file.replace(/\\\\/g, '/');\n        } else {\n            return file;\n        }\n    }\n\n    sourcePath(node) {\n        if ( this.mapOpts.from ) {\n            return this.mapOpts.from;\n        } else {\n            return this.relative(node.source.input.from);\n        }\n    }\n\n    generateString() {\n        this.css = '';\n        this.map = new mozilla.SourceMapGenerator({ file: this.outputFile() });\n\n        let line   = 1;\n        let column = 1;\n\n        let lines, last;\n        this.stringify(this.root, (str, node, type) => {\n            this.css += str;\n\n            if ( node && type !== 'end' ) {\n                if ( node.source && node.source.start ) {\n                    this.map.addMapping({\n                        source:    this.sourcePath(node),\n                        generated: { line, column: column - 1 },\n                        original:  {\n                            line:   node.source.start.line,\n                            column: node.source.start.column - 1\n                        }\n                    });\n                } else {\n                    this.map.addMapping({\n                        source:    '<no source>',\n                        original:  { line: 1, column: 0 },\n                        generated: { line, column: column - 1 }\n                    });\n                }\n            }\n\n            lines = str.match(/\\n/g);\n            if ( lines ) {\n                line  += lines.length;\n                last   = str.lastIndexOf('\\n');\n                column = str.length - last;\n            } else {\n                column += str.length;\n            }\n\n            if ( node && type !== 'start' ) {\n                if ( node.source && node.source.end ) {\n                    this.map.addMapping({\n                        source:    this.sourcePath(node),\n                        generated: { line, column: column - 1 },\n                        original:  {\n                            line:   node.source.end.line,\n                            column: node.source.end.column\n                        }\n                    });\n                } else {\n                    this.map.addMapping({\n                        source:    '<no source>',\n                        original:  { line: 1, column: 0 },\n                        generated: { line, column: column - 1 }\n                    });\n                }\n            }\n        });\n    }\n\n    generate() {\n        this.clearAnnotation();\n\n        if ( this.isMap() ) {\n            return this.generateMap();\n        } else {\n            let result = '';\n            this.stringify(this.root, i => {\n                result += i;\n            });\n            return [result];\n        }\n    }\n\n}\n"]} diff --git a/node_modules/postcss/lib/node.js b/node_modules/postcss/lib/node.js new file mode 100644 index 00000000..e217a7d5 --- /dev/null +++ b/node_modules/postcss/lib/node.js @@ -0,0 +1,672 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _cssSyntaxError = require('./css-syntax-error'); + +var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError); + +var _stringifier = require('./stringifier'); + +var _stringifier2 = _interopRequireDefault(_stringifier); + +var _stringify = require('./stringify'); + +var _stringify2 = _interopRequireDefault(_stringify); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var cloneNode = function cloneNode(obj, parent) { + var cloned = new obj.constructor(); + + for (var i in obj) { + if (!obj.hasOwnProperty(i)) continue; + var value = obj[i]; + var type = typeof value === 'undefined' ? 'undefined' : _typeof(value); + + if (i === 'parent' && type === 'object') { + if (parent) cloned[i] = parent; + } else if (i === 'source') { + cloned[i] = value; + } else if (value instanceof Array) { + cloned[i] = value.map(function (j) { + return cloneNode(j, cloned); + }); + } else if (i !== 'before' && i !== 'after' && i !== 'between' && i !== 'semicolon') { + if (type === 'object' && value !== null) value = cloneNode(value); + cloned[i] = value; + } + } + + return cloned; +}; + +/** + * All node classes inherit the following common methods. + * + * @abstract + */ + +var Node = function () { + + /** + * @param {object} [defaults] - value for node properties + */ + function Node() { + var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, Node); + + this.raws = {}; + if ((typeof defaults === 'undefined' ? 'undefined' : _typeof(defaults)) !== 'object' && typeof defaults !== 'undefined') { + throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults)); + } + for (var name in defaults) { + this[name] = defaults[name]; + } + } + + /** + * Returns a CssSyntaxError instance containing the original position + * of the node in the source, showing line and column numbers and also + * a small excerpt to facilitate debugging. + * + * If present, an input source map will be used to get the original position + * of the source, even from a previous compilation step + * (e.g., from Sass compilation). + * + * This method produces very useful error messages. + * + * @param {string} message - error description + * @param {object} [opts] - options + * @param {string} opts.plugin - plugin name that created this error. + * PostCSS will set it automatically. + * @param {string} opts.word - a word inside a node’s string that should + * be highlighted as the source of the error + * @param {number} opts.index - an index inside a node’s string that should + * be highlighted as the source of the error + * + * @return {CssSyntaxError} error object to throw it + * + * @example + * if ( !variables[name] ) { + * throw decl.error('Unknown variable ' + name, { word: name }); + * // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black + * // color: $black + * // a + * // ^ + * // background: white + * } + */ + + + Node.prototype.error = function error(message) { + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (this.source) { + var pos = this.positionBy(opts); + return this.source.input.error(message, pos.line, pos.column, opts); + } else { + return new _cssSyntaxError2.default(message); + } + }; + + /** + * This method is provided as a convenience wrapper for {@link Result#warn}. + * + * @param {Result} result - the {@link Result} instance + * that will receive the warning + * @param {string} text - warning message + * @param {object} [opts] - options + * @param {string} opts.plugin - plugin name that created this warning. + * PostCSS will set it automatically. + * @param {string} opts.word - a word inside a node’s string that should + * be highlighted as the source of the warning + * @param {number} opts.index - an index inside a node’s string that should + * be highlighted as the source of the warning + * + * @return {Warning} created warning object + * + * @example + * const plugin = postcss.plugin('postcss-deprecated', () => { + * return (root, result) => { + * root.walkDecls('bad', decl => { + * decl.warn(result, 'Deprecated property bad'); + * }); + * }; + * }); + */ + + + Node.prototype.warn = function warn(result, text, opts) { + var data = { node: this }; + for (var i in opts) { + data[i] = opts[i]; + }return result.warn(text, data); + }; + + /** + * Removes the node from its parent and cleans the parent properties + * from the node and its children. + * + * @example + * if ( decl.prop.match(/^-webkit-/) ) { + * decl.remove(); + * } + * + * @return {Node} node to make calls chain + */ + + + Node.prototype.remove = function remove() { + if (this.parent) { + this.parent.removeChild(this); + } + this.parent = undefined; + return this; + }; + + /** + * Returns a CSS string representing the node. + * + * @param {stringifier|syntax} [stringifier] - a syntax to use + * in string generation + * + * @return {string} CSS string of this node + * + * @example + * postcss.rule({ selector: 'a' }).toString() //=> "a {}" + */ + + + Node.prototype.toString = function toString() { + var stringifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _stringify2.default; + + if (stringifier.stringify) stringifier = stringifier.stringify; + var result = ''; + stringifier(this, function (i) { + result += i; + }); + return result; + }; + + /** + * Returns a clone of the node. + * + * The resulting cloned node and its (cloned) children will have + * a clean parent and code style properties. + * + * @param {object} [overrides] - new properties to override in the clone. + * + * @example + * const cloned = decl.clone({ prop: '-moz-' + decl.prop }); + * cloned.raws.before //=> undefined + * cloned.parent //=> undefined + * cloned.toString() //=> -moz-transform: scale(0) + * + * @return {Node} clone of the node + */ + + + Node.prototype.clone = function clone() { + var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var cloned = cloneNode(this); + for (var name in overrides) { + cloned[name] = overrides[name]; + } + return cloned; + }; + + /** + * Shortcut to clone the node and insert the resulting cloned node + * before the current node. + * + * @param {object} [overrides] - new properties to override in the clone. + * + * @example + * decl.cloneBefore({ prop: '-moz-' + decl.prop }); + * + * @return {Node} - new node + */ + + + Node.prototype.cloneBefore = function cloneBefore() { + var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var cloned = this.clone(overrides); + this.parent.insertBefore(this, cloned); + return cloned; + }; + + /** + * Shortcut to clone the node and insert the resulting cloned node + * after the current node. + * + * @param {object} [overrides] - new properties to override in the clone. + * + * @return {Node} - new node + */ + + + Node.prototype.cloneAfter = function cloneAfter() { + var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var cloned = this.clone(overrides); + this.parent.insertAfter(this, cloned); + return cloned; + }; + + /** + * Inserts node(s) before the current node and removes the current node. + * + * @param {...Node} nodes - node(s) to replace current one + * + * @example + * if ( atrule.name == 'mixin' ) { + * atrule.replaceWith(mixinRules[atrule.params]); + * } + * + * @return {Node} current node to methods chain + */ + + + Node.prototype.replaceWith = function replaceWith() { + if (this.parent) { + for (var _len = arguments.length, nodes = Array(_len), _key = 0; _key < _len; _key++) { + nodes[_key] = arguments[_key]; + } + + for (var _iterator = 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; + + this.parent.insertBefore(this, node); + } + + this.remove(); + } + + return this; + }; + + /** + * Removes the node from its current parent and inserts it + * at the end of `newParent`. + * + * This will clean the `before` and `after` code {@link Node#raws} data + * from the node and replace them with the indentation style of `newParent`. + * It will also clean the `between` property + * if `newParent` is in another {@link Root}. + * + * @param {Container} newParent - container node where the current node + * will be moved + * + * @example + * atrule.moveTo(atrule.root()); + * + * @return {Node} current node to methods chain + */ + + + Node.prototype.moveTo = function moveTo(newParent) { + this.cleanRaws(this.root() === newParent.root()); + this.remove(); + newParent.append(this); + return this; + }; + + /** + * Removes the node from its current parent and inserts it into + * a new parent before `otherNode`. + * + * This will also clean the node’s code style properties just as it would + * in {@link Node#moveTo}. + * + * @param {Node} otherNode - node that will be before current node + * + * @return {Node} current node to methods chain + */ + + + Node.prototype.moveBefore = function moveBefore(otherNode) { + this.cleanRaws(this.root() === otherNode.root()); + this.remove(); + otherNode.parent.insertBefore(otherNode, this); + return this; + }; + + /** + * Removes the node from its current parent and inserts it into + * a new parent after `otherNode`. + * + * This will also clean the node’s code style properties just as it would + * in {@link Node#moveTo}. + * + * @param {Node} otherNode - node that will be after current node + * + * @return {Node} current node to methods chain + */ + + + Node.prototype.moveAfter = function moveAfter(otherNode) { + this.cleanRaws(this.root() === otherNode.root()); + this.remove(); + otherNode.parent.insertAfter(otherNode, this); + return this; + }; + + /** + * Returns the next child of the node’s parent. + * Returns `undefined` if the current node is the last child. + * + * @return {Node|undefined} next node + * + * @example + * if ( comment.text === 'delete next' ) { + * const next = comment.next(); + * if ( next ) { + * next.remove(); + * } + * } + */ + + + Node.prototype.next = function next() { + var index = this.parent.index(this); + return this.parent.nodes[index + 1]; + }; + + /** + * Returns the previous child of the node’s parent. + * Returns `undefined` if the current node is the first child. + * + * @return {Node|undefined} previous node + * + * @example + * const annotation = decl.prev(); + * if ( annotation.type == 'comment' ) { + * readAnnotation(annotation.text); + * } + */ + + + Node.prototype.prev = function prev() { + var index = this.parent.index(this); + return this.parent.nodes[index - 1]; + }; + + Node.prototype.toJSON = function toJSON() { + var fixed = {}; + + for (var name in this) { + if (!this.hasOwnProperty(name)) continue; + if (name === 'parent') continue; + var value = this[name]; + + if (value instanceof Array) { + fixed[name] = value.map(function (i) { + if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && i.toJSON) { + return i.toJSON(); + } else { + return i; + } + }); + } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.toJSON) { + fixed[name] = value.toJSON(); + } else { + fixed[name] = value; + } + } + + return fixed; + }; + + /** + * Returns a {@link Node#raws} value. If the node is missing + * the code style property (because the node was manually built or cloned), + * PostCSS will try to autodetect the code style property by looking + * at other nodes in the tree. + * + * @param {string} prop - name of code style property + * @param {string} [defaultType] - name of default value, it can be missed + * if the value is the same as prop + * + * @example + * const root = postcss.parse('a { background: white }'); + * root.nodes[0].append({ prop: 'color', value: 'black' }); + * root.nodes[0].nodes[1].raws.before //=> undefined + * root.nodes[0].nodes[1].raw('before') //=> ' ' + * + * @return {string} code style value + */ + + + Node.prototype.raw = function raw(prop, defaultType) { + var str = new _stringifier2.default(); + return str.raw(this, prop, defaultType); + }; + + /** + * Finds the Root instance of the node’s tree. + * + * @example + * root.nodes[0].nodes[0].root() === root + * + * @return {Root} root parent + */ + + + Node.prototype.root = function root() { + var result = this; + while (result.parent) { + result = result.parent; + }return result; + }; + + Node.prototype.cleanRaws = function cleanRaws(keepBetween) { + delete this.raws.before; + delete this.raws.after; + if (!keepBetween) delete this.raws.between; + }; + + Node.prototype.positionInside = function positionInside(index) { + var string = this.toString(); + var column = this.source.start.column; + var line = this.source.start.line; + + for (var i = 0; i < index; i++) { + if (string[i] === '\n') { + column = 1; + line += 1; + } else { + column += 1; + } + } + + return { line: line, column: column }; + }; + + Node.prototype.positionBy = function positionBy(opts) { + var pos = this.source.start; + if (opts.index) { + pos = this.positionInside(opts.index); + } else if (opts.word) { + var index = this.toString().indexOf(opts.word); + if (index !== -1) pos = this.positionInside(index); + } + return pos; + }; + + Node.prototype.removeSelf = function removeSelf() { + (0, _warnOnce2.default)('Node#removeSelf is deprecated. Use Node#remove.'); + return this.remove(); + }; + + Node.prototype.replace = function replace(nodes) { + (0, _warnOnce2.default)('Node#replace is deprecated. Use Node#replaceWith'); + return this.replaceWith(nodes); + }; + + Node.prototype.style = function style(own, detect) { + (0, _warnOnce2.default)('Node#style() is deprecated. Use Node#raw()'); + return this.raw(own, detect); + }; + + Node.prototype.cleanStyles = function cleanStyles(keepBetween) { + (0, _warnOnce2.default)('Node#cleanStyles() is deprecated. Use Node#cleanRaws()'); + return this.cleanRaws(keepBetween); + }; + + _createClass(Node, [{ + key: 'before', + get: function get() { + (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before'); + return this.raws.before; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before'); + this.raws.before = val; + } + }, { + key: 'between', + get: function get() { + (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between'); + return this.raws.between; + }, + set: function set(val) { + (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between'); + this.raws.between = val; + } + + /** + * @memberof Node# + * @member {string} type - String representing the node’s type. + * Possible values are `root`, `atrule`, `rule`, + * `decl`, or `comment`. + * + * @example + * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl' + */ + + /** + * @memberof Node# + * @member {Container} parent - the node’s parent node. + * + * @example + * root.nodes[0].parent == root; + */ + + /** + * @memberof Node# + * @member {source} source - the input source of the node + * + * The property is used in source map generation. + * + * If you create a node manually (e.g., with `postcss.decl()`), + * that node will not have a `source` property and will be absent + * from the source map. For this reason, the plugin developer should + * consider cloning nodes to create new ones (in which case the new node’s + * source will reference the original, cloned node) or setting + * the `source` property manually. + * + * ```js + * // Bad + * const prefixed = postcss.decl({ + * prop: '-moz-' + decl.prop, + * value: decl.value + * }); + * + * // Good + * const prefixed = decl.clone({ prop: '-moz-' + decl.prop }); + * ``` + * + * ```js + * if ( atrule.name == 'add-link' ) { + * const rule = postcss.rule({ selector: 'a', source: atrule.source }); + * atrule.parent.insertBefore(atrule, rule); + * } + * ``` + * + * @example + * decl.source.input.from //=> '/home/ai/a.sass' + * decl.source.start //=> { line: 10, column: 2 } + * decl.source.end //=> { line: 10, column: 12 } + */ + + /** + * @memberof Node# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * * `afterName`: the space between the at-rule name and its parameters. + * * `left`: the space symbols between `/*` and the comment’s text. + * * `right`: the space symbols between the comment’s text + * and <code>*/</code>. + * * `important`: the content of the important statement, + * if it is not just `!important`. + * + * PostCSS cleans selectors, declaration values and at-rule parameters + * from comments and extra spaces, but it stores origin content in raws + * properties. As such, if you don’t change a declaration’s value, + * PostCSS will use the raw value with comments. + * + * @example + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '\n ', between: ':' } + */ + + }]); + + return Node; +}(); + +exports.default = Node; + +/** + * @typedef {object} position + * @property {number} line - source line in file + * @property {number} column - source column in file + */ + +/** + * @typedef {object} source + * @property {Input} input - {@link Input} with input file + * @property {position} start - The starting position of the node’s source + * @property {position} end - The ending position of the node’s source + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["node.es6"],"names":["cloneNode","obj","parent","cloned","constructor","i","hasOwnProperty","value","type","Array","map","j","Node","defaults","raws","Error","JSON","stringify","name","error","message","opts","source","pos","positionBy","input","line","column","warn","result","text","data","node","remove","removeChild","undefined","toString","stringifier","clone","overrides","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","nodes","moveTo","newParent","cleanRaws","root","append","moveBefore","otherNode","moveAfter","next","index","prev","toJSON","fixed","raw","prop","defaultType","str","keepBetween","before","after","between","positionInside","string","start","word","indexOf","removeSelf","replace","style","own","detect","cleanStyles","val"],"mappings":"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","file":"node.js","sourcesContent":["import CssSyntaxError from './css-syntax-error';\nimport Stringifier    from './stringifier';\nimport stringify      from './stringify';\nimport warnOnce       from './warn-once';\n\nlet cloneNode = function (obj, parent) {\n    let cloned = new obj.constructor();\n\n    for ( let i in obj ) {\n        if ( !obj.hasOwnProperty(i) ) continue;\n        let value = obj[i];\n        let type  = typeof value;\n\n        if ( i === 'parent' && type === 'object' ) {\n            if (parent) cloned[i] = parent;\n        } else if ( i === 'source' ) {\n            cloned[i] = value;\n        } else if ( value instanceof Array ) {\n            cloned[i] = value.map( j => cloneNode(j, cloned) );\n        } else if ( i !== 'before'  && i !== 'after' &&\n                    i !== 'between' && i !== 'semicolon' ) {\n            if ( type === 'object' && value !== null ) value = cloneNode(value);\n            cloned[i] = value;\n        }\n    }\n\n    return cloned;\n};\n\n/**\n * All node classes inherit the following common methods.\n *\n * @abstract\n */\nclass Node {\n\n    /**\n     * @param {object} [defaults] - value for node properties\n     */\n    constructor(defaults = { }) {\n        this.raws = { };\n        if ( typeof defaults !== 'object' && typeof defaults !== 'undefined' ) {\n            throw new Error(\n                'PostCSS nodes constructor accepts object, not ' +\n                JSON.stringify(defaults));\n        }\n        for ( let name in defaults ) {\n            this[name] = defaults[name];\n        }\n    }\n\n    /**\n     * Returns a CssSyntaxError instance containing the original position\n     * of the node in the source, showing line and column numbers and also\n     * a small excerpt to facilitate debugging.\n     *\n     * If present, an input source map will be used to get the original position\n     * of the source, even from a previous compilation step\n     * (e.g., from Sass compilation).\n     *\n     * This method produces very useful error messages.\n     *\n     * @param {string} message     - error description\n     * @param {object} [opts]      - options\n     * @param {string} opts.plugin - plugin name that created this error.\n     *                               PostCSS will set it automatically.\n     * @param {string} opts.word   - a word inside a node’s string that should\n     *                               be highlighted as the source of the error\n     * @param {number} opts.index  - an index inside a node’s string that should\n     *                               be highlighted as the source of the error\n     *\n     * @return {CssSyntaxError} error object to throw it\n     *\n     * @example\n     * if ( !variables[name] ) {\n     *   throw decl.error('Unknown variable ' + name, { word: name });\n     *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black\n     *   //   color: $black\n     *   // a\n     *   //          ^\n     *   //   background: white\n     * }\n     */\n    error(message, opts = { }) {\n        if ( this.source ) {\n            let pos = this.positionBy(opts);\n            return this.source.input.error(message, pos.line, pos.column, opts);\n        } else {\n            return new CssSyntaxError(message);\n        }\n    }\n\n    /**\n     * This method is provided as a convenience wrapper for {@link Result#warn}.\n     *\n     * @param {Result} result      - the {@link Result} instance\n     *                               that will receive the warning\n     * @param {string} text        - warning message\n     * @param {object} [opts]      - options\n     * @param {string} opts.plugin - plugin name that created this warning.\n     *                               PostCSS will set it automatically.\n     * @param {string} opts.word   - a word inside a node’s string that should\n     *                               be highlighted as the source of the warning\n     * @param {number} opts.index  - an index inside a node’s string that should\n     *                               be highlighted as the source of the warning\n     *\n     * @return {Warning} created warning object\n     *\n     * @example\n     * const plugin = postcss.plugin('postcss-deprecated', () => {\n     *   return (root, result) => {\n     *     root.walkDecls('bad', decl => {\n     *       decl.warn(result, 'Deprecated property bad');\n     *     });\n     *   };\n     * });\n     */\n    warn(result, text, opts) {\n        let data = { node: this };\n        for ( let i in opts ) data[i] = opts[i];\n        return result.warn(text, data);\n    }\n\n    /**\n     * Removes the node from its parent and cleans the parent properties\n     * from the node and its children.\n     *\n     * @example\n     * if ( decl.prop.match(/^-webkit-/) ) {\n     *   decl.remove();\n     * }\n     *\n     * @return {Node} node to make calls chain\n     */\n    remove() {\n        if ( this.parent ) {\n            this.parent.removeChild(this);\n        }\n        this.parent = undefined;\n        return this;\n    }\n\n    /**\n     * Returns a CSS string representing the node.\n     *\n     * @param {stringifier|syntax} [stringifier] - a syntax to use\n     *                                             in string generation\n     *\n     * @return {string} CSS string of this node\n     *\n     * @example\n     * postcss.rule({ selector: 'a' }).toString() //=> \"a {}\"\n     */\n    toString(stringifier = stringify) {\n        if ( stringifier.stringify ) stringifier = stringifier.stringify;\n        let result  = '';\n        stringifier(this, i => {\n            result += i;\n        });\n        return result;\n    }\n\n    /**\n     * Returns a clone of the node.\n     *\n     * The resulting cloned node and its (cloned) children will have\n     * a clean parent and code style properties.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @example\n     * const cloned = decl.clone({ prop: '-moz-' + decl.prop });\n     * cloned.raws.before  //=> undefined\n     * cloned.parent       //=> undefined\n     * cloned.toString()   //=> -moz-transform: scale(0)\n     *\n     * @return {Node} clone of the node\n     */\n    clone(overrides = { }) {\n        let cloned = cloneNode(this);\n        for ( let name in overrides ) {\n            cloned[name] = overrides[name];\n        }\n        return cloned;\n    }\n\n    /**\n     * Shortcut to clone the node and insert the resulting cloned node\n     * before the current node.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @example\n     * decl.cloneBefore({ prop: '-moz-' + decl.prop });\n     *\n     * @return {Node} - new node\n     */\n    cloneBefore(overrides = { }) {\n        let cloned = this.clone(overrides);\n        this.parent.insertBefore(this, cloned);\n        return cloned;\n    }\n\n    /**\n     * Shortcut to clone the node and insert the resulting cloned node\n     * after the current node.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @return {Node} - new node\n     */\n    cloneAfter(overrides = { }) {\n        let cloned = this.clone(overrides);\n        this.parent.insertAfter(this, cloned);\n        return cloned;\n    }\n\n    /**\n     * Inserts node(s) before the current node and removes the current node.\n     *\n     * @param {...Node} nodes - node(s) to replace current one\n     *\n     * @example\n     * if ( atrule.name == 'mixin' ) {\n     *   atrule.replaceWith(mixinRules[atrule.params]);\n     * }\n     *\n     * @return {Node} current node to methods chain\n     */\n    replaceWith(...nodes) {\n        if (this.parent) {\n            for (let node of nodes) {\n                this.parent.insertBefore(this, node);\n            }\n\n            this.remove();\n        }\n\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it\n     * at the end of `newParent`.\n     *\n     * This will clean the `before` and `after` code {@link Node#raws} data\n     * from the node and replace them with the indentation style of `newParent`.\n     * It will also clean the `between` property\n     * if `newParent` is in another {@link Root}.\n     *\n     * @param {Container} newParent - container node where the current node\n     *                                will be moved\n     *\n     * @example\n     * atrule.moveTo(atrule.root());\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveTo(newParent) {\n        this.cleanRaws(this.root() === newParent.root());\n        this.remove();\n        newParent.append(this);\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it into\n     * a new parent before `otherNode`.\n     *\n     * This will also clean the node’s code style properties just as it would\n     * in {@link Node#moveTo}.\n     *\n     * @param {Node} otherNode - node that will be before current node\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveBefore(otherNode) {\n        this.cleanRaws(this.root() === otherNode.root());\n        this.remove();\n        otherNode.parent.insertBefore(otherNode, this);\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it into\n     * a new parent after `otherNode`.\n     *\n     * This will also clean the node’s code style properties just as it would\n     * in {@link Node#moveTo}.\n     *\n     * @param {Node} otherNode - node that will be after current node\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveAfter(otherNode) {\n        this.cleanRaws(this.root() === otherNode.root());\n        this.remove();\n        otherNode.parent.insertAfter(otherNode, this);\n        return this;\n    }\n\n    /**\n     * Returns the next child of the node’s parent.\n     * Returns `undefined` if the current node is the last child.\n     *\n     * @return {Node|undefined} next node\n     *\n     * @example\n     * if ( comment.text === 'delete next' ) {\n     *   const next = comment.next();\n     *   if ( next ) {\n     *     next.remove();\n     *   }\n     * }\n     */\n    next() {\n        let index = this.parent.index(this);\n        return this.parent.nodes[index + 1];\n    }\n\n    /**\n     * Returns the previous child of the node’s parent.\n     * Returns `undefined` if the current node is the first child.\n     *\n     * @return {Node|undefined} previous node\n     *\n     * @example\n     * const annotation = decl.prev();\n     * if ( annotation.type == 'comment' ) {\n     *  readAnnotation(annotation.text);\n     * }\n     */\n    prev() {\n        let index = this.parent.index(this);\n        return this.parent.nodes[index - 1];\n    }\n\n    toJSON() {\n        let fixed = { };\n\n        for ( let name in this ) {\n            if ( !this.hasOwnProperty(name) ) continue;\n            if ( name === 'parent' ) continue;\n            let value = this[name];\n\n            if ( value instanceof Array ) {\n                fixed[name] = value.map( i => {\n                    if ( typeof i === 'object' && i.toJSON ) {\n                        return i.toJSON();\n                    } else {\n                        return i;\n                    }\n                });\n            } else if ( typeof value === 'object' && value.toJSON ) {\n                fixed[name] = value.toJSON();\n            } else {\n                fixed[name] = value;\n            }\n        }\n\n        return fixed;\n    }\n\n    /**\n     * Returns a {@link Node#raws} value. If the node is missing\n     * the code style property (because the node was manually built or cloned),\n     * PostCSS will try to autodetect the code style property by looking\n     * at other nodes in the tree.\n     *\n     * @param {string} prop          - name of code style property\n     * @param {string} [defaultType] - name of default value, it can be missed\n     *                                 if the value is the same as prop\n     *\n     * @example\n     * const root = postcss.parse('a { background: white }');\n     * root.nodes[0].append({ prop: 'color', value: 'black' });\n     * root.nodes[0].nodes[1].raws.before   //=> undefined\n     * root.nodes[0].nodes[1].raw('before') //=> ' '\n     *\n     * @return {string} code style value\n     */\n    raw(prop, defaultType) {\n        let str = new Stringifier();\n        return str.raw(this, prop, defaultType);\n    }\n\n    /**\n     * Finds the Root instance of the node’s tree.\n     *\n     * @example\n     * root.nodes[0].nodes[0].root() === root\n     *\n     * @return {Root} root parent\n     */\n    root() {\n        let result = this;\n        while ( result.parent ) result = result.parent;\n        return result;\n    }\n\n    cleanRaws(keepBetween) {\n        delete this.raws.before;\n        delete this.raws.after;\n        if ( !keepBetween ) delete this.raws.between;\n    }\n\n    positionInside(index) {\n        let string = this.toString();\n        let column = this.source.start.column;\n        let line   = this.source.start.line;\n\n        for ( let i = 0; i < index; i++ ) {\n            if ( string[i] === '\\n' ) {\n                column = 1;\n                line  += 1;\n            } else {\n                column += 1;\n            }\n        }\n\n        return { line, column };\n    }\n\n    positionBy(opts) {\n        let pos = this.source.start;\n        if ( opts.index ) {\n            pos = this.positionInside(opts.index);\n        } else if ( opts.word ) {\n            let index = this.toString().indexOf(opts.word);\n            if ( index !== -1 ) pos = this.positionInside(index);\n        }\n        return pos;\n    }\n\n    removeSelf() {\n        warnOnce('Node#removeSelf is deprecated. Use Node#remove.');\n        return this.remove();\n    }\n\n    replace(nodes) {\n        warnOnce('Node#replace is deprecated. Use Node#replaceWith');\n        return this.replaceWith(nodes);\n    }\n\n    style(own, detect) {\n        warnOnce('Node#style() is deprecated. Use Node#raw()');\n        return this.raw(own, detect);\n    }\n\n    cleanStyles(keepBetween) {\n        warnOnce('Node#cleanStyles() is deprecated. Use Node#cleanRaws()');\n        return this.cleanRaws(keepBetween);\n    }\n\n    get before() {\n        warnOnce('Node#before is deprecated. Use Node#raws.before');\n        return this.raws.before;\n    }\n\n    set before(val) {\n        warnOnce('Node#before is deprecated. Use Node#raws.before');\n        this.raws.before = val;\n    }\n\n    get between() {\n        warnOnce('Node#between is deprecated. Use Node#raws.between');\n        return this.raws.between;\n    }\n\n    set between(val) {\n        warnOnce('Node#between is deprecated. Use Node#raws.between');\n        this.raws.between = val;\n    }\n\n    /**\n     * @memberof Node#\n     * @member {string} type - String representing the node’s type.\n     *                         Possible values are `root`, `atrule`, `rule`,\n     *                         `decl`, or `comment`.\n     *\n     * @example\n     * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'\n     */\n\n    /**\n     * @memberof Node#\n     * @member {Container} parent - the node’s parent node.\n     *\n     * @example\n     * root.nodes[0].parent == root;\n     */\n\n    /**\n     * @memberof Node#\n     * @member {source} source - the input source of the node\n     *\n     * The property is used in source map generation.\n     *\n     * If you create a node manually (e.g., with `postcss.decl()`),\n     * that node will not have a `source` property and will be absent\n     * from the source map. For this reason, the plugin developer should\n     * consider cloning nodes to create new ones (in which case the new node’s\n     * source will reference the original, cloned node) or setting\n     * the `source` property manually.\n     *\n     * ```js\n     * // Bad\n     * const prefixed = postcss.decl({\n     *   prop: '-moz-' + decl.prop,\n     *   value: decl.value\n     * });\n     *\n     * // Good\n     * const prefixed = decl.clone({ prop: '-moz-' + decl.prop });\n     * ```\n     *\n     * ```js\n     * if ( atrule.name == 'add-link' ) {\n     *   const rule = postcss.rule({ selector: 'a', source: atrule.source });\n     *   atrule.parent.insertBefore(atrule, rule);\n     * }\n     * ```\n     *\n     * @example\n     * decl.source.input.from //=> '/home/ai/a.sass'\n     * decl.source.start      //=> { line: 10, column: 2 }\n     * decl.source.end        //=> { line: 10, column: 12 }\n     */\n\n    /**\n     * @memberof Node#\n     * @member {object} raws - Information to generate byte-to-byte equal\n     *                         node string as it was in the origin input.\n     *\n     * Every parser saves its own properties,\n     * but the default CSS parser uses:\n     *\n     * * `before`: the space symbols before the node. It also stores `*`\n     *   and `_` symbols before the declaration (IE hack).\n     * * `after`: the space symbols after the last child of the node\n     *   to the end of the node.\n     * * `between`: the symbols between the property and value\n     *   for declarations, selector and `{` for rules, or last parameter\n     *   and `{` for at-rules.\n     * * `semicolon`: contains true if the last child has\n     *   an (optional) semicolon.\n     * * `afterName`: the space between the at-rule name and its parameters.\n     * * `left`: the space symbols between `/*` and the comment’s text.\n     * * `right`: the space symbols between the comment’s text\n     *   and <code>*&#47;</code>.\n     * * `important`: the content of the important statement,\n     *   if it is not just `!important`.\n     *\n     * PostCSS cleans selectors, declaration values and at-rule parameters\n     * from comments and extra spaces, but it stores origin content in raws\n     * properties. As such, if you don’t change a declaration’s value,\n     * PostCSS will use the raw value with comments.\n     *\n     * @example\n     * const root = postcss.parse('a {\\n  color:black\\n}')\n     * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n     */\n\n}\n\nexport default Node;\n\n/**\n * @typedef {object} position\n * @property {number} line   - source line in file\n * @property {number} column - source column in file\n */\n\n/**\n * @typedef {object} source\n * @property {Input} input    - {@link Input} with input file\n * @property {position} start - The starting position of the node’s source\n * @property {position} end   - The ending position of the node’s source\n */\n"]} diff --git a/node_modules/postcss/lib/parse.js b/node_modules/postcss/lib/parse.js new file mode 100644 index 00000000..b1e52d8e --- /dev/null +++ b/node_modules/postcss/lib/parse.js @@ -0,0 +1,43 @@ +'use strict'; + +exports.__esModule = true; +exports.default = parse; + +var _parser = require('./parser'); + +var _parser2 = _interopRequireDefault(_parser); + +var _input = require('./input'); + +var _input2 = _interopRequireDefault(_input); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function parse(css, opts) { + if (opts && opts.safe) { + throw new Error('Option safe was removed. ' + 'Use parser: require("postcss-safe-parser")'); + } + + var input = new _input2.default(css, opts); + + var parser = new _parser2.default(input); + try { + parser.tokenize(); + parser.loop(); + } catch (e) { + if (e.name === 'CssSyntaxError' && opts && opts.from) { + if (/\.scss$/i.test(opts.from)) { + e.message += '\nYou tried to parse SCSS with ' + 'the standard CSS parser; ' + 'try again with the postcss-scss parser'; + } else if (/\.sass/i.test(opts.from)) { + e.message += '\nYou tried to parse Sass with ' + 'the standard CSS parser; ' + 'try again with the postcss-sass parser'; + } else if (/\.less$/i.test(opts.from)) { + e.message += '\nYou tried to parse Less with ' + 'the standard CSS parser; ' + 'try again with the postcss-less parser'; + } + } + throw e; + } + + return parser.root; +} +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/parser.js b/node_modules/postcss/lib/parser.js new file mode 100644 index 00000000..7320196f --- /dev/null +++ b/node_modules/postcss/lib/parser.js @@ -0,0 +1,514 @@ +'use strict'; + +exports.__esModule = true; + +var _declaration = require('./declaration'); + +var _declaration2 = _interopRequireDefault(_declaration); + +var _tokenize = require('./tokenize'); + +var _tokenize2 = _interopRequireDefault(_tokenize); + +var _comment = require('./comment'); + +var _comment2 = _interopRequireDefault(_comment); + +var _atRule = require('./at-rule'); + +var _atRule2 = _interopRequireDefault(_atRule); + +var _root = require('./root'); + +var _root2 = _interopRequireDefault(_root); + +var _rule = require('./rule'); + +var _rule2 = _interopRequireDefault(_rule); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Parser = function () { + function Parser(input) { + _classCallCheck(this, Parser); + + this.input = input; + + this.pos = 0; + this.root = new _root2.default(); + this.current = this.root; + this.spaces = ''; + this.semicolon = false; + + this.root.source = { input: input, start: { line: 1, column: 1 } }; + } + + Parser.prototype.tokenize = function tokenize() { + this.tokens = (0, _tokenize2.default)(this.input); + }; + + Parser.prototype.loop = function loop() { + var token = void 0; + while (this.pos < this.tokens.length) { + token = this.tokens[this.pos]; + + switch (token[0]) { + + case 'space': + case ';': + this.spaces += token[1]; + break; + + case '}': + this.end(token); + break; + + case 'comment': + this.comment(token); + break; + + case 'at-word': + this.atrule(token); + break; + + case '{': + this.emptyRule(token); + break; + + default: + this.other(); + break; + } + + this.pos += 1; + } + this.endFile(); + }; + + Parser.prototype.comment = function comment(token) { + var node = new _comment2.default(); + this.init(node, token[2], token[3]); + node.source.end = { line: token[4], column: token[5] }; + + var text = token[1].slice(2, -2); + if (/^\s*$/.test(text)) { + node.text = ''; + node.raws.left = text; + node.raws.right = ''; + } else { + var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/); + node.text = match[2]; + node.raws.left = match[1]; + node.raws.right = match[3]; + } + }; + + Parser.prototype.emptyRule = function emptyRule(token) { + var node = new _rule2.default(); + this.init(node, token[2], token[3]); + node.selector = ''; + node.raws.between = ''; + this.current = node; + }; + + Parser.prototype.other = function other() { + var token = void 0; + var end = false; + var type = null; + var colon = false; + var bracket = null; + var brackets = []; + + var start = this.pos; + while (this.pos < this.tokens.length) { + token = this.tokens[this.pos]; + type = token[0]; + + if (type === '(' || type === '[') { + if (!bracket) bracket = token; + brackets.push(type === '(' ? ')' : ']'); + } else if (brackets.length === 0) { + if (type === ';') { + if (colon) { + this.decl(this.tokens.slice(start, this.pos + 1)); + return; + } else { + break; + } + } else if (type === '{') { + this.rule(this.tokens.slice(start, this.pos + 1)); + return; + } else if (type === '}') { + this.pos -= 1; + end = true; + break; + } else if (type === ':') { + colon = true; + } + } else if (type === brackets[brackets.length - 1]) { + brackets.pop(); + if (brackets.length === 0) bracket = null; + } + + this.pos += 1; + } + if (this.pos === this.tokens.length) { + this.pos -= 1; + end = true; + } + + if (brackets.length > 0) this.unclosedBracket(bracket); + + if (end && colon) { + while (this.pos > start) { + token = this.tokens[this.pos][0]; + if (token !== 'space' && token !== 'comment') break; + this.pos -= 1; + } + this.decl(this.tokens.slice(start, this.pos + 1)); + return; + } + + this.unknownWord(start); + }; + + Parser.prototype.rule = function rule(tokens) { + tokens.pop(); + + var node = new _rule2.default(); + this.init(node, tokens[0][2], tokens[0][3]); + + node.raws.between = this.spacesAndCommentsFromEnd(tokens); + this.raw(node, 'selector', tokens); + this.current = node; + }; + + Parser.prototype.decl = function decl(tokens) { + var node = new _declaration2.default(); + this.init(node); + + var last = tokens[tokens.length - 1]; + if (last[0] === ';') { + this.semicolon = true; + tokens.pop(); + } + if (last[4]) { + node.source.end = { line: last[4], column: last[5] }; + } else { + node.source.end = { line: last[2], column: last[3] }; + } + + while (tokens[0][0] !== 'word') { + node.raws.before += tokens.shift()[1]; + } + node.source.start = { line: tokens[0][2], column: tokens[0][3] }; + + node.prop = ''; + while (tokens.length) { + var type = tokens[0][0]; + if (type === ':' || type === 'space' || type === 'comment') { + break; + } + node.prop += tokens.shift()[1]; + } + + node.raws.between = ''; + + var token = void 0; + while (tokens.length) { + token = tokens.shift(); + + if (token[0] === ':') { + node.raws.between += token[1]; + break; + } else { + node.raws.between += token[1]; + } + } + + if (node.prop[0] === '_' || node.prop[0] === '*') { + node.raws.before += node.prop[0]; + node.prop = node.prop.slice(1); + } + node.raws.between += this.spacesAndCommentsFromStart(tokens); + this.precheckMissedSemicolon(tokens); + + for (var i = tokens.length - 1; i > 0; i--) { + token = tokens[i]; + if (token[1] === '!important') { + node.important = true; + var string = this.stringFrom(tokens, i); + string = this.spacesFromEnd(tokens) + string; + if (string !== ' !important') node.raws.important = string; + break; + } else if (token[1] === 'important') { + var cache = tokens.slice(0); + var str = ''; + for (var j = i; j > 0; j--) { + var _type = cache[j][0]; + if (str.trim().indexOf('!') === 0 && _type !== 'space') { + break; + } + str = cache.pop()[1] + str; + } + if (str.trim().indexOf('!') === 0) { + node.important = true; + node.raws.important = str; + tokens = cache; + } + } + + if (token[0] !== 'space' && token[0] !== 'comment') { + break; + } + } + + this.raw(node, 'value', tokens); + + if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens); + }; + + Parser.prototype.atrule = function atrule(token) { + var node = new _atRule2.default(); + node.name = token[1].slice(1); + if (node.name === '') { + this.unnamedAtrule(node, token); + } + this.init(node, token[2], token[3]); + + var last = false; + var open = false; + var params = []; + + this.pos += 1; + while (this.pos < this.tokens.length) { + token = this.tokens[this.pos]; + + if (token[0] === ';') { + node.source.end = { line: token[2], column: token[3] }; + this.semicolon = true; + break; + } else if (token[0] === '{') { + open = true; + break; + } else if (token[0] === '}') { + this.end(token); + break; + } else { + params.push(token); + } + + this.pos += 1; + } + if (this.pos === this.tokens.length) { + last = true; + } + + node.raws.between = this.spacesAndCommentsFromEnd(params); + if (params.length) { + node.raws.afterName = this.spacesAndCommentsFromStart(params); + this.raw(node, 'params', params); + if (last) { + token = params[params.length - 1]; + node.source.end = { line: token[4], column: token[5] }; + this.spaces = node.raws.between; + node.raws.between = ''; + } + } else { + node.raws.afterName = ''; + node.params = ''; + } + + if (open) { + node.nodes = []; + this.current = node; + } + }; + + Parser.prototype.end = function end(token) { + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon; + } + this.semicolon = false; + + this.current.raws.after = (this.current.raws.after || '') + this.spaces; + this.spaces = ''; + + if (this.current.parent) { + this.current.source.end = { line: token[2], column: token[3] }; + this.current = this.current.parent; + } else { + this.unexpectedClose(token); + } + }; + + Parser.prototype.endFile = function endFile() { + if (this.current.parent) this.unclosedBlock(); + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon; + } + this.current.raws.after = (this.current.raws.after || '') + this.spaces; + }; + + // Helpers + + Parser.prototype.init = function init(node, line, column) { + this.current.push(node); + + node.source = { start: { line: line, column: column }, input: this.input }; + node.raws.before = this.spaces; + this.spaces = ''; + if (node.type !== 'comment') this.semicolon = false; + }; + + Parser.prototype.raw = function raw(node, prop, tokens) { + var token = void 0, + type = void 0; + var length = tokens.length; + var value = ''; + var clean = true; + for (var i = 0; i < length; i += 1) { + token = tokens[i]; + type = token[0]; + if (type === 'comment' || type === 'space' && i === length - 1) { + clean = false; + } else { + value += token[1]; + } + } + if (!clean) { + var raw = tokens.reduce(function (all, i) { + return all + i[1]; + }, ''); + node.raws[prop] = { value: value, raw: raw }; + } + node[prop] = value; + }; + + Parser.prototype.spacesAndCommentsFromEnd = function spacesAndCommentsFromEnd(tokens) { + var lastTokenType = void 0; + var spaces = ''; + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0]; + if (lastTokenType !== 'space' && lastTokenType !== 'comment') break; + spaces = tokens.pop()[1] + spaces; + } + return spaces; + }; + + Parser.prototype.spacesAndCommentsFromStart = function spacesAndCommentsFromStart(tokens) { + var next = void 0; + var spaces = ''; + while (tokens.length) { + next = tokens[0][0]; + if (next !== 'space' && next !== 'comment') break; + spaces += tokens.shift()[1]; + } + return spaces; + }; + + Parser.prototype.spacesFromEnd = function spacesFromEnd(tokens) { + var lastTokenType = void 0; + var spaces = ''; + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0]; + if (lastTokenType !== 'space') break; + spaces = tokens.pop()[1] + spaces; + } + return spaces; + }; + + Parser.prototype.stringFrom = function stringFrom(tokens, from) { + var result = ''; + for (var i = from; i < tokens.length; i++) { + result += tokens[i][1]; + } + tokens.splice(from, tokens.length - from); + return result; + }; + + Parser.prototype.colon = function colon(tokens) { + var brackets = 0; + var token = void 0, + type = void 0, + prev = void 0; + for (var i = 0; i < tokens.length; i++) { + token = tokens[i]; + type = token[0]; + + if (type === '(') { + brackets += 1; + } else if (type === ')') { + brackets -= 1; + } else if (brackets === 0 && type === ':') { + if (!prev) { + this.doubleColon(token); + } else if (prev[0] === 'word' && prev[1] === 'progid') { + continue; + } else { + return i; + } + } + + prev = token; + } + return false; + }; + + // Errors + + Parser.prototype.unclosedBracket = function unclosedBracket(bracket) { + throw this.input.error('Unclosed bracket', bracket[2], bracket[3]); + }; + + Parser.prototype.unknownWord = function unknownWord(start) { + var token = this.tokens[start]; + throw this.input.error('Unknown word', token[2], token[3]); + }; + + Parser.prototype.unexpectedClose = function unexpectedClose(token) { + throw this.input.error('Unexpected }', token[2], token[3]); + }; + + Parser.prototype.unclosedBlock = function unclosedBlock() { + var pos = this.current.source.start; + throw this.input.error('Unclosed block', pos.line, pos.column); + }; + + Parser.prototype.doubleColon = function doubleColon(token) { + throw this.input.error('Double colon', token[2], token[3]); + }; + + Parser.prototype.unnamedAtrule = function unnamedAtrule(node, token) { + throw this.input.error('At-rule without name', token[2], token[3]); + }; + + Parser.prototype.precheckMissedSemicolon = function precheckMissedSemicolon(tokens) { + // Hook for Safe Parser + tokens; + }; + + Parser.prototype.checkMissedSemicolon = function checkMissedSemicolon(tokens) { + var colon = this.colon(tokens); + if (colon === false) return; + + var founded = 0; + var token = void 0; + for (var j = colon - 1; j >= 0; j--) { + token = tokens[j]; + if (token[0] !== 'space') { + founded += 1; + if (founded === 2) break; + } + } + throw this.input.error('Missed semicolon', token[2], token[3]); + }; + + return Parser; +}(); + +exports.default = Parser; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["parser.es6"],"names":["Parser","input","pos","root","current","spaces","semicolon","source","start","line","column","tokenize","tokens","loop","token","length","end","comment","atrule","emptyRule","other","endFile","node","init","text","slice","test","raws","left","right","match","selector","between","type","colon","bracket","brackets","push","decl","rule","pop","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","raw","last","before","shift","prop","spacesAndCommentsFromStart","precheckMissedSemicolon","i","important","string","stringFrom","spacesFromEnd","cache","str","j","trim","indexOf","value","checkMissedSemicolon","name","unnamedAtrule","open","params","afterName","nodes","after","parent","unexpectedClose","unclosedBlock","clean","reduce","all","lastTokenType","next","from","result","splice","prev","doubleColon","error","founded"],"mappings":"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","file":"parser.js","sourcesContent":["import Declaration from './declaration';\nimport tokenizer   from './tokenize';\nimport Comment     from './comment';\nimport AtRule      from './at-rule';\nimport Root        from './root';\nimport Rule        from './rule';\n\nexport default class Parser {\n\n    constructor(input) {\n        this.input = input;\n\n        this.pos       = 0;\n        this.root      = new Root();\n        this.current   = this.root;\n        this.spaces    = '';\n        this.semicolon = false;\n\n        this.root.source = { input, start: { line: 1, column: 1 } };\n    }\n\n    tokenize() {\n        this.tokens = tokenizer(this.input);\n    }\n\n    loop() {\n        let token;\n        while ( this.pos < this.tokens.length ) {\n            token = this.tokens[this.pos];\n\n            switch ( token[0] ) {\n\n            case 'space':\n            case ';':\n                this.spaces += token[1];\n                break;\n\n            case '}':\n                this.end(token);\n                break;\n\n            case 'comment':\n                this.comment(token);\n                break;\n\n            case 'at-word':\n                this.atrule(token);\n                break;\n\n            case '{':\n                this.emptyRule(token);\n                break;\n\n            default:\n                this.other();\n                break;\n            }\n\n            this.pos += 1;\n        }\n        this.endFile();\n    }\n\n    comment(token) {\n        let node = new Comment();\n        this.init(node, token[2], token[3]);\n        node.source.end = { line: token[4], column: token[5] };\n\n        let text = token[1].slice(2, -2);\n        if ( /^\\s*$/.test(text) ) {\n            node.text       = '';\n            node.raws.left  = text;\n            node.raws.right = '';\n        } else {\n            let match = text.match(/^(\\s*)([^]*[^\\s])(\\s*)$/);\n            node.text       = match[2];\n            node.raws.left  = match[1];\n            node.raws.right = match[3];\n        }\n    }\n\n    emptyRule(token) {\n        let node = new Rule();\n        this.init(node, token[2], token[3]);\n        node.selector = '';\n        node.raws.between = '';\n        this.current = node;\n    }\n\n    other() {\n        let token;\n        let end      = false;\n        let type     = null;\n        let colon    = false;\n        let bracket  = null;\n        let brackets = [];\n\n        let start = this.pos;\n        while ( this.pos < this.tokens.length ) {\n            token = this.tokens[this.pos];\n            type  = token[0];\n\n            if ( type === '(' || type === '[' ) {\n                if ( !bracket ) bracket = token;\n                brackets.push(type === '(' ? ')' : ']');\n\n            } else if ( brackets.length === 0 ) {\n                if ( type === ';' ) {\n                    if ( colon ) {\n                        this.decl(this.tokens.slice(start, this.pos + 1));\n                        return;\n                    } else {\n                        break;\n                    }\n\n                } else if ( type === '{' ) {\n                    this.rule(this.tokens.slice(start, this.pos + 1));\n                    return;\n\n                } else if ( type === '}' ) {\n                    this.pos -= 1;\n                    end = true;\n                    break;\n\n                } else if ( type === ':' ) {\n                    colon = true;\n                }\n\n            } else if ( type === brackets[brackets.length - 1] ) {\n                brackets.pop();\n                if ( brackets.length === 0 ) bracket = null;\n            }\n\n            this.pos += 1;\n        }\n        if ( this.pos === this.tokens.length ) {\n            this.pos -= 1;\n            end = true;\n        }\n\n        if ( brackets.length > 0 ) this.unclosedBracket(bracket);\n\n        if ( end && colon ) {\n            while ( this.pos > start ) {\n                token = this.tokens[this.pos][0];\n                if ( token !== 'space' && token !== 'comment' ) break;\n                this.pos -= 1;\n            }\n            this.decl(this.tokens.slice(start, this.pos + 1));\n            return;\n        }\n\n        this.unknownWord(start);\n    }\n\n    rule(tokens) {\n        tokens.pop();\n\n        let node = new Rule();\n        this.init(node, tokens[0][2], tokens[0][3]);\n\n        node.raws.between = this.spacesAndCommentsFromEnd(tokens);\n        this.raw(node, 'selector', tokens);\n        this.current = node;\n    }\n\n    decl(tokens) {\n        let node = new Declaration();\n        this.init(node);\n\n        let last = tokens[tokens.length - 1];\n        if ( last[0] === ';' ) {\n            this.semicolon = true;\n            tokens.pop();\n        }\n        if ( last[4] ) {\n            node.source.end = { line: last[4], column: last[5] };\n        } else {\n            node.source.end = { line: last[2], column: last[3] };\n        }\n\n        while ( tokens[0][0] !== 'word' ) {\n            node.raws.before += tokens.shift()[1];\n        }\n        node.source.start = { line: tokens[0][2], column: tokens[0][3] };\n\n        node.prop = '';\n        while ( tokens.length ) {\n            let type = tokens[0][0];\n            if ( type === ':' || type === 'space' || type === 'comment' ) {\n                break;\n            }\n            node.prop += tokens.shift()[1];\n        }\n\n        node.raws.between = '';\n\n        let token;\n        while ( tokens.length ) {\n            token = tokens.shift();\n\n            if ( token[0] === ':' ) {\n                node.raws.between += token[1];\n                break;\n            } else {\n                node.raws.between += token[1];\n            }\n        }\n\n        if ( node.prop[0] === '_' || node.prop[0] === '*' ) {\n            node.raws.before += node.prop[0];\n            node.prop = node.prop.slice(1);\n        }\n        node.raws.between += this.spacesAndCommentsFromStart(tokens);\n        this.precheckMissedSemicolon(tokens);\n\n        for ( let i = tokens.length - 1; i > 0; i-- ) {\n            token = tokens[i];\n            if ( token[1] === '!important' ) {\n                node.important = true;\n                let string = this.stringFrom(tokens, i);\n                string = this.spacesFromEnd(tokens) + string;\n                if ( string !== ' !important' ) node.raws.important = string;\n                break;\n\n            } else if (token[1] === 'important') {\n                let cache = tokens.slice(0);\n                let str   = '';\n                for ( let j = i; j > 0; j-- ) {\n                    let type = cache[j][0];\n                    if ( str.trim().indexOf('!') === 0 && type !== 'space' ) {\n                        break;\n                    }\n                    str = cache.pop()[1] + str;\n                }\n                if ( str.trim().indexOf('!') === 0 ) {\n                    node.important = true;\n                    node.raws.important = str;\n                    tokens = cache;\n                }\n            }\n\n            if ( token[0] !== 'space' && token[0] !== 'comment' ) {\n                break;\n            }\n        }\n\n        this.raw(node, 'value', tokens);\n\n        if ( node.value.indexOf(':') !== -1 ) this.checkMissedSemicolon(tokens);\n    }\n\n    atrule(token) {\n        let node  = new AtRule();\n        node.name = token[1].slice(1);\n        if ( node.name === '' ) {\n            this.unnamedAtrule(node, token);\n        }\n        this.init(node, token[2], token[3]);\n\n        let last   = false;\n        let open   = false;\n        let params = [];\n\n        this.pos += 1;\n        while ( this.pos < this.tokens.length ) {\n            token = this.tokens[this.pos];\n\n            if ( token[0] === ';' ) {\n                node.source.end = { line: token[2], column: token[3] };\n                this.semicolon = true;\n                break;\n            } else if ( token[0] === '{' ) {\n                open = true;\n                break;\n            } else if ( token[0] === '}') {\n                this.end(token);\n                break;\n            } else {\n                params.push(token);\n            }\n\n            this.pos += 1;\n        }\n        if ( this.pos === this.tokens.length ) {\n            last = true;\n        }\n\n        node.raws.between = this.spacesAndCommentsFromEnd(params);\n        if ( params.length ) {\n            node.raws.afterName = this.spacesAndCommentsFromStart(params);\n            this.raw(node, 'params', params);\n            if ( last ) {\n                token = params[params.length - 1];\n                node.source.end   = { line: token[4], column: token[5] };\n                this.spaces       = node.raws.between;\n                node.raws.between = '';\n            }\n        } else {\n            node.raws.afterName = '';\n            node.params         = '';\n        }\n\n        if ( open ) {\n            node.nodes   = [];\n            this.current = node;\n        }\n    }\n\n    end(token) {\n        if ( this.current.nodes && this.current.nodes.length ) {\n            this.current.raws.semicolon = this.semicolon;\n        }\n        this.semicolon = false;\n\n        this.current.raws.after = (this.current.raws.after || '') + this.spaces;\n        this.spaces = '';\n\n        if ( this.current.parent ) {\n            this.current.source.end = { line: token[2], column: token[3] };\n            this.current = this.current.parent;\n        } else {\n            this.unexpectedClose(token);\n        }\n    }\n\n    endFile() {\n        if ( this.current.parent ) this.unclosedBlock();\n        if ( this.current.nodes && this.current.nodes.length ) {\n            this.current.raws.semicolon = this.semicolon;\n        }\n        this.current.raws.after = (this.current.raws.after || '') + this.spaces;\n    }\n\n    // Helpers\n\n    init(node, line, column) {\n        this.current.push(node);\n\n        node.source = { start: { line, column }, input: this.input };\n        node.raws.before = this.spaces;\n        this.spaces = '';\n        if ( node.type !== 'comment' ) this.semicolon = false;\n    }\n\n    raw(node, prop, tokens) {\n        let token, type;\n        let length = tokens.length;\n        let value  = '';\n        let clean  = true;\n        for ( let i = 0; i < length; i += 1 ) {\n            token = tokens[i];\n            type  = token[0];\n            if ( type === 'comment' || type === 'space' && i === length - 1 ) {\n                clean = false;\n            } else {\n                value += token[1];\n            }\n        }\n        if ( !clean ) {\n            let raw = tokens.reduce( (all, i) => all + i[1], '');\n            node.raws[prop] = { value, raw };\n        }\n        node[prop] = value;\n    }\n\n    spacesAndCommentsFromEnd(tokens) {\n        let lastTokenType;\n        let spaces = '';\n        while ( tokens.length ) {\n            lastTokenType = tokens[tokens.length - 1][0];\n            if ( lastTokenType !== 'space' &&\n                lastTokenType !== 'comment' ) break;\n            spaces = tokens.pop()[1] + spaces;\n        }\n        return spaces;\n    }\n\n    spacesAndCommentsFromStart(tokens) {\n        let next;\n        let spaces = '';\n        while ( tokens.length ) {\n            next = tokens[0][0];\n            if ( next !== 'space' && next !== 'comment' ) break;\n            spaces += tokens.shift()[1];\n        }\n        return spaces;\n    }\n\n    spacesFromEnd(tokens) {\n        let lastTokenType;\n        let spaces = '';\n        while ( tokens.length ) {\n            lastTokenType = tokens[tokens.length - 1][0];\n            if ( lastTokenType !== 'space' ) break;\n            spaces = tokens.pop()[1] + spaces;\n        }\n        return spaces;\n    }\n\n    stringFrom(tokens, from) {\n        let result = '';\n        for ( let i = from; i < tokens.length; i++ ) {\n            result += tokens[i][1];\n        }\n        tokens.splice(from, tokens.length - from);\n        return result;\n    }\n\n    colon(tokens) {\n        let brackets = 0;\n        let token, type, prev;\n        for ( let i = 0; i < tokens.length; i++ ) {\n            token = tokens[i];\n            type  = token[0];\n\n            if ( type === '(' ) {\n                brackets += 1;\n            } else if ( type === ')' ) {\n                brackets -= 1;\n            } else if ( brackets === 0 && type === ':' ) {\n                if ( !prev ) {\n                    this.doubleColon(token);\n                } else if ( prev[0] === 'word' && prev[1] === 'progid' ) {\n                    continue;\n                } else {\n                    return i;\n                }\n            }\n\n            prev = token;\n        }\n        return false;\n    }\n\n    // Errors\n\n    unclosedBracket(bracket) {\n        throw this.input.error('Unclosed bracket', bracket[2], bracket[3]);\n    }\n\n    unknownWord(start) {\n        let token = this.tokens[start];\n        throw this.input.error('Unknown word', token[2], token[3]);\n    }\n\n    unexpectedClose(token) {\n        throw this.input.error('Unexpected }', token[2], token[3]);\n    }\n\n    unclosedBlock() {\n        let pos = this.current.source.start;\n        throw this.input.error('Unclosed block', pos.line, pos.column);\n    }\n\n    doubleColon(token) {\n        throw this.input.error('Double colon', token[2], token[3]);\n    }\n\n    unnamedAtrule(node, token) {\n        throw this.input.error('At-rule without name', token[2], token[3]);\n    }\n\n    precheckMissedSemicolon(tokens) {\n        // Hook for Safe Parser\n        tokens;\n    }\n\n    checkMissedSemicolon(tokens) {\n        let colon = this.colon(tokens);\n        if ( colon === false ) return;\n\n        let founded = 0;\n        let token;\n        for ( let j = colon - 1; j >= 0; j-- ) {\n            token = tokens[j];\n            if ( token[0] !== 'space' ) {\n                founded += 1;\n                if ( founded === 2 ) break;\n            }\n        }\n        throw this.input.error('Missed semicolon', token[2], token[3]);\n    }\n\n}\n"]} diff --git a/node_modules/postcss/lib/postcss.d.ts b/node_modules/postcss/lib/postcss.d.ts new file mode 100644 index 00000000..fc577051 --- /dev/null +++ b/node_modules/postcss/lib/postcss.d.ts @@ -0,0 +1,1305 @@ +/** + * @param plugins Can also be included with the Processor#use method. + * @returns A processor that will apply plugins as CSS processors. + */ +declare function postcss(plugins?: postcss.AcceptedPlugin[]): postcss.Processor; +declare function postcss(...plugins: postcss.AcceptedPlugin[]): postcss.Processor; +declare namespace postcss { + type AcceptedPlugin = Plugin<any> | Transformer | { + postcss: TransformCallback | Processor; + } | Processor; + /** + * Creates a PostCSS plugin with a standard API. + * @param name Plugin name. Same as in name property in package.json. It will + * be saved in plugin.postcssPlugin property. + * @param initializer Will receive plugin options and should return functions + * to modify nodes in input CSS. + */ + function plugin<T>(name: string, initializer: PluginInitializer<T>): Plugin<T>; + interface Plugin<T> extends Transformer { + (opts?: T): Transformer; + postcss: Transformer; + process: (css: string | { + toString(): string; + } | Result, opts?: any) => LazyResult; + } + interface Transformer extends TransformCallback { + postcssPlugin?: string; + postcssVersion?: string; + } + interface TransformCallback { + /** + * @returns Asynchronous plugins should return a promise. + */ + (root: Root, result?: Result): void | Function | any; + } + interface PluginInitializer<T> { + (pluginOptions?: T): Transformer; + } + /** + * Contains helpers for working with vendor prefixes. + */ + export namespace vendor { + /** + * @returns The vendor prefix extracted from the input string. + */ + function prefix(prop: string): string; + /** + * @returns The input string stripped of its vendor prefix. + */ + function unprefixed(prop: string): string; + } + export class Stringifier { + builder: Stringifier.Builder; + constructor(builder?: Stringifier.Builder); + stringify(node: Node, semicolon?: boolean): void; + root(node: any): void; + comment(node: any): void; + decl(node: any, semicolon: any): void; + rule(node: any): void; + atrule(node: any, semicolon: any): void; + body(node: any): void; + block(node: any, start: any): void; + raw(node: Node, own: string, detect?: string): any; + rawSemicolon(root: any): any; + rawEmptyBody(root: any): any; + rawIndent(root: any): any; + rawBeforeComment(root: any, node: any): any; + rawBeforeDecl(root: any, node: any): any; + rawBeforeRule(root: any): any; + rawBeforeClose(root: any): any; + rawBeforeOpen(root: any): any; + rawColon(root: any): any; + beforeAfter(node: any, detect: any): any; + rawValue(node: any, prop: any): any; + } + export namespace Stringifier { + interface Builder { + (str: string, node?: Node, str2?: string): void; + } + } + /** + * Default function to convert a node tree into a CSS string. + */ + function stringify(node: Node, builder: Stringifier.Builder): void; + /** + * Parses source CSS. + * @param css The CSS to parse. + * @param options + * @returns {} A new Root node, which contains the source CSS nodes. + */ + function parse(css: string | { + toString(): string; + } | LazyResult | Result, options?: { + from?: string; + map?: postcss.SourceMapOptions; + }): Root; + /** + * Contains helpers for safely splitting lists of CSS values, preserving + * parentheses and quotes. + */ + export namespace list { + /** + * Safely splits space-separated values (such as those for background, + * border-radius and other shorthand properties). + */ + function space(str: string): string[]; + /** + * Safely splits comma-separated values (such as those for transition-* and + * background properties). + */ + function comma(str: string): string[]; + } + /** + * Creates a new Comment node. + * @param defaults Properties for the new Comment node. + * @returns The new node. + */ + function comment(defaults?: CommentNewProps): Comment; + /** + * Creates a new AtRule node. + * @param defaults Properties for the new AtRule node. + * @returns The new node. + */ + function atRule(defaults?: AtRuleNewProps): AtRule; + /** + * Creates a new Declaration node. + * @param defaults Properties for the new Declaration node. + * @returns The new node. + */ + function decl(defaults?: DeclarationNewProps): Declaration; + /** + * Creates a new Rule node. + * @param defaults Properties for the new Rule node. + * @returns The new node. + */ + function rule(defaults?: RuleNewProps): Rule; + /** + * Creates a new Root node. + * @param defaults Properties for the new Root node. + * @returns The new node. + */ + function root(defaults?: Object): Root; + interface SourceMapOptions { + /** + * Indicates that the source map should be embedded in the output CSS as a + * Base64-encoded comment. By default, it is true. But if all previous maps + * are external, not inline, PostCSS will not embed the map even if you do + * not set this option. + * + * If you have an inline source map, the result.map property will be empty, + * as the source map will be contained within the text of result.css. + */ + inline?: boolean; + /** + * Source map content from a previous processing step (e.g., Sass compilation). + * PostCSS will try to read the previous source map automatically (based on comments + * within the source CSS), but you can use this option to identify it manually. + * If desired, you can omit the previous map with prev: false. + */ + prev?: any; + /** + * Indicates that PostCSS should set the origin content (e.g., Sass source) + * of the source map. By default, it is true. But if all previous maps do not + * contain sources content, PostCSS will also leave it out even if you do not set + * this option. + */ + sourcesContent?: boolean; + /** + * Indicates that PostCSS should add annotation comments to the CSS. By default, + * PostCSS will always add a comment with a path to the source map. PostCSS will + * not add annotations to CSS files that do not contain any comments. + * + * By default, PostCSS presumes that you want to save the source map as + * opts.to + '.map' and will use this path in the annotation comment. A different + * path can be set by providing a string value for annotation. + * + * If you have set inline: true, annotation cannot be disabled. + */ + annotation?: boolean | string; + /** + * If true, PostCSS will try to correct any syntax errors that it finds in the CSS. + * This is useful for legacy code filled with hacks. Another use-case is interactive + * tools with live input — for example, the Autoprefixer demo. + */ + safe?: boolean; + } + /** + * A Processor instance contains plugins to process CSS. Create one + * Processor instance, initialize its plugins, and then use that instance + * on numerous CSS files. + */ + interface Processor { + /** + * Adds a plugin to be used as a CSS processor. Plugins can also be + * added by passing them as arguments when creating a postcss instance. + */ + use(plugin: AcceptedPlugin): Processor; + /** + * Parses source CSS. Because some plugins can be asynchronous it doesn't + * make any transformations. Transformations will be applied in LazyResult's + * methods. + * @param css Input CSS or any object with toString() method, like a file + * stream. If a Result instance is passed the processor will take the + * existing Root parser from it. + */ + process(css: string | { + toString(): string; + } | Result, options?: ProcessOptions): LazyResult; + /** + * Contains plugins added to this processor. + */ + plugins: Plugin<any>[]; + /** + * Contains the current version of PostCSS (e.g., "4.0.5"). + */ + version: string; + } + interface ProcessOptions extends Syntax { + /** + * The path of the CSS source file. You should always set from, because it is + * used in source map generation and syntax error messages. + */ + from?: string; + /** + * The path where you'll put the output CSS file. You should always set it + * to generate correct source maps. + */ + to?: string; + syntax?: Syntax; + /** + * Enable Safe Mode, in which PostCSS will try to fix CSS syntax errors. + */ + safe?: boolean; + map?: postcss.SourceMapOptions; + /** + * Function to generate AST by string. + */ + parser?: Parse | Syntax; + /** + * Class to generate string by AST. + */ + stringifier?: Stringify | Syntax; + } + interface Syntax { + /** + * Function to generate AST by string. + */ + parse?: Parse; + /** + * Class to generate string by AST. + */ + stringify?: Stringify; + } + interface Parse { + (css?: string, opts?: postcss.SourceMapOptions): Root; + } + interface Stringify { + (node?: postcss.Node, builder?: any): postcss.Result | void; + } + /** + * A promise proxy for the result of PostCSS transformations. + */ + interface LazyResult { + /** + * Processes input CSS through synchronous and asynchronous plugins. + * @param onRejected Called if any plugin throws an error. + */ + then(onFulfilled: (result: Result) => void, onRejected?: (error: Error) => void): Function | any; + /** + * Processes input CSS through synchronous and asynchronous plugins. + * @param onRejected Called if any plugin throws an error. + */ + catch(onRejected: (error: Error) => void): Function | any; + /** + * Alias for css property. + */ + toString(): string; + /** + * Processes input CSS through synchronous plugins and converts Root to + * CSS string. This property will only work with synchronous plugins. If + * the processor contains any asynchronous plugins it will throw an error. + * In this case, you should use LazyResult#then() instead. + * @returns Result#css. + */ + css: string; + /** + * Alias for css property to use when syntaxes generate non-CSS output. + */ + content: string; + /** + * Processes input CSS through synchronous plugins. This property will + * work only with synchronous plugins. If processor contains any + * asynchronous plugins it will throw an error. You should use + * LazyResult#then() instead. + */ + map: ResultMap; + /** + * Processes input CSS through synchronous plugins. This property will work + * only with synchronous plugins. If processor contains any asynchronous + * plugins it will throw an error. You should use LazyResult#then() instead. + */ + root: Root; + /** + * Processes input CSS through synchronous plugins and calls Result#warnings(). + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. In this case, + * you should use LazyResult#then() instead. + */ + warnings(): ResultMessage[]; + /** + * Processes input CSS through synchronous plugins. This property will work + * only with synchronous plugins. If processor contains any asynchronous + * plugins it will throw an error. You should use LazyResult#then() instead. + */ + messages: ResultMessage[]; + /** + * @returns A processor used for CSS transformations. + */ + processor: Processor; + /** + * @returns Options from the Processor#process(css, opts) call that produced + * this Result instance. + */ + opts: ResultOptions; + } + /** + * Provides the result of the PostCSS transformations. + */ + interface Result { + /** + * Alias for css property. + */ + toString(): string; + /** + * Creates an instance of Warning and adds it to messages. + * @param message Used in the text property of the message object. + * @param options Properties for Message object. + */ + warn(message: string, options?: WarningOptions): void; + /** + * @returns Warnings from plugins, filtered from messages. + */ + warnings(): ResultMessage[]; + /** + * A CSS string representing this Result's Root instance. + */ + css: string; + /** + * Alias for css property to use with syntaxes that generate non-CSS output. + */ + content: string; + /** + * An instance of the SourceMapGenerator class from the source-map library, + * representing changes to the Result's Root instance. + * This property will have a value only if the user does not want an inline + * source map. By default, PostCSS generates inline source maps, written + * directly into the processed CSS. The map property will be empty by default. + * An external source map will be generated — and assigned to map — only if + * the user has set the map.inline option to false, or if PostCSS was passed + * an external input source map. + */ + map: ResultMap; + /** + * Contains the Root node after all transformations. + */ + root?: Root; + /** + * Contains messages from plugins (e.g., warnings or custom messages). + * Add a warning using Result#warn() and get all warnings + * using the Result#warnings() method. + */ + messages: ResultMessage[]; + /** + * The Processor instance used for this transformation. + */ + processor?: Processor; + /** + * Options from the Processor#process(css, opts) or Root#toResult(opts) call + * that produced this Result instance. + */ + opts?: ResultOptions; + } + interface ResultOptions extends ProcessOptions { + /** + * The CSS node that was the source of the warning. + */ + node?: postcss.Node; + /** + * Name of plugin that created this warning. Result#warn() will fill it + * automatically with plugin.postcssPlugin value. + */ + plugin?: string; + } + interface ResultMap { + /** + * Add a single mapping from original source line and column to the generated + * source's line and column for this source map being created. The mapping + * object should have the following properties: + * @param mapping + * @returns {} + */ + addMapping(mapping: { + generated: { + line: number; + column: number; + }; + original: { + line: number; + column: number; + }; + /** + * The original source file (relative to the sourceRoot). + */ + source: string; + name?: string; + }): void; + /** + * Set the source content for an original source file. + * @param sourceFile The URL of the original source file. + * @param sourceContent The content of the source file. + */ + setSourceContent(sourceFile: string, sourceContent: string): void; + /** + * Applies a SourceMap for a source file to the SourceMap. Each mapping to + * the supplied source file is rewritten using the supplied SourceMap. + * Note: The resolution for the resulting mappings is the minimium of this + * map and the supplied map. + * @param sourceMapConsumer The SourceMap to be applied. + * @param sourceFile The filename of the source file. If omitted, sourceMapConsumer + * file will be used, if it exists. Otherwise an error will be thrown. + * @param sourceMapPath The dirname of the path to the SourceMap to be applied. + * If relative, it is relative to the SourceMap. This parameter is needed when + * the two SourceMaps aren't in the same directory, and the SourceMap to be + * applied contains relative source paths. If so, those relative source paths + * need to be rewritten relative to the SourceMap. + * If omitted, it is assumed that both SourceMaps are in the same directory; + * thus, not needing any rewriting (Supplying '.' has the same effect). + */ + applySourceMap(sourceMapConsumer: any, sourceFile?: string, sourceMapPath?: string): void; + /** + * Renders the source map being generated to JSON. + */ + toJSON: () => any; + /** + * Renders the source map being generated to a string. + */ + toString: () => string; + } + interface ResultMessage { + type: string; + text?: string; + plugin?: string; + browsers?: string[]; + } + /** + * Represents a plugin warning. It can be created using Result#warn(). + */ + interface Warning { + /** + * @returns Error position, message. + */ + toString(): string; + /** + * Contains the warning message. + */ + text: string; + /** + * Contains the name of the plugin that created this warning. When you + * call Result#warn(), it will fill this property automatically. + */ + plugin: string; + /** + * The CSS node that caused the warning. + */ + node: Node; + /** + * The line in the input file with this warning's source. + */ + line: number; + /** + * Column in the input file with this warning's source. + */ + column: number; + } + interface WarningOptions extends ResultOptions { + /** + * A word inside a node's string that should be highlighted as source + * of warning. + */ + word?: string; + /** + * The index inside a node's string that should be highlighted as + * source of warning. + */ + index?: number; + } + /** + * The CSS parser throws this error for broken CSS. + */ + interface CssSyntaxError extends InputOrigin { + name: string; + /** + * @returns Error position, message and source code of broken part. + */ + toString(): string; + /** + * @param color Whether arrow should be colored red by terminal color codes. + * By default, PostCSS will use process.stdout.isTTY and + * process.env.NODE_DISABLE_COLORS. + * @returns A few lines of CSS source that caused the error. If CSS has + * input source map without sourceContent this method will return an empty + * string. + */ + showSourceCode(color?: boolean): string; + /** + * Contains full error text in the GNU error format. + */ + message: string; + /** + * Contains only the error description. + */ + reason: string; + /** + * Contains the PostCSS plugin name if the error didn't come from the + * CSS parser. + */ + plugin?: string; + input?: InputOrigin; + } + interface InputOrigin { + /** + * If parser's from option is set, contains the absolute path to the + * broken file. PostCSS will use the input source map to detect the + * original error location. If you wrote a Sass file, then compiled it + * to CSS and parsed it with PostCSS, PostCSS will show the original + * position in the Sass file. If you need the position in the PostCSS + * input (e.g., to debug the previous compiler), use error.input.file. + */ + file?: string; + /** + * Contains the source line of the error. PostCSS will use the input + * source map to detect the original error location. If you wrote a Sass + * file, then compiled it to CSS and parsed it with PostCSS, PostCSS + * will show the original position in the Sass file. If you need the + * position in the PostCSS input (e.g., to debug the previous + * compiler), use error.input.line. + */ + line?: number; + /** + * Contains the source column of the error. PostCSS will use input + * source map to detect the original error location. If you wrote a + * Sass file, then compiled it to CSS and parsed it with PostCSS, + * PostCSS will show the original position in the Sass file. If you + * need the position in the PostCSS input (e.g., to debug the + * previous compiler), use error.input.column. + */ + column?: number; + /** + * Contains the source code of the broken file. PostCSS will use the + * input source map to detect the original error location. If you wrote + * a Sass file, then compiled it to CSS and parsed it with PostCSS, + * PostCSS will show the original position in the Sass file. If you need + * the position in the PostCSS input (e.g., to debug the previous + * compiler), use error.input.source. + */ + source?: string; + } + export class PreviousMap { + private inline; + annotation: string; + root: string; + private consumerCache; + text: string; + file: string; + constructor(css: any, opts: any); + consumer(): any; + withContent(): boolean; + startWith(string: any, start: any): boolean; + loadAnnotation(css: any): void; + decodeInline(text: any): any; + loadMap(file: any, prev: any): any; + isMap(map: any): boolean; + } + /** + * Represents the source CSS. + */ + interface Input { + /** + * The absolute path to the CSS source file defined with the "from" option. + */ + file: string; + /** + * The unique ID of the CSS source. Used if "from" option is not provided + * (because PostCSS does not know the file path). + */ + id: string; + /** + * The CSS source identifier. Contains input.file if the user set the + * "from" option, or input.id if they did not. + */ + from: string; + /** + * Represents the input source map passed from a compilation step before + * PostCSS (e.g., from the Sass compiler). + */ + map: PreviousMap; + /** + * Reads the input source map. + * @returns A symbol position in the input source (e.g., in a Sass file + * that was compiled to CSS before being passed to PostCSS): + */ + origin(line: number, column: number): InputOrigin; + } + interface Node { + /** + * Returns a string representing the node's type. Possible values are + * root, atrule, rule, decl or comment. + */ + type: string; + /** + * Returns the node's parent node. + */ + parent: Container; + /** + * Returns the input source of the node. The property is used in source + * map generation. If you create a node manually + * (e.g., with postcss.decl() ), that node will not have a source + * property and will be absent from the source map. For this reason, the + * plugin developer should consider cloning nodes to create new ones + * (in which case the new node's source will reference the original, + * cloned node) or setting the source property manually. + */ + source: NodeSource; + /** + * Contains information to generate byte-to-byte equal node string as it + * was in origin input. + */ + raws: NodeRaws; + /** + * @returns A CSS string representing the node. + */ + toString(): string; + /** + * This method produces very useful error messages. If present, an input + * source map will be used to get the original position of the source, even + * from a previous compilation step (e.g., from Sass compilation). + * @returns The original position of the node in the source, showing line + * and column numbers and also a small excerpt to facilitate debugging. + */ + error( + /** + * Error description. + */ + message: string, options?: NodeErrorOptions): CssSyntaxError; + /** + * Creates an instance of Warning and adds it to messages. This method is + * provided as a convenience wrapper for Result#warn. + * Note that `opts.node` is automatically passed to Result#warn for you. + * @param result The result that will receive the warning. + * @param text Warning message. It will be used in the `text` property of + * the message object. + * @param opts Properties to assign to the message object. + */ + warn(result: Result, text: string, opts?: WarningOptions): void; + /** + * @returns The next child of the node's parent; or, returns undefined if + * the current node is the last child. + */ + next(): Node; + /** + * @returns The previous child of the node's parent; or, returns undefined + * if the current node is the first child. + */ + prev(): Node; + /** + * @returns The Root instance of the node's tree. + */ + root(): Root; + /** + * Removes the node from its parent and cleans the parent property in the + * node and its children. + * @returns This node for chaining. + */ + remove(): this; + /** + * Inserts node(s) before the current node and removes the current node. + * @returns This node for chaining. + */ + replaceWith(...nodes: (Node | Object)[]): this; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + /** + * Shortcut to clone the node and insert the resulting cloned node before + * the current node. + * @param overrides New Properties to override in the clone. + * @returns The cloned node. + */ + cloneBefore(overrides?: Object): this; + /** + * Shortcut to clone the node and insert the resulting cloned node after + * the current node. + * @param overrides New Properties to override in the clone. + * @returns The cloned node. + */ + cloneAfter(overrides?: Object): this; + /** + * Removes the node from its current parent and inserts it at the end of + * newParent. This will clean the before and after code style properties + * from the node and replace them with the indentation style of newParent. + * It will also clean the between property if newParent is in another Root. + * @param newParent Where the current node will be moved. + * @returns This node for chaining. + */ + moveTo(newParent: Container): this; + /** + * Removes the node from its current parent and inserts it into a new + * parent before otherNode. This will also clean the node's code style + * properties just as it would in node.moveTo(newParent). + * @param otherNode Will be after the current node after moving. + * @returns This node for chaining. + */ + moveBefore(otherNode: Node): this; + /** + * Removes the node from its current parent and inserts it into a new + * parent after otherNode. This will also clean the node's code style + * properties just as it would in node.moveTo(newParent). + * @param otherNode Will be before the current node after moving. + * @returns This node for chaining. + */ + moveAfter(otherNode: Node): this; + /** + * @param prop Name or code style property. + * @param defaultType Name of default value. It can be easily missed if the + * value is the same as prop. + * @returns A code style property value. If the node is missing the code + * style property (because the node was manually built or cloned), PostCSS + * will try to autodetect the code style property by looking at other nodes + * in the tree. + */ + raw(prop: string, defaultType?: string): any; + } + interface NodeNewProps { + raws?: NodeRaws; + } + interface NodeRaws { + /** + * The space symbols before the node. It also stores `*` and `_` + * symbols before the declaration (IE hack). + */ + before?: string; + /** + * The space symbols after the last child of the node to the end of + * the node. + */ + after?: string; + /** + * The symbols between the property and value for declarations, + * selector and "{" for rules, last parameter and "{" for at-rules. + */ + between?: string; + /** + * True if last child has (optional) semicolon. + */ + semicolon?: boolean; + /** + * The space between the at-rule's name and parameters. + */ + afterName?: string; + /** + * The space symbols between "/*" and comment's text. + */ + left?: string; + /** + * The space symbols between comment's text and "*\/". + */ + right?: string; + /** + * The content of important statement, if it is not just "!important". + */ + important?: string; + } + interface NodeSource { + input: Input; + /** + * The starting position of the node's source. + */ + start?: { + column: number; + line: number; + }; + /** + * The ending position of the node's source. + */ + end?: { + column: number; + line: number; + }; + } + interface NodeErrorOptions { + /** + * Plugin name that created this error. PostCSS will set it automatically. + */ + plugin?: string; + /** + * A word inside a node's string, that should be highlighted as source + * of error. + */ + word?: string; + /** + * An index inside a node's string that should be highlighted as source + * of error. + */ + index?: number; + } + interface JsonNode { + /** + * Returns a string representing the node's type. Possible values are + * root, atrule, rule, decl or comment. + */ + type?: string; + /** + * Returns the node's parent node. + */ + parent?: JsonContainer; + /** + * Returns the input source of the node. The property is used in source + * map generation. If you create a node manually (e.g., with + * postcss.decl() ), that node will not have a source property and + * will be absent from the source map. For this reason, the plugin + * developer should consider cloning nodes to create new ones (in which + * case the new node's source will reference the original, cloned node) + * or setting the source property manually. + */ + source?: NodeSource; + /** + * Contains information to generate byte-to-byte equal node string as it + * was in origin input. + */ + raws?: NodeRaws; + } + /** + * Containers can store any content. If you write a rule inside a rule, + * PostCSS will parse it. + */ + interface Container extends Node { + /** + * Returns the container's parent node. + */ + parent: Container; + /** + * Contains the container's children. + */ + nodes?: Node[]; + /** + * @returns The container's first child. + */ + first?: Node; + /** + * @returns The container's last child. + */ + last?: Node; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + /** + * @param child Child of the current container. + * @returns The child's index within the container's "nodes" array. + */ + index(child: Node | number): number; + /** + * Determines whether all child nodes satisfy the specified test. + * @param callback A function that accepts up to three arguments. The + * every method calls the callback function for each node until the + * callback returns false, or until the end of the array. + * @returns True if the callback returns true for all of the container's + * children. + */ + every(callback: (node: Node, index: number, nodes: Node[]) => any, thisArg?: any): boolean; + /** + * Determines whether the specified callback returns true for any child node. + * @param callback A function that accepts up to three arguments. The some + * method calls the callback for each node until the callback returns true, + * or until the end of the array. + * @param thisArg An object to which the this keyword can refer in the + * callback function. If thisArg is omitted, undefined is used as the + * this value. + * @returns True if callback returns true for (at least) one of the + * container's children. + */ + some(callback: (node: Node, index: number, nodes: Node[]) => boolean, thisArg?: any): boolean; + /** + * Iterates through the container's immediate children, calling the + * callback function for each child. If you need to recursively iterate + * through all the container's descendant nodes, use container.walk(). + * Unlike the for {} -cycle or Array#forEach() this iterator is safe if + * you are mutating the array of child nodes during iteration. + * @param callback Iterator. Returning false will break iteration. Safe + * if you are mutating the array of child nodes during iteration. PostCSS + * will adjust the current index to match the mutations. + * @returns False if the callback returns false during iteration. + */ + each(callback: (node: Node, index: number) => any): boolean | void; + /** + * Traverses the container's descendant nodes, calling `callback` for each + * node. Like container.each(), this method is safe to use if you are + * mutating arrays during iteration. If you only need to iterate through + * the container's immediate children, use container.each(). + * @param callback Iterator. + */ + walk(callback: (node: Node, index: number) => any): boolean | void; + /** + * Traverses the container's descendant nodes, calling `callback` for each + * declaration. Like container.each(), this method is safe to use if you + * are mutating arrays during iteration. + * @param propFilter Filters declarations by property name. Only those + * declarations whose property matches propFilter will be iterated over. + * @param callback Called for each declaration node within the container. + */ + walkDecls(propFilter: string | RegExp, callback?: (decl: Declaration, index: number) => any): boolean | void; + walkDecls(callback: (decl: Declaration, index: number) => any): boolean | void; + /** + * Traverses the container's descendant nodes, calling `callback` for each + * at-rule. Like container.each(), this method is safe to use if you are + * mutating arrays during iteration. + * @param nameFilter Filters at-rules by name. If provided, iteration + * will only happen over at-rules that have matching names. + * @param callback Iterator called for each at-rule node within the + * container. + */ + walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => any): boolean | void; + walkAtRules(callback: (atRule: AtRule, index: number) => any): boolean | void; + /** + * Traverses the container's descendant nodes, calling `callback` for each + * rule. Like container.each(), this method is safe to use if you are + * mutating arrays during iteration. + * @param selectorFilter Filters rules by selector. If provided, + * iteration will only happen over rules that have matching names. + * @param callback Iterator called for each rule node within the + * container. + */ + walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => any): boolean | void; + walkRules(callback: (atRule: Rule, index: number) => any): boolean | void; + walkRules(selectorFilter: any, callback?: (atRule: Rule, index: number) => any): boolean | void; + /** + * Traverses the container's descendant nodes, calling `callback` for each + * comment. Like container.each(), this method is safe to use if you are + * mutating arrays during iteration. + * @param callback Iterator called for each comment node within the container. + */ + walkComments(callback: (comment: Comment, indexed: number) => any): void | boolean; + /** + * Passes all declaration values within the container that match pattern + * through the callback, replacing those values with the returned result of + * callback. This method is useful if you are using a custom unit or + * function and need to iterate through all values. + * @param pattern Pattern that we need to replace. + * @param options Options to speed up the search. + * @param callbackOrReplaceValue String to replace pattern or callback + * that will return a new value. The callback will receive the same + * arguments as those passed to a function parameter of String#replace. + */ + replaceValues(pattern: string | RegExp, options: { + /** + * Property names. The method will only search for values that match + * regexp within declarations of listed properties. + */ + props?: string[]; + /** + * Used to narrow down values and speed up the regexp search. Searching + * every single value with a regexp can be slow. If you pass a fast + * string, PostCSS will first check whether the value contains the fast + * string; and only if it does will PostCSS check that value against + * regexp. For example, instead of just checking for /\d+rem/ on all + * values, set fast: 'rem' to first check whether a value has the rem + * unit, and only if it does perform the regexp check. + */ + fast?: string; + }, callbackOrReplaceValue: string | { + (substring: string, ...args: any[]): string; + }): this; + replaceValues(pattern: string | RegExp, callbackOrReplaceValue: string | { + (substring: string, ...args: any[]): string; + }): this; + /** + * Inserts new nodes to the beginning of the container. + * Because each node class is identifiable by unique properties, use the + * following shortcuts to create nodes in insert methods: + * root.prepend({ name: '@charset', params: '"UTF-8"' }); // at-rule + * root.prepend({ selector: 'a' }); // rule + * rule.prepend({ prop: 'color', value: 'black' }); // declaration + * rule.prepend({ text: 'Comment' }) // comment + * A string containing the CSS of the new element can also be used. This + * approach is slower than the above shortcuts. + * root.prepend('a {}'); + * root.first.prepend('color: black; z-index: 1'); + * @param nodes New nodes. + * @returns This container for chaining. + */ + prepend(...nodes: (Node | Object | string)[]): this; + /** + * Inserts new nodes to the end of the container. + * Because each node class is identifiable by unique properties, use the + * following shortcuts to create nodes in insert methods: + * root.append({ name: '@charset', params: '"UTF-8"' }); // at-rule + * root.append({ selector: 'a' }); // rule + * rule.append({ prop: 'color', value: 'black' }); // declaration + * rule.append({ text: 'Comment' }) // comment + * A string containing the CSS of the new element can also be used. This + * approach is slower than the above shortcuts. + * root.append('a {}'); + * root.first.append('color: black; z-index: 1'); + * @param nodes New nodes. + * @returns This container for chaining. + */ + append(...nodes: (Node | Object | string)[]): this; + /** + * Insert newNode before oldNode within the container. + * @param oldNode Child or child's index. + * @returns This container for chaining. + */ + insertBefore(oldNode: Node | number, newNode: Node | Object | string): this; + /** + * Insert newNode after oldNode within the container. + * @param oldNode Child or child's index. + * @returns This container for chaining. + */ + insertAfter(oldNode: Node | number, newNode: Node | Object | string): this; + /** + * Removes the container from its parent and cleans the parent property in the + * container and its children. + * @returns This container for chaining. + */ + remove(): this; + /** + * Removes child from the container and cleans the parent properties + * from the node and its children. + * @param child Child or child's index. + * @returns This container for chaining. + */ + removeChild(child: Node | number): this; + /** + * Removes all children from the container and cleans their parent + * properties. + * @returns This container for chaining. + */ + removeAll(): this; + } + interface ContainerNewProps extends NodeNewProps { + /** + * Contains the container's children. + */ + nodes?: Node[]; + raws?: ContainerRaws; + } + interface ContainerRaws extends NodeRaws { + indent?: string; + } + interface JsonContainer extends JsonNode { + /** + * Contains the container's children. + */ + nodes?: Node[]; + /** + * @returns The container's first child. + */ + first?: Node; + /** + * @returns The container's last child. + */ + last?: Node; + } + /** + * Represents a CSS file and contains all its parsed nodes. + */ + interface Root extends Container { + /** + * Inherited from Container. Should always be undefined for a Root node. + */ + parent: Container; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + /** + * @returns A Result instance representing the root's CSS. + */ + toResult(options?: { + /** + * The path where you'll put the output CSS file. You should always + * set "to" to generate correct source maps. + */ + to?: string; + map?: SourceMapOptions; + }): Result; + /** + * Deprecated. Use Root#removeChild. + */ + remove(child?: Node | number): this; + /** + * Removes child from the root node, and the parent properties of node and + * its children. + * @param child Child or child's index. + * @returns This root node for chaining. + */ + removeChild(child: Node | number): this; + } + interface RootNewProps extends ContainerNewProps { + } + interface JsonRoot extends JsonContainer { + } + /** + * Represents an at-rule. If it's followed in the CSS by a {} block, this + * node will have a nodes property representing its children. + */ + interface AtRule extends Container { + /** + * The identifier that immediately follows the @. + */ + name: string; + /** + * These are the values that follow the at-rule's name, but precede any {} + * block. The spec refers to this area as the at-rule's "prelude". + */ + params: string; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + } + interface AtRuleNewProps extends ContainerNewProps { + /** + * The identifier that immediately follows the @. + */ + name?: string; + /** + * These are the values that follow the at-rule's name, but precede any {} + * block. The spec refers to this area as the at-rule's "prelude". + */ + params?: string | number; + raws?: AtRuleRaws; + } + interface AtRuleRaws extends NodeRaws { + params?: string; + } + interface JsonAtRule extends JsonContainer { + /** + * The identifier that immediately follows the @. + */ + name?: string; + /** + * These are the values that follow the at-rule's name, but precede any {} + * block. The spec refers to this area as the at-rule's "prelude". + */ + params?: string; + } + /** + * Represents a CSS rule: a selector followed by a declaration block. + */ + interface Rule extends Container { + /** + * Returns the rule's parent node. + */ + parent: Container; + /** + * The rule's full selector. If there are multiple comma-separated selectors, + * the entire group will be included. + */ + selector: string; + /** + * An array containing the rule's individual selectors. + * Groups of selectors are split at commas. + */ + selectors?: string[]; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + } + interface RuleNewProps extends ContainerNewProps { + /** + * The rule's full selector. If there are multiple comma-separated selectors, + * the entire group will be included. + */ + selector?: string; + /** + * An array containing the rule's individual selectors. Groups of selectors + * are split at commas. + */ + selectors?: string[]; + raws?: RuleRaws; + } + interface RuleRaws extends ContainerRaws { + /** + * The rule's full selector. If there are multiple comma-separated selectors, + * the entire group will be included. + */ + selector?: string; + } + interface JsonRule extends JsonContainer { + /** + * The rule's full selector. If there are multiple comma-separated selectors, + * the entire group will be included. + */ + selector?: string; + /** + * An array containing the rule's individual selectors. + * Groups of selectors are split at commas. + */ + selectors?: string[]; + } + /** + * Represents a CSS declaration. + */ + interface Declaration extends Node { + /** + * The declaration's property name. + */ + prop: string; + /** + * The declaration's value. This value will be cleaned of comments. If the + * source value contained comments, those comments will be available in the + * _value.raws property. If you have not changed the value, the result of + * decl.toString() will include the original raws value (comments and all). + */ + value: string; + /** + * True if the declaration has an !important annotation. + */ + important: boolean; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + } + interface DeclarationNewProps { + /** + * The declaration's property name. + */ + prop?: string; + /** + * The declaration's value. This value will be cleaned of comments. If the + * source value contained comments, those comments will be available in the + * _value.raws property. If you have not changed the value, the result of + * decl.toString() will include the original raws value (comments and all). + */ + value?: string; + raws?: DeclarationRaws; + } + interface DeclarationRaws extends NodeRaws { + /** + * The declaration's value. This value will be cleaned of comments. + * If the source value contained comments, those comments will be + * available in the _value.raws property. If you have not changed the value, the result of + * decl.toString() will include the original raws value (comments and all). + */ + value?: string; + } + interface JsonDeclaration extends JsonNode { + /** + * True if the declaration has an !important annotation. + */ + important?: boolean; + } + /** + * Represents a comment between declarations or statements (rule and at-rules). + * Comments inside selectors, at-rule parameters, or declaration values will + * be stored in the Node#raws properties. + */ + interface Comment extends Node { + /** + * The comment's text. + */ + text: string; + /** + * @param overrides New properties to override in the clone. + * @returns A clone of this node. The node and its (cloned) children will + * have a clean parent and code style properties. + */ + clone(overrides?: Object): this; + } + interface CommentNewProps { + /** + * The comment's text. + */ + text?: string; + } + interface JsonComment extends JsonNode { + } +} +export = postcss; diff --git a/node_modules/postcss/lib/postcss.js b/node_modules/postcss/lib/postcss.js new file mode 100644 index 00000000..b0be50d0 --- /dev/null +++ b/node_modules/postcss/lib/postcss.js @@ -0,0 +1,292 @@ +'use strict'; + +exports.__esModule = true; + +var _declaration = require('./declaration'); + +var _declaration2 = _interopRequireDefault(_declaration); + +var _processor = require('./processor'); + +var _processor2 = _interopRequireDefault(_processor); + +var _stringify = require('./stringify'); + +var _stringify2 = _interopRequireDefault(_stringify); + +var _comment = require('./comment'); + +var _comment2 = _interopRequireDefault(_comment); + +var _atRule = require('./at-rule'); + +var _atRule2 = _interopRequireDefault(_atRule); + +var _vendor = require('./vendor'); + +var _vendor2 = _interopRequireDefault(_vendor); + +var _parse = require('./parse'); + +var _parse2 = _interopRequireDefault(_parse); + +var _list = require('./list'); + +var _list2 = _interopRequireDefault(_list); + +var _rule = require('./rule'); + +var _rule2 = _interopRequireDefault(_rule); + +var _root = require('./root'); + +var _root2 = _interopRequireDefault(_root); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Create a new {@link Processor} instance that will apply `plugins` + * as CSS processors. + * + * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS + * plugins. See {@link Processor#use} for plugin format. + * + * @return {Processor} Processor to process multiple CSS + * + * @example + * import postcss from 'postcss'; + * + * postcss(plugins).process(css, { from, to }).then(result => { + * console.log(result.css); + * }); + * + * @namespace postcss + */ +function postcss() { + for (var _len = arguments.length, plugins = Array(_len), _key = 0; _key < _len; _key++) { + plugins[_key] = arguments[_key]; + } + + if (plugins.length === 1 && Array.isArray(plugins[0])) { + plugins = plugins[0]; + } + return new _processor2.default(plugins); +} + +/** + * Creates a PostCSS plugin with a standard API. + * + * The newly-wrapped function will provide both the name and PostCSS + * version of the plugin. + * + * ```js + * const processor = postcss([replace]); + * processor.plugins[0].postcssPlugin //=> 'postcss-replace' + * processor.plugins[0].postcssVersion //=> '5.1.0' + * ``` + * + * The plugin function receives 2 arguments: {@link Root} + * and {@link Result} instance. The function should mutate the provided + * `Root` node. Alternatively, you can create a new `Root` node + * and override the `result.root` property. + * + * ```js + * const cleaner = postcss.plugin('postcss-cleaner', () => { + * return (root, result) => { + * result.root = postcss.root(); + * }; + * }); + * ``` + * + * As a convenience, plugins also expose a `process` method so that you can use + * them as standalone tools. + * + * ```js + * cleaner.process(css, options); + * // This is equivalent to: + * postcss([ cleaner(options) ]).process(css); + * ``` + * + * Asynchronous plugins should return a `Promise` instance. + * + * ```js + * postcss.plugin('postcss-import', () => { + * return (root, result) => { + * return new Promise( (resolve, reject) => { + * fs.readFile('base.css', (base) => { + * root.prepend(base); + * resolve(); + * }); + * }); + * }; + * }); + * ``` + * + * Add warnings using the {@link Node#warn} method. + * Send data to other plugins using the {@link Result#messages} array. + * + * ```js + * postcss.plugin('postcss-caniuse-test', () => { + * return (root, result) => { + * css.walkDecls(decl => { + * if ( !caniuse.support(decl.prop) ) { + * decl.warn(result, 'Some browsers do not support ' + decl.prop); + * } + * }); + * }; + * }); + * ``` + * + * @param {string} name - PostCSS plugin name. Same as in `name` + * property in `package.json`. It will be saved + * in `plugin.postcssPlugin` property. + * @param {function} initializer - will receive plugin options + * and should return {@link pluginFunction} + * + * @return {Plugin} PostCSS plugin + */ +postcss.plugin = function plugin(name, initializer) { + var creator = function creator() { + var transformer = initializer.apply(undefined, arguments); + transformer.postcssPlugin = name; + transformer.postcssVersion = new _processor2.default().version; + return transformer; + }; + + var cache = void 0; + Object.defineProperty(creator, 'postcss', { + get: function get() { + if (!cache) cache = creator(); + return cache; + } + }); + + creator.process = function (root, opts) { + return postcss([creator(opts)]).process(root, opts); + }; + + return creator; +}; + +/** + * Default function to convert a node tree into a CSS string. + * + * @param {Node} node - start node for stringifing. Usually {@link Root}. + * @param {builder} builder - function to concatenate CSS from node’s parts + * or generate string and source map + * + * @return {void} + * + * @function + */ +postcss.stringify = _stringify2.default; + +/** + * Parses source css and returns a new {@link Root} node, + * which contains the source CSS nodes. + * + * @param {string|toString} css - string with input CSS or any object + * with toString() method, like a Buffer + * @param {processOptions} [opts] - options with only `from` and `map` keys + * + * @return {Root} PostCSS AST + * + * @example + * // Simple CSS concatenation with source map support + * const root1 = postcss.parse(css1, { from: file1 }); + * const root2 = postcss.parse(css2, { from: file2 }); + * root1.append(root2).toResult().css; + * + * @function + */ +postcss.parse = _parse2.default; + +/** + * @member {vendor} - Contains the {@link vendor} module. + * + * @example + * postcss.vendor.unprefixed('-moz-tab') //=> ['tab'] + */ +postcss.vendor = _vendor2.default; + +/** + * @member {list} - Contains the {@link list} module. + * + * @example + * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)'] + */ +postcss.list = _list2.default; + +/** + * Creates a new {@link Comment} node. + * + * @param {object} [defaults] - properties for the new node. + * + * @return {Comment} new Comment node + * + * @example + * postcss.comment({ text: 'test' }) + */ +postcss.comment = function (defaults) { + return new _comment2.default(defaults); +}; + +/** + * Creates a new {@link AtRule} node. + * + * @param {object} [defaults] - properties for the new node. + * + * @return {AtRule} new AtRule node + * + * @example + * postcss.atRule({ name: 'charset' }).toString() //=> "@charset" + */ +postcss.atRule = function (defaults) { + return new _atRule2.default(defaults); +}; + +/** + * Creates a new {@link Declaration} node. + * + * @param {object} [defaults] - properties for the new node. + * + * @return {Declaration} new Declaration node + * + * @example + * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> "color: red" + */ +postcss.decl = function (defaults) { + return new _declaration2.default(defaults); +}; + +/** + * Creates a new {@link Rule} node. + * + * @param {object} [defaults] - properties for the new node. + * + * @return {AtRule} new Rule node + * + * @example + * postcss.rule({ selector: 'a' }).toString() //=> "a {\n}" + */ +postcss.rule = function (defaults) { + return new _rule2.default(defaults); +}; + +/** + * Creates a new {@link Root} node. + * + * @param {object} [defaults] - properties for the new node. + * + * @return {Root} new Root node + * + * @example + * postcss.root({ after: '\n' }).toString() //=> "\n" + */ +postcss.root = function (defaults) { + return new _root2.default(defaults); +}; + +exports.default = postcss; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["postcss.es6"],"names":["postcss","plugins","length","Array","isArray","plugin","name","initializer","creator","transformer","postcssPlugin","postcssVersion","version","cache","Object","defineProperty","get","process","root","opts","stringify","parse","vendor","list","comment","defaults","atRule","decl","rule"],"mappings":";;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA;;;;;;;;;;;;;;;;;;AAkBA,SAASA,OAAT,GAA6B;AAAA,oCAATC,OAAS;AAATA,WAAS;AAAA;;AACzB,MAAKA,QAAQC,MAAR,KAAmB,CAAnB,IAAwBC,MAAMC,OAAN,CAAcH,QAAQ,CAAR,CAAd,CAA7B,EAAyD;AACrDA,cAAUA,QAAQ,CAAR,CAAV;AACH;AACD,SAAO,wBAAcA,OAAd,CAAP;AACH;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEAD,QAAQK,MAAR,GAAiB,SAASA,MAAT,CAAgBC,IAAhB,EAAsBC,WAAtB,EAAmC;AAChD,MAAIC,UAAU,SAAVA,OAAU,GAAmB;AAC7B,QAAIC,cAAcF,uCAAlB;AACAE,gBAAYC,aAAZ,GAA6BJ,IAA7B;AACAG,gBAAYE,cAAZ,GAA8B,yBAAD,CAAkBC,OAA/C;AACA,WAAOH,WAAP;AACH,GALD;;AAOA,MAAII,cAAJ;AACAC,SAAOC,cAAP,CAAsBP,OAAtB,EAA+B,SAA/B,EAA0C;AACtCQ,OADsC,iBAChC;AACF,UAAK,CAACH,KAAN,EAAcA,QAAQL,SAAR;AACd,aAAOK,KAAP;AACH;AAJqC,GAA1C;;AAOAL,UAAQS,OAAR,GAAkB,UAAUC,IAAV,EAAgBC,IAAhB,EAAsB;AACpC,WAAOnB,QAAQ,CAAEQ,QAAQW,IAAR,CAAF,CAAR,EAA2BF,OAA3B,CAAmCC,IAAnC,EAAyCC,IAAzC,CAAP;AACH,GAFD;;AAIA,SAAOX,OAAP;AACH,CArBD;;AAuBA;;;;;;;;;;;AAWAR,QAAQoB,SAAR;;AAEA;;;;;;;;;;;;;;;;;;AAkBApB,QAAQqB,KAAR;;AAEA;;;;;;AAMArB,QAAQsB,MAAR;;AAEA;;;;;;AAMAtB,QAAQuB,IAAR;;AAEA;;;;;;;;;;AAUAvB,QAAQwB,OAAR,GAAkB;AAAA,SAAY,sBAAYC,QAAZ,CAAZ;AAAA,CAAlB;;AAEA;;;;;;;;;;AAUAzB,QAAQ0B,MAAR,GAAiB;AAAA,SAAY,qBAAWD,QAAX,CAAZ;AAAA,CAAjB;;AAEA;;;;;;;;;;AAUAzB,QAAQ2B,IAAR,GAAe;AAAA,SAAY,0BAAgBF,QAAhB,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUAzB,QAAQ4B,IAAR,GAAe;AAAA,SAAY,mBAASH,QAAT,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUAzB,QAAQkB,IAAR,GAAe;AAAA,SAAY,mBAASO,QAAT,CAAZ;AAAA,CAAf;;kBAEezB,O","file":"postcss.js","sourcesContent":["import Declaration from './declaration';\nimport Processor   from './processor';\nimport stringify   from './stringify';\nimport Comment     from './comment';\nimport AtRule      from './at-rule';\nimport vendor      from './vendor';\nimport parse       from './parse';\nimport list        from './list';\nimport Rule        from './rule';\nimport Root        from './root';\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS\n *        plugins. See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS\n *\n * @example\n * import postcss from 'postcss';\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css);\n * });\n *\n * @namespace postcss\n */\nfunction postcss(...plugins) {\n    if ( plugins.length === 1 && Array.isArray(plugins[0]) ) {\n        plugins = plugins[0];\n    }\n    return new Processor(plugins);\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n *  const processor = postcss([replace]);\n *  processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n *  processor.plugins[0].postcssVersion //=> '5.1.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root();\n *   };\n * });\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, options);\n * // This is equivalent to:\n * postcss([ cleaner(options) ]).process(css);\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base);\n *         resolve();\n *       });\n *     });\n *   };\n * });\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     css.walkDecls(decl => {\n *       if ( !caniuse.support(decl.prop) ) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop);\n *       }\n *     });\n *   };\n * });\n * ```\n *\n * @param {string} name          - PostCSS plugin name. Same as in `name`\n *                                 property in `package.json`. It will be saved\n *                                 in `plugin.postcssPlugin` property.\n * @param {function} initializer - will receive plugin options\n *                                 and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin\n */\npostcss.plugin = function plugin(name, initializer) {\n    let creator = function (...args) {\n        let transformer = initializer(...args);\n        transformer.postcssPlugin  = name;\n        transformer.postcssVersion = (new Processor()).version;\n        return transformer;\n    };\n\n    let cache;\n    Object.defineProperty(creator, 'postcss', {\n        get() {\n            if ( !cache ) cache = creator();\n            return cache;\n        }\n    });\n\n    creator.process = function (root, opts) {\n        return postcss([ creator(opts) ]).process(root, opts);\n    };\n\n    return creator;\n};\n\n/**\n * Default function to convert a node tree into a CSS string.\n *\n * @param {Node} node       - start node for stringifing. Usually {@link Root}.\n * @param {builder} builder - function to concatenate CSS from node’s parts\n *                            or generate string and source map\n *\n * @return {void}\n *\n * @function\n */\npostcss.stringify = stringify;\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\n *\n * @param {string|toString} css   - string with input CSS or any object\n *                                  with toString() method, like a Buffer\n * @param {processOptions} [opts] - options with only `from` and `map` keys\n *\n * @return {Root} PostCSS AST\n *\n * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 });\n * const root2 = postcss.parse(css2, { from: file2 });\n * root1.append(root2).toResult().css;\n *\n * @function\n */\npostcss.parse = parse;\n\n/**\n * @member {vendor} - Contains the {@link vendor} module.\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = vendor;\n\n/**\n * @member {list} - Contains the {@link list} module.\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = list;\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Comment} new Comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = defaults => new Comment(defaults);\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {AtRule} new AtRule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = defaults => new AtRule(defaults);\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Declaration} new Declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = defaults => new Declaration(defaults);\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {AtRule} new Rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = defaults => new Rule(defaults);\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Root} new Root node\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = defaults => new Root(defaults);\n\nexport default postcss;\n"]} diff --git a/node_modules/postcss/lib/previous-map.js b/node_modules/postcss/lib/previous-map.js new file mode 100644 index 00000000..71b8e268 --- /dev/null +++ b/node_modules/postcss/lib/previous-map.js @@ -0,0 +1,162 @@ +'use strict'; + +exports.__esModule = true; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _jsBase = require('js-base64'); + +var _sourceMap = require('source-map'); + +var _sourceMap2 = _interopRequireDefault(_sourceMap); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _fs = require('fs'); + +var _fs2 = _interopRequireDefault(_fs); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Source map information from input CSS. + * For example, source map after Sass compiler. + * + * This class will automatically find source map in input CSS or in file system + * near input file (according `from` option). + * + * @example + * const root = postcss.parse(css, { from: 'a.sass.css' }); + * root.input.map //=> PreviousMap + */ +var PreviousMap = function () { + + /** + * @param {string} css - input CSS source + * @param {processOptions} [opts] - {@link Processor#process} options + */ + function PreviousMap(css, opts) { + _classCallCheck(this, PreviousMap); + + this.loadAnnotation(css); + /** + * @member {boolean} - Was source map inlined by data-uri to input CSS. + */ + this.inline = this.startWith(this.annotation, 'data:'); + + var prev = opts.map ? opts.map.prev : undefined; + var text = this.loadMap(opts.from, prev); + if (text) this.text = text; + } + + /** + * Create a instance of `SourceMapGenerator` class + * from the `source-map` library to work with source map information. + * + * It is lazy method, so it will create object only on first call + * and then it will use cache. + * + * @return {SourceMapGenerator} object with source map information + */ + + + PreviousMap.prototype.consumer = function consumer() { + if (!this.consumerCache) { + this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text); + } + return this.consumerCache; + }; + + /** + * Does source map contains `sourcesContent` with input source text. + * + * @return {boolean} Is `sourcesContent` present + */ + + + PreviousMap.prototype.withContent = function withContent() { + return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0); + }; + + PreviousMap.prototype.startWith = function startWith(string, start) { + if (!string) return false; + return string.substr(0, start.length) === start; + }; + + PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) { + var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//); + if (match) this.annotation = match[1].trim(); + }; + + PreviousMap.prototype.decodeInline = function decodeInline(text) { + var utfd64 = 'data:application/json;charset=utf-8;base64,'; + var utf64 = 'data:application/json;charset=utf8;base64,'; + var b64 = 'data:application/json;base64,'; + var uri = 'data:application/json,'; + + if (this.startWith(text, uri)) { + return decodeURIComponent(text.substr(uri.length)); + } else if (this.startWith(text, b64)) { + return _jsBase.Base64.decode(text.substr(b64.length)); + } else if (this.startWith(text, utf64)) { + return _jsBase.Base64.decode(text.substr(utf64.length)); + } else if (this.startWith(text, utfd64)) { + return _jsBase.Base64.decode(text.substr(utfd64.length)); + } else { + var encoding = text.match(/data:application\/json;([^,]+),/)[1]; + throw new Error('Unsupported source map encoding ' + encoding); + } + }; + + PreviousMap.prototype.loadMap = function loadMap(file, prev) { + if (prev === false) return false; + + if (prev) { + if (typeof prev === 'string') { + return prev; + } else if (typeof prev === 'function') { + var prevPath = prev(file); + if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) { + return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim(); + } else { + throw new Error('Unable to load previous source map: ' + prevPath.toString()); + } + } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) { + return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString(); + } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) { + return prev.toString(); + } else if (this.isMap(prev)) { + return JSON.stringify(prev); + } else { + throw new Error('Unsupported previous source map format: ' + prev.toString()); + } + } else if (this.inline) { + return this.decodeInline(this.annotation); + } else if (this.annotation) { + var map = this.annotation; + if (file) map = _path2.default.join(_path2.default.dirname(file), map); + + this.root = _path2.default.dirname(map); + if (_fs2.default.existsSync && _fs2.default.existsSync(map)) { + return _fs2.default.readFileSync(map, 'utf-8').toString().trim(); + } else { + return false; + } + } + }; + + PreviousMap.prototype.isMap = function isMap(map) { + if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false; + return typeof map.mappings === 'string' || typeof map._mappings === 'string'; + }; + + return PreviousMap; +}(); + +exports.default = PreviousMap; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","from","consumer","consumerCache","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","match","trim","decodeInline","utfd64","utf64","b64","uri","decodeURIComponent","decode","encoding","Error","file","prevPath","existsSync","readFileSync","toString","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","join","dirname","root","mappings","_mappings"],"mappings":"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","file":"previous-map.js","sourcesContent":["import { Base64 } from 'js-base64';\nimport   mozilla  from 'source-map';\nimport   path     from 'path';\nimport   fs       from 'fs';\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' });\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n\n    /**\n     * @param {string}         css    - input CSS source\n     * @param {processOptions} [opts] - {@link Processor#process} options\n     */\n    constructor(css, opts) {\n        this.loadAnnotation(css);\n        /**\n         * @member {boolean} - Was source map inlined by data-uri to input CSS.\n         */\n        this.inline = this.startWith(this.annotation, 'data:');\n\n        let prev = opts.map ? opts.map.prev : undefined;\n        let text = this.loadMap(opts.from, prev);\n        if ( text ) this.text = text;\n    }\n\n    /**\n     * Create a instance of `SourceMapGenerator` class\n     * from the `source-map` library to work with source map information.\n     *\n     * It is lazy method, so it will create object only on first call\n     * and then it will use cache.\n     *\n     * @return {SourceMapGenerator} object with source map information\n     */\n    consumer() {\n        if ( !this.consumerCache ) {\n            this.consumerCache = new mozilla.SourceMapConsumer(this.text);\n        }\n        return this.consumerCache;\n    }\n\n    /**\n     * Does source map contains `sourcesContent` with input source text.\n     *\n     * @return {boolean} Is `sourcesContent` present\n     */\n    withContent() {\n        return !!(this.consumer().sourcesContent &&\n                  this.consumer().sourcesContent.length > 0);\n    }\n\n    startWith(string, start) {\n        if ( !string ) return false;\n        return string.substr(0, start.length) === start;\n    }\n\n    loadAnnotation(css) {\n        let match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//);\n        if ( match ) this.annotation = match[1].trim();\n    }\n\n    decodeInline(text) {\n        let utfd64 = 'data:application/json;charset=utf-8;base64,';\n        let utf64  = 'data:application/json;charset=utf8;base64,';\n        let b64    = 'data:application/json;base64,';\n        let uri    = 'data:application/json,';\n\n        if ( this.startWith(text, uri) ) {\n            return decodeURIComponent( text.substr(uri.length) );\n\n        } else if ( this.startWith(text, b64) ) {\n            return Base64.decode( text.substr(b64.length) );\n\n        } else if ( this.startWith(text, utf64) ) {\n            return Base64.decode( text.substr(utf64.length) );\n\n        } else if ( this.startWith(text, utfd64) ) {\n            return Base64.decode( text.substr(utfd64.length) );\n\n        } else {\n            let encoding = text.match(/data:application\\/json;([^,]+),/)[1];\n            throw new Error('Unsupported source map encoding ' + encoding);\n        }\n    }\n\n    loadMap(file, prev) {\n        if ( prev === false ) return false;\n\n        if ( prev ) {\n            if ( typeof prev === 'string' ) {\n                return prev;\n            } else if ( typeof prev === 'function' ) {\n                let prevPath = prev(file);\n                if ( prevPath && fs.existsSync && fs.existsSync(prevPath) ) {\n                    return fs.readFileSync(prevPath, 'utf-8').toString().trim();\n                } else {\n                    throw new Error('Unable to load previous source map: ' +\n                    prevPath.toString());\n                }\n            } else if ( prev instanceof mozilla.SourceMapConsumer ) {\n                return mozilla.SourceMapGenerator\n                    .fromSourceMap(prev).toString();\n            } else if ( prev instanceof mozilla.SourceMapGenerator ) {\n                return prev.toString();\n            } else if ( this.isMap(prev) ) {\n                return JSON.stringify(prev);\n            } else {\n                throw new Error('Unsupported previous source map format: ' +\n                    prev.toString());\n            }\n\n        } else if ( this.inline ) {\n            return this.decodeInline(this.annotation);\n\n        } else if ( this.annotation ) {\n            let map = this.annotation;\n            if ( file ) map = path.join(path.dirname(file), map);\n\n            this.root = path.dirname(map);\n            if ( fs.existsSync && fs.existsSync(map) ) {\n                return fs.readFileSync(map, 'utf-8').toString().trim();\n            } else {\n                return false;\n            }\n        }\n    }\n\n    isMap(map) {\n        if ( typeof map !== 'object' ) return false;\n        return typeof map.mappings === 'string' ||\n               typeof map._mappings === 'string';\n    }\n}\n\nexport default PreviousMap;\n"]} diff --git a/node_modules/postcss/lib/processor.js b/node_modules/postcss/lib/processor.js new file mode 100644 index 00000000..b8b3bd87 --- /dev/null +++ b/node_modules/postcss/lib/processor.js @@ -0,0 +1,240 @@ +'use strict'; + +exports.__esModule = true; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _lazyResult = require('./lazy-result'); + +var _lazyResult2 = _interopRequireDefault(_lazyResult); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Contains plugins to process CSS. Create one `Processor` instance, + * initialize its plugins, and then use that instance on numerous CSS files. + * + * @example + * const processor = postcss([autoprefixer, precss]); + * processor.process(css1).then(result => console.log(result.css)); + * processor.process(css2).then(result => console.log(result.css)); + */ +var Processor = function () { + + /** + * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS + * plugins. See {@link Processor#use} for plugin format. + */ + function Processor() { + var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + _classCallCheck(this, Processor); + + /** + * @member {string} - Current PostCSS version. + * + * @example + * if ( result.processor.version.split('.')[0] !== '5' ) { + * throw new Error('This plugin works only with PostCSS 5'); + * } + */ + this.version = '5.2.18'; + /** + * @member {pluginFunction[]} - Plugins added to this processor. + * + * @example + * const processor = postcss([autoprefixer, precss]); + * processor.plugins.length //=> 2 + */ + this.plugins = this.normalize(plugins); + } + + /** + * Adds a plugin to be used as a CSS processor. + * + * PostCSS plugin can be in 4 formats: + * * A plugin created by {@link postcss.plugin} method. + * * A function. PostCSS will pass the function a @{link Root} + * as the first argument and current {@link Result} instance + * as the second. + * * An object with a `postcss` method. PostCSS will use that method + * as described in #2. + * * Another {@link Processor} instance. PostCSS will copy plugins + * from that instance into this one. + * + * Plugins can also be added by passing them as arguments when creating + * a `postcss` instance (see [`postcss(plugins)`]). + * + * Asynchronous plugins should return a `Promise` instance. + * + * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin + * or {@link Processor} + * with plugins + * + * @example + * const processor = postcss() + * .use(autoprefixer) + * .use(precss); + * + * @return {Processes} current processor to make methods chain + */ + + + Processor.prototype.use = function use(plugin) { + this.plugins = this.plugins.concat(this.normalize([plugin])); + return this; + }; + + /** + * Parses source CSS and returns a {@link LazyResult} Promise proxy. + * Because some plugins can be asynchronous it doesn’t make + * any transformations. Transformations will be applied + * in the {@link LazyResult} methods. + * + * @param {string|toString|Result} css - String with input CSS or + * any object with a `toString()` + * method, like a Buffer. + * Optionally, send a {@link Result} + * instance and the processor will + * take the {@link Root} from it. + * @param {processOptions} [opts] - options + * + * @return {LazyResult} Promise proxy + * + * @example + * processor.process(css, { from: 'a.css', to: 'a.out.css' }) + * .then(result => { + * console.log(result.css); + * }); + */ + + + Processor.prototype.process = function process(css) { + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + return new _lazyResult2.default(this, css, opts); + }; + + Processor.prototype.normalize = function normalize(plugins) { + var normalized = []; + for (var _iterator = plugins, _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.postcss) i = i.postcss; + + if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && Array.isArray(i.plugins)) { + normalized = normalized.concat(i.plugins); + } else if (typeof i === 'function') { + normalized.push(i); + } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && (i.parse || i.stringify)) { + throw new Error('PostCSS syntaxes cannot be used as plugins. ' + 'Instead, please use one of the ' + 'syntax/parser/stringifier options as ' + 'outlined in your PostCSS ' + 'runner documentation.'); + } else { + throw new Error(i + ' is not a PostCSS plugin'); + } + } + return normalized; + }; + + return Processor; +}(); + +exports.default = Processor; + +/** + * @callback builder + * @param {string} part - part of generated CSS connected to this node + * @param {Node} node - AST node + * @param {"start"|"end"} [type] - node’s part type + */ + +/** + * @callback parser + * + * @param {string|toString} css - string with input CSS or any object + * with toString() method, like a Buffer + * @param {processOptions} [opts] - options with only `from` and `map` keys + * + * @return {Root} PostCSS AST + */ + +/** + * @callback stringifier + * + * @param {Node} node - start node for stringifing. Usually {@link Root}. + * @param {builder} builder - function to concatenate CSS from node’s parts + * or generate string and source map + * + * @return {void} + */ + +/** + * @typedef {object} syntax + * @property {parser} parse - function to generate AST by string + * @property {stringifier} stringify - function to generate string by AST + */ + +/** + * @typedef {object} toString + * @property {function} toString + */ + +/** + * @callback pluginFunction + * @param {Root} root - parsed input CSS + * @param {Result} result - result to set warnings or check other plugins + */ + +/** + * @typedef {object} Plugin + * @property {function} postcss - PostCSS plugin function + */ + +/** + * @typedef {object} processOptions + * @property {string} from - the path of the CSS source file. + * You should always set `from`, + * because it is used in source map + * generation and syntax error messages. + * @property {string} to - the path where you’ll put the output + * CSS file. You should always set `to` + * to generate correct source maps. + * @property {parser} parser - function to generate AST by string + * @property {stringifier} stringifier - class to generate string by AST + * @property {syntax} syntax - object with `parse` and `stringify` + * @property {object} map - source map options + * @property {boolean} map.inline - does source map should + * be embedded in the output + * CSS as a base64-encoded + * comment + * @property {string|object|false|function} map.prev - source map content + * from a previous + * processing step + * (for example, Sass). + * PostCSS will try to find + * previous map + * automatically, so you + * could disable it by + * `false` value. + * @property {boolean} map.sourcesContent - does PostCSS should set + * the origin content to map + * @property {string|false} map.annotation - does PostCSS should set + * annotation comment to map + * @property {string} map.from - override `from` in map’s + * `sources` + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["processor.es6"],"names":["Processor","plugins","version","normalize","use","plugin","concat","process","css","opts","normalized","i","postcss","Array","isArray","push","parse","stringify","Error"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;IASMA,S;;AAEF;;;;AAIA,uBAA0B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AACtB;;;;;;;;AAQA,SAAKC,OAAL,GAAe,QAAf;AACA;;;;;;;AAOA,SAAKD,OAAL,GAAe,KAAKE,SAAL,CAAeF,OAAf,CAAf;AACH;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6BAG,G,gBAAIC,M,EAAQ;AACR,SAAKJ,OAAL,GAAe,KAAKA,OAAL,CAAaK,MAAb,CAAoB,KAAKH,SAAL,CAAe,CAACE,MAAD,CAAf,CAApB,CAAf;AACA,WAAO,IAAP;AACH,G;;AAED;;;;;;;;;;;;;;;;;;;;;;;;sBAsBAE,O,oBAAQC,G,EAAiB;AAAA,QAAZC,IAAY,uEAAL,EAAK;;AACrB,WAAO,yBAAe,IAAf,EAAqBD,GAArB,EAA0BC,IAA1B,CAAP;AACH,G;;sBAEDN,S,sBAAUF,O,EAAS;AACf,QAAIS,aAAa,EAAjB;AACA,yBAAeT,OAAf,kHAAyB;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,UAAfU,CAAe;;AACrB,UAAKA,EAAEC,OAAP,EAAiBD,IAAIA,EAAEC,OAAN;;AAEjB,UAAK,QAAOD,CAAP,yCAAOA,CAAP,OAAa,QAAb,IAAyBE,MAAMC,OAAN,CAAcH,EAAEV,OAAhB,CAA9B,EAAyD;AACrDS,qBAAaA,WAAWJ,MAAX,CAAkBK,EAAEV,OAApB,CAAb;AACH,OAFD,MAEO,IAAK,OAAOU,CAAP,KAAa,UAAlB,EAA+B;AAClCD,mBAAWK,IAAX,CAAgBJ,CAAhB;AACH,OAFM,MAEA,IAAK,QAAOA,CAAP,yCAAOA,CAAP,OAAa,QAAb,KAA0BA,EAAEK,KAAF,IAAWL,EAAEM,SAAvC,CAAL,EAAyD;AAC5D,cAAM,IAAIC,KAAJ,CAAU,iDACA,iCADA,GAEA,uCAFA,GAGA,2BAHA,GAIA,uBAJV,CAAN;AAKH,OANM,MAMA;AACH,cAAM,IAAIA,KAAJ,CAAUP,IAAI,0BAAd,CAAN;AACH;AACJ;AACD,WAAOD,UAAP;AACH,G;;;;;kBAIUV,S;;AAEf;;;;;;;AAOA;;;;;;;;;;AAUA;;;;;;;;;;AAUA;;;;;;AAMA;;;;;AAKA;;;;;;AAMA;;;;;AAKA","file":"processor.js","sourcesContent":["import LazyResult  from './lazy-result';\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss]);\n * processor.process(css1).then(result => console.log(result.css));\n * processor.process(css2).then(result => console.log(result.css));\n */\nclass Processor {\n\n    /**\n     * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS\n     *        plugins. See {@link Processor#use} for plugin format.\n     */\n    constructor(plugins = []) {\n        /**\n         * @member {string} - Current PostCSS version.\n         *\n         * @example\n         * if ( result.processor.version.split('.')[0] !== '5' ) {\n         *   throw new Error('This plugin works only with PostCSS 5');\n         * }\n         */\n        this.version = '5.2.18';\n        /**\n         * @member {pluginFunction[]} - Plugins added to this processor.\n         *\n         * @example\n         * const processor = postcss([autoprefixer, precss]);\n         * processor.plugins.length //=> 2\n         */\n        this.plugins = this.normalize(plugins);\n    }\n\n    /**\n     * Adds a plugin to be used as a CSS processor.\n     *\n     * PostCSS plugin can be in 4 formats:\n     * * A plugin created by {@link postcss.plugin} method.\n     * * A function. PostCSS will pass the function a @{link Root}\n     *   as the first argument and current {@link Result} instance\n     *   as the second.\n     * * An object with a `postcss` method. PostCSS will use that method\n     *   as described in #2.\n     * * Another {@link Processor} instance. PostCSS will copy plugins\n     *   from that instance into this one.\n     *\n     * Plugins can also be added by passing them as arguments when creating\n     * a `postcss` instance (see [`postcss(plugins)`]).\n     *\n     * Asynchronous plugins should return a `Promise` instance.\n     *\n     * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin\n     *                                                   or {@link Processor}\n     *                                                   with plugins\n     *\n     * @example\n     * const processor = postcss()\n     *   .use(autoprefixer)\n     *   .use(precss);\n     *\n     * @return {Processes} current processor to make methods chain\n     */\n    use(plugin) {\n        this.plugins = this.plugins.concat(this.normalize([plugin]));\n        return this;\n    }\n\n    /**\n     * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n     * Because some plugins can be asynchronous it doesn’t make\n     * any transformations. Transformations will be applied\n     * in the {@link LazyResult} methods.\n     *\n     * @param {string|toString|Result} css - String with input CSS or\n     *                                       any object with a `toString()`\n     *                                       method, like a Buffer.\n     *                                       Optionally, send a {@link Result}\n     *                                       instance and the processor will\n     *                                       take the {@link Root} from it.\n     * @param {processOptions} [opts]      - options\n     *\n     * @return {LazyResult} Promise proxy\n     *\n     * @example\n     * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n     *   .then(result => {\n     *      console.log(result.css);\n     *   });\n     */\n    process(css, opts = { }) {\n        return new LazyResult(this, css, opts);\n    }\n\n    normalize(plugins) {\n        let normalized = [];\n        for ( let i of plugins ) {\n            if ( i.postcss ) i = i.postcss;\n\n            if ( typeof i === 'object' && Array.isArray(i.plugins) ) {\n                normalized = normalized.concat(i.plugins);\n            } else if ( typeof i === 'function' ) {\n                normalized.push(i);\n            } else if ( typeof i === 'object' && (i.parse || i.stringify) ) {\n                throw new Error('PostCSS syntaxes cannot be used as plugins. ' +\n                                'Instead, please use one of the ' +\n                                'syntax/parser/stringifier options as ' +\n                                'outlined in your PostCSS ' +\n                                'runner documentation.');\n            } else {\n                throw new Error(i + ' is not a PostCSS plugin');\n            }\n        }\n        return normalized;\n    }\n\n}\n\nexport default Processor;\n\n/**\n * @callback builder\n * @param {string} part          - part of generated CSS connected to this node\n * @param {Node}   node          - AST node\n * @param {\"start\"|\"end\"} [type] - node’s part type\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   - string with input CSS or any object\n *                                  with toString() method, like a Buffer\n * @param {processOptions} [opts] - options with only `from` and `map` keys\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       - start node for stringifing. Usually {@link Root}.\n * @param {builder} builder - function to concatenate CSS from node’s parts\n *                            or generate string and source map\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          - function to generate AST by string\n * @property {stringifier} stringify - function to generate string by AST\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     - parsed input CSS\n * @param {Result} result - result to set warnings or check other plugins\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss - PostCSS plugin function\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             - the path of the CSS source file.\n *                                       You should always set `from`,\n *                                       because it is used in source map\n *                                       generation and syntax error messages.\n * @property {string} to               - the path where you’ll put the output\n *                                       CSS file. You should always set `to`\n *                                       to generate correct source maps.\n * @property {parser} parser           - function to generate AST by string\n * @property {stringifier} stringifier - class to generate string by AST\n * @property {syntax} syntax           - object with `parse` and `stringify`\n * @property {object} map              - source map options\n * @property {boolean} map.inline                    - does source map should\n *                                                     be embedded in the output\n *                                                     CSS as a base64-encoded\n *                                                     comment\n * @property {string|object|false|function} map.prev - source map content\n *                                                     from a previous\n *                                                     processing step\n *                                                     (for example, Sass).\n *                                                     PostCSS will try to find\n *                                                     previous map\n *                                                     automatically, so you\n *                                                     could disable it by\n *                                                     `false` value.\n * @property {boolean} map.sourcesContent            - does PostCSS should set\n *                                                     the origin content to map\n * @property {string|false} map.annotation           - does PostCSS should set\n *                                                     annotation comment to map\n * @property {string} map.from                       - override `from` in map’s\n *                                                     `sources`\n */\n"]} diff --git a/node_modules/postcss/lib/result.js b/node_modules/postcss/lib/result.js new file mode 100644 index 00000000..2b3da76d --- /dev/null +++ b/node_modules/postcss/lib/result.js @@ -0,0 +1,206 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _warning = require('./warning'); + +var _warning2 = _interopRequireDefault(_warning); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Provides the result of the PostCSS transformations. + * + * A Result instance is returned by {@link LazyResult#then} + * or {@link Root#toResult} methods. + * + * @example + * postcss([cssnext]).process(css).then(function (result) { + * console.log(result.css); + * }); + * + * @example + * var result2 = postcss.parse(css).toResult(); + */ +var Result = function () { + + /** + * @param {Processor} processor - processor used for this transformation. + * @param {Root} root - Root node after all transformations. + * @param {processOptions} opts - options from the {@link Processor#process} + * or {@link Root#toResult} + */ + function Result(processor, root, opts) { + _classCallCheck(this, Result); + + /** + * @member {Processor} - The Processor instance used + * for this transformation. + * + * @example + * for ( let plugin of result.processor.plugins) { + * if ( plugin.postcssPlugin === 'postcss-bad' ) { + * throw 'postcss-good is incompatible with postcss-bad'; + * } + * }); + */ + this.processor = processor; + /** + * @member {Message[]} - Contains messages from plugins + * (e.g., warnings or custom messages). + * Each message should have type + * and plugin properties. + * + * @example + * postcss.plugin('postcss-min-browser', () => { + * return (root, result) => { + * var browsers = detectMinBrowsersByCanIUse(root); + * result.messages.push({ + * type: 'min-browser', + * plugin: 'postcss-min-browser', + * browsers: browsers + * }); + * }; + * }); + */ + this.messages = []; + /** + * @member {Root} - Root node after all transformations. + * + * @example + * root.toResult().root == root; + */ + this.root = root; + /** + * @member {processOptions} - Options from the {@link Processor#process} + * or {@link Root#toResult} call + * that produced this Result instance. + * + * @example + * root.toResult(opts).opts == opts; + */ + this.opts = opts; + /** + * @member {string} - A CSS string representing of {@link Result#root}. + * + * @example + * postcss.parse('a{}').toResult().css //=> "a{}" + */ + this.css = undefined; + /** + * @member {SourceMapGenerator} - An instance of `SourceMapGenerator` + * class from the `source-map` library, + * representing changes + * to the {@link Result#root} instance. + * + * @example + * result.map.toJSON() //=> { version: 3, file: 'a.css', … } + * + * @example + * if ( result.map ) { + * fs.writeFileSync(result.opts.to + '.map', result.map.toString()); + * } + */ + this.map = undefined; + } + + /** + * Returns for @{link Result#css} content. + * + * @example + * result + '' === result.css + * + * @return {string} string representing of {@link Result#root} + */ + + + Result.prototype.toString = function toString() { + return this.css; + }; + + /** + * Creates an instance of {@link Warning} and adds it + * to {@link Result#messages}. + * + * @param {string} text - warning message + * @param {Object} [opts] - warning options + * @param {Node} opts.node - CSS node that caused the warning + * @param {string} opts.word - word in CSS source that caused the warning + * @param {number} opts.index - index in CSS node string that caused + * the warning + * @param {string} opts.plugin - name of the plugin that created + * this warning. {@link Result#warn} fills + * this property automatically. + * + * @return {Warning} created warning + */ + + + Result.prototype.warn = function warn(text) { + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (!opts.plugin) { + if (this.lastPlugin && this.lastPlugin.postcssPlugin) { + opts.plugin = this.lastPlugin.postcssPlugin; + } + } + + var warning = new _warning2.default(text, opts); + this.messages.push(warning); + + return warning; + }; + + /** + * Returns warnings from plugins. Filters {@link Warning} instances + * from {@link Result#messages}. + * + * @example + * result.warnings().forEach(warn => { + * console.warn(warn.toString()); + * }); + * + * @return {Warning[]} warnings from plugins + */ + + + Result.prototype.warnings = function warnings() { + return this.messages.filter(function (i) { + return i.type === 'warning'; + }); + }; + + /** + * An alias for the {@link Result#css} property. + * Use it with syntaxes that generate non-CSS output. + * @type {string} + * + * @example + * result.css === result.content; + */ + + + _createClass(Result, [{ + key: 'content', + get: function get() { + return this.css; + } + }]); + + return Result; +}(); + +exports.default = Result; + +/** + * @typedef {object} Message + * @property {string} type - message type + * @property {string} plugin - source PostCSS plugin name + */ + +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["result.es6"],"names":["Result","processor","root","opts","messages","css","undefined","map","toString","warn","text","plugin","lastPlugin","postcssPlugin","warning","push","warnings","filter","i","type"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;;;;;;IAcMA,M;;AAEF;;;;;;AAMA,kBAAYC,SAAZ,EAAuBC,IAAvB,EAA6BC,IAA7B,EAAmC;AAAA;;AAC/B;;;;;;;;;;;AAWA,SAAKF,SAAL,GAAiBA,SAAjB;AACA;;;;;;;;;;;;;;;;;;AAkBA,SAAKG,QAAL,GAAgB,EAAhB;AACA;;;;;;AAMA,SAAKF,IAAL,GAAYA,IAAZ;AACA;;;;;;;;AAQA,SAAKC,IAAL,GAAYA,IAAZ;AACA;;;;;;AAMA,SAAKE,GAAL,GAAWC,SAAX;AACA;;;;;;;;;;;;;;AAcA,SAAKC,GAAL,GAAWD,SAAX;AACH;;AAED;;;;;;;;;;mBAQAE,Q,uBAAW;AACP,WAAO,KAAKH,GAAZ;AACH,G;;AAED;;;;;;;;;;;;;;;;;;mBAgBAI,I,iBAAKC,I,EAAkB;AAAA,QAAZP,IAAY,uEAAL,EAAK;;AACnB,QAAK,CAACA,KAAKQ,MAAX,EAAoB;AAChB,UAAK,KAAKC,UAAL,IAAmB,KAAKA,UAAL,CAAgBC,aAAxC,EAAwD;AACpDV,aAAKQ,MAAL,GAAc,KAAKC,UAAL,CAAgBC,aAA9B;AACH;AACJ;;AAED,QAAIC,UAAU,sBAAYJ,IAAZ,EAAkBP,IAAlB,CAAd;AACA,SAAKC,QAAL,CAAcW,IAAd,CAAmBD,OAAnB;;AAEA,WAAOA,OAAP;AACH,G;;AAED;;;;;;;;;;;;;mBAWAE,Q,uBAAW;AACP,WAAO,KAAKZ,QAAL,CAAca,MAAd,CAAsB;AAAA,aAAKC,EAAEC,IAAF,KAAW,SAAhB;AAAA,KAAtB,CAAP;AACH,G;;AAED;;;;;;;;;;;;wBAQc;AACV,aAAO,KAAKd,GAAZ;AACH;;;;;;kBAIUL,M;;AAEf","file":"result.js","sourcesContent":["import Warning from './warning';\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([cssnext]).process(css).then(function (result) {\n *    console.log(result.css);\n * });\n *\n * @example\n * var result2 = postcss.parse(css).toResult();\n */\nclass Result {\n\n    /**\n     * @param {Processor} processor - processor used for this transformation.\n     * @param {Root}      root      - Root node after all transformations.\n     * @param {processOptions} opts - options from the {@link Processor#process}\n     *                                or {@link Root#toResult}\n     */\n    constructor(processor, root, opts) {\n        /**\n         * @member {Processor} - The Processor instance used\n         *                       for this transformation.\n         *\n         * @example\n         * for ( let plugin of result.processor.plugins) {\n         *   if ( plugin.postcssPlugin === 'postcss-bad' ) {\n         *     throw 'postcss-good is incompatible with postcss-bad';\n         *   }\n         * });\n         */\n        this.processor = processor;\n        /**\n         * @member {Message[]} - Contains messages from plugins\n         *                       (e.g., warnings or custom messages).\n         *                       Each message should have type\n         *                       and plugin properties.\n         *\n         * @example\n         * postcss.plugin('postcss-min-browser', () => {\n         *   return (root, result) => {\n         *     var browsers = detectMinBrowsersByCanIUse(root);\n         *     result.messages.push({\n         *       type:    'min-browser',\n         *       plugin:  'postcss-min-browser',\n         *       browsers: browsers\n         *     });\n         *   };\n         * });\n         */\n        this.messages = [];\n        /**\n         * @member {Root} - Root node after all transformations.\n         *\n         * @example\n         * root.toResult().root == root;\n         */\n        this.root = root;\n        /**\n         * @member {processOptions} - Options from the {@link Processor#process}\n         *                            or {@link Root#toResult} call\n         *                            that produced this Result instance.\n         *\n         * @example\n         * root.toResult(opts).opts == opts;\n         */\n        this.opts = opts;\n        /**\n         * @member {string} - A CSS string representing of {@link Result#root}.\n         *\n         * @example\n         * postcss.parse('a{}').toResult().css //=> \"a{}\"\n         */\n        this.css = undefined;\n        /**\n         * @member {SourceMapGenerator} - An instance of `SourceMapGenerator`\n         *                                class from the `source-map` library,\n         *                                representing changes\n         *                                to the {@link Result#root} instance.\n         *\n         * @example\n         * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n         *\n         * @example\n         * if ( result.map ) {\n         *   fs.writeFileSync(result.opts.to + '.map', result.map.toString());\n         * }\n         */\n        this.map = undefined;\n    }\n\n    /**\n     * Returns for @{link Result#css} content.\n     *\n     * @example\n     * result + '' === result.css\n     *\n     * @return {string} string representing of {@link Result#root}\n     */\n    toString() {\n        return this.css;\n    }\n\n    /**\n     * Creates an instance of {@link Warning} and adds it\n     * to {@link Result#messages}.\n     *\n     * @param {string} text        - warning message\n     * @param {Object} [opts]      - warning options\n     * @param {Node}   opts.node   - CSS node that caused the warning\n     * @param {string} opts.word   - word in CSS source that caused the warning\n     * @param {number} opts.index  - index in CSS node string that caused\n     *                               the warning\n     * @param {string} opts.plugin - name of the plugin that created\n     *                               this warning. {@link Result#warn} fills\n     *                               this property automatically.\n     *\n     * @return {Warning} created warning\n     */\n    warn(text, opts = { }) {\n        if ( !opts.plugin ) {\n            if ( this.lastPlugin && this.lastPlugin.postcssPlugin ) {\n                opts.plugin = this.lastPlugin.postcssPlugin;\n            }\n        }\n\n        let warning = new Warning(text, opts);\n        this.messages.push(warning);\n\n        return warning;\n    }\n\n    /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString());\n     * });\n     *\n     * @return {Warning[]} warnings from plugins\n     */\n    warnings() {\n        return this.messages.filter( i => i.type === 'warning' );\n    }\n\n    /**\n     * An alias for the {@link Result#css} property.\n     * Use it with syntaxes that generate non-CSS output.\n     * @type {string}\n     *\n     * @example\n     * result.css === result.content;\n     */\n    get content() {\n        return this.css;\n    }\n\n}\n\nexport default Result;\n\n/**\n * @typedef  {object} Message\n * @property {string} type   - message type\n * @property {string} plugin - source PostCSS plugin name\n */\n"]} diff --git a/node_modules/postcss/lib/root.js b/node_modules/postcss/lib/root.js new file mode 100644 index 00000000..0e7b136b --- /dev/null +++ b/node_modules/postcss/lib/root.js @@ -0,0 +1,143 @@ +'use strict'; + +exports.__esModule = true; + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Represents a CSS file and contains all its parsed nodes. + * + * @extends Container + * + * @example + * const root = postcss.parse('a{color:black} b{z-index:2}'); + * root.type //=> 'root' + * root.nodes.length //=> 2 + */ +var Root = function (_Container) { + _inherits(Root, _Container); + + function Root(defaults) { + _classCallCheck(this, Root); + + var _this = _possibleConstructorReturn(this, _Container.call(this, defaults)); + + _this.type = 'root'; + if (!_this.nodes) _this.nodes = []; + return _this; + } + + Root.prototype.removeChild = function removeChild(child) { + child = this.index(child); + + if (child === 0 && this.nodes.length > 1) { + this.nodes[1].raws.before = this.nodes[child].raws.before; + } + + return _Container.prototype.removeChild.call(this, child); + }; + + Root.prototype.normalize = function normalize(child, sample, type) { + var nodes = _Container.prototype.normalize.call(this, child); + + if (sample) { + if (type === 'prepend') { + if (this.nodes.length > 1) { + sample.raws.before = this.nodes[1].raws.before; + } else { + delete sample.raws.before; + } + } else if (this.first !== sample) { + for (var _iterator = 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; + + node.raws.before = sample.raws.before; + } + } + } + + return nodes; + }; + + /** + * Returns a {@link Result} instance representing the root’s CSS. + * + * @param {processOptions} [opts] - options with only `to` and `map` keys + * + * @return {Result} result with current root’s CSS + * + * @example + * const root1 = postcss.parse(css1, { from: 'a.css' }); + * const root2 = postcss.parse(css2, { from: 'b.css' }); + * root1.append(root2); + * const result = root1.toResult({ to: 'all.css', map: true }); + */ + + + Root.prototype.toResult = function toResult() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var LazyResult = require('./lazy-result'); + var Processor = require('./processor'); + + var lazy = new LazyResult(new Processor(), this, opts); + return lazy.stringify(); + }; + + Root.prototype.remove = function remove(child) { + (0, _warnOnce2.default)('Root#remove is deprecated. Use Root#removeChild'); + this.removeChild(child); + }; + + Root.prototype.prevMap = function prevMap() { + (0, _warnOnce2.default)('Root#prevMap is deprecated. Use Root#source.input.map'); + return this.source.input.map; + }; + + /** + * @memberof Root# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `after`: the space symbols after the last child to the end of file. + * * `semicolon`: is the last child has an (optional) semicolon. + * + * @example + * postcss.parse('a {}\n').raws //=> { after: '\n' } + * postcss.parse('a {}').raws //=> { after: '' } + */ + + return Root; +}(_container2.default); + +exports.default = Root; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/rule.js b/node_modules/postcss/lib/rule.js new file mode 100644 index 00000000..2935bff5 --- /dev/null +++ b/node_modules/postcss/lib/rule.js @@ -0,0 +1,136 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _warnOnce = require('./warn-once'); + +var _warnOnce2 = _interopRequireDefault(_warnOnce); + +var _list = require('./list'); + +var _list2 = _interopRequireDefault(_list); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Represents a CSS rule: a selector followed by a declaration block. + * + * @extends Container + * + * @example + * const root = postcss.parse('a{}'); + * const rule = root.first; + * rule.type //=> 'rule' + * rule.toString() //=> 'a{}' + */ +var Rule = function (_Container) { + _inherits(Rule, _Container); + + function Rule(defaults) { + _classCallCheck(this, Rule); + + var _this = _possibleConstructorReturn(this, _Container.call(this, defaults)); + + _this.type = 'rule'; + if (!_this.nodes) _this.nodes = []; + return _this; + } + + /** + * An array containing the rule’s individual selectors. + * Groups of selectors are split at commas. + * + * @type {string[]} + * + * @example + * const root = postcss.parse('a, b { }'); + * const rule = root.first; + * + * rule.selector //=> 'a, b' + * rule.selectors //=> ['a', 'b'] + * + * rule.selectors = ['a', 'strong']; + * rule.selector //=> 'a, strong' + */ + + + _createClass(Rule, [{ + key: 'selectors', + get: function get() { + return _list2.default.comma(this.selector); + }, + set: function set(values) { + var match = this.selector ? this.selector.match(/,\s*/) : null; + var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen'); + this.selector = values.join(sep); + } + }, { + key: '_selector', + get: function get() { + (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector'); + return this.raws.selector; + }, + set: function set(val) { + (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector'); + this.raws.selector = val; + } + + /** + * @memberof Rule# + * @member {string} selector - the rule’s full selector represented + * as a string + * + * @example + * const root = postcss.parse('a, b { }'); + * const rule = root.first; + * rule.selector //=> 'a, b' + */ + + /** + * @memberof Rule# + * @member {object} raws - Information to generate byte-to-byte equal + * node string as it was in the origin input. + * + * Every parser saves its own properties, + * but the default CSS parser uses: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * + * PostCSS cleans selectors from comments and extra spaces, + * but it stores origin content in raws properties. + * As such, if you don’t change a declaration’s value, + * PostCSS will use the raw value with comments. + * + * @example + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '', between: ' ', after: '\n' } + */ + + }]); + + return Rule; +}(_container2.default); + +exports.default = Rule; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/stringifier.js b/node_modules/postcss/lib/stringifier.js new file mode 100644 index 00000000..f8db1cd0 --- /dev/null +++ b/node_modules/postcss/lib/stringifier.js @@ -0,0 +1,335 @@ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var defaultRaw = { + colon: ': ', + indent: ' ', + beforeDecl: '\n', + beforeRule: '\n', + beforeOpen: ' ', + beforeClose: '\n', + beforeComment: '\n', + after: '\n', + emptyBody: '', + commentLeft: ' ', + commentRight: ' ' +}; + +function capitalize(str) { + return str[0].toUpperCase() + str.slice(1); +} + +var Stringifier = function () { + function Stringifier(builder) { + _classCallCheck(this, Stringifier); + + this.builder = builder; + } + + Stringifier.prototype.stringify = function stringify(node, semicolon) { + this[node.type](node, semicolon); + }; + + Stringifier.prototype.root = function root(node) { + this.body(node); + if (node.raws.after) this.builder(node.raws.after); + }; + + Stringifier.prototype.comment = function comment(node) { + var left = this.raw(node, 'left', 'commentLeft'); + var right = this.raw(node, 'right', 'commentRight'); + this.builder('/*' + left + node.text + right + '*/', node); + }; + + Stringifier.prototype.decl = function decl(node, semicolon) { + var between = this.raw(node, 'between', 'colon'); + var string = node.prop + between + this.rawValue(node, 'value'); + + if (node.important) { + string += node.raws.important || ' !important'; + } + + if (semicolon) string += ';'; + this.builder(string, node); + }; + + Stringifier.prototype.rule = function rule(node) { + this.block(node, this.rawValue(node, 'selector')); + }; + + Stringifier.prototype.atrule = function atrule(node, semicolon) { + var name = '@' + node.name; + var params = node.params ? this.rawValue(node, 'params') : ''; + + if (typeof node.raws.afterName !== 'undefined') { + name += node.raws.afterName; + } else if (params) { + name += ' '; + } + + if (node.nodes) { + this.block(node, name + params); + } else { + var end = (node.raws.between || '') + (semicolon ? ';' : ''); + this.builder(name + params + end, node); + } + }; + + Stringifier.prototype.body = function body(node) { + var last = node.nodes.length - 1; + while (last > 0) { + if (node.nodes[last].type !== 'comment') break; + last -= 1; + } + + var semicolon = this.raw(node, 'semicolon'); + for (var i = 0; i < node.nodes.length; i++) { + var child = node.nodes[i]; + var before = this.raw(child, 'before'); + if (before) this.builder(before); + this.stringify(child, last !== i || semicolon); + } + }; + + Stringifier.prototype.block = function block(node, start) { + var between = this.raw(node, 'between', 'beforeOpen'); + this.builder(start + between + '{', node, 'start'); + + var after = void 0; + if (node.nodes && node.nodes.length) { + this.body(node); + after = this.raw(node, 'after'); + } else { + after = this.raw(node, 'after', 'emptyBody'); + } + + if (after) this.builder(after); + this.builder('}', node, 'end'); + }; + + Stringifier.prototype.raw = function raw(node, own, detect) { + var value = void 0; + if (!detect) detect = own; + + // Already had + if (own) { + value = node.raws[own]; + if (typeof value !== 'undefined') return value; + } + + var parent = node.parent; + + // Hack for first rule in CSS + if (detect === 'before') { + if (!parent || parent.type === 'root' && parent.first === node) { + return ''; + } + } + + // Floating child without parent + if (!parent) return defaultRaw[detect]; + + // Detect style by other nodes + var root = node.root(); + if (!root.rawCache) root.rawCache = {}; + if (typeof root.rawCache[detect] !== 'undefined') { + return root.rawCache[detect]; + } + + if (detect === 'before' || detect === 'after') { + return this.beforeAfter(node, detect); + } else { + var method = 'raw' + capitalize(detect); + if (this[method]) { + value = this[method](root, node); + } else { + root.walk(function (i) { + value = i.raws[own]; + if (typeof value !== 'undefined') return false; + }); + } + } + + if (typeof value === 'undefined') value = defaultRaw[detect]; + + root.rawCache[detect] = value; + return value; + }; + + Stringifier.prototype.rawSemicolon = function rawSemicolon(root) { + var value = void 0; + root.walk(function (i) { + if (i.nodes && i.nodes.length && i.last.type === 'decl') { + value = i.raws.semicolon; + if (typeof value !== 'undefined') return false; + } + }); + return value; + }; + + Stringifier.prototype.rawEmptyBody = function rawEmptyBody(root) { + var value = void 0; + root.walk(function (i) { + if (i.nodes && i.nodes.length === 0) { + value = i.raws.after; + if (typeof value !== 'undefined') return false; + } + }); + return value; + }; + + Stringifier.prototype.rawIndent = function rawIndent(root) { + if (root.raws.indent) return root.raws.indent; + var value = void 0; + root.walk(function (i) { + var p = i.parent; + if (p && p !== root && p.parent && p.parent === root) { + if (typeof i.raws.before !== 'undefined') { + var parts = i.raws.before.split('\n'); + value = parts[parts.length - 1]; + value = value.replace(/[^\s]/g, ''); + return false; + } + } + }); + return value; + }; + + Stringifier.prototype.rawBeforeComment = function rawBeforeComment(root, node) { + var value = void 0; + root.walkComments(function (i) { + if (typeof i.raws.before !== 'undefined') { + value = i.raws.before; + if (value.indexOf('\n') !== -1) { + value = value.replace(/[^\n]+$/, ''); + } + return false; + } + }); + if (typeof value === 'undefined') { + value = this.raw(node, null, 'beforeDecl'); + } + return value; + }; + + Stringifier.prototype.rawBeforeDecl = function rawBeforeDecl(root, node) { + var value = void 0; + root.walkDecls(function (i) { + if (typeof i.raws.before !== 'undefined') { + value = i.raws.before; + if (value.indexOf('\n') !== -1) { + value = value.replace(/[^\n]+$/, ''); + } + return false; + } + }); + if (typeof value === 'undefined') { + value = this.raw(node, null, 'beforeRule'); + } + return value; + }; + + Stringifier.prototype.rawBeforeRule = function rawBeforeRule(root) { + var value = void 0; + root.walk(function (i) { + if (i.nodes && (i.parent !== root || root.first !== i)) { + if (typeof i.raws.before !== 'undefined') { + value = i.raws.before; + if (value.indexOf('\n') !== -1) { + value = value.replace(/[^\n]+$/, ''); + } + return false; + } + } + }); + return value; + }; + + Stringifier.prototype.rawBeforeClose = function rawBeforeClose(root) { + var value = void 0; + root.walk(function (i) { + if (i.nodes && i.nodes.length > 0) { + if (typeof i.raws.after !== 'undefined') { + value = i.raws.after; + if (value.indexOf('\n') !== -1) { + value = value.replace(/[^\n]+$/, ''); + } + return false; + } + } + }); + return value; + }; + + Stringifier.prototype.rawBeforeOpen = function rawBeforeOpen(root) { + var value = void 0; + root.walk(function (i) { + if (i.type !== 'decl') { + value = i.raws.between; + if (typeof value !== 'undefined') return false; + } + }); + return value; + }; + + Stringifier.prototype.rawColon = function rawColon(root) { + var value = void 0; + root.walkDecls(function (i) { + if (typeof i.raws.between !== 'undefined') { + value = i.raws.between.replace(/[^\s:]/g, ''); + return false; + } + }); + return value; + }; + + Stringifier.prototype.beforeAfter = function beforeAfter(node, detect) { + var value = void 0; + if (node.type === 'decl') { + value = this.raw(node, null, 'beforeDecl'); + } else if (node.type === 'comment') { + value = this.raw(node, null, 'beforeComment'); + } else if (detect === 'before') { + value = this.raw(node, null, 'beforeRule'); + } else { + value = this.raw(node, null, 'beforeClose'); + } + + var buf = node.parent; + var depth = 0; + while (buf && buf.type !== 'root') { + depth += 1; + buf = buf.parent; + } + + if (value.indexOf('\n') !== -1) { + var indent = this.raw(node, null, 'indent'); + if (indent.length) { + for (var step = 0; step < depth; step++) { + value += indent; + } + } + } + + return value; + }; + + Stringifier.prototype.rawValue = function rawValue(node, prop) { + var value = node[prop]; + var raw = node.raws[prop]; + if (raw && raw.value === value) { + return raw.raw; + } else { + return value; + } + }; + + return Stringifier; +}(); + +exports.default = Stringifier; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["stringifier.es6"],"names":["defaultRaw","colon","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","after","emptyBody","commentLeft","commentRight","capitalize","str","toUpperCase","slice","Stringifier","builder","stringify","node","semicolon","type","root","body","raws","comment","left","raw","right","text","decl","between","string","prop","rawValue","important","rule","block","atrule","name","params","afterName","nodes","end","last","length","i","child","before","start","own","detect","value","parent","first","rawCache","beforeAfter","method","walk","rawSemicolon","rawEmptyBody","rawIndent","p","parts","split","replace","rawBeforeComment","walkComments","indexOf","rawBeforeDecl","walkDecls","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","depth","step"],"mappings":"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","file":"stringifier.js","sourcesContent":["const defaultRaw = {\n    colon:         ': ',\n    indent:        '    ',\n    beforeDecl:    '\\n',\n    beforeRule:    '\\n',\n    beforeOpen:    ' ',\n    beforeClose:   '\\n',\n    beforeComment: '\\n',\n    after:         '\\n',\n    emptyBody:     '',\n    commentLeft:   ' ',\n    commentRight:  ' '\n};\n\nfunction capitalize(str) {\n    return str[0].toUpperCase() + str.slice(1);\n}\n\nclass Stringifier {\n\n    constructor(builder) {\n        this.builder = builder;\n    }\n\n    stringify(node, semicolon) {\n        this[node.type](node, semicolon);\n    }\n\n    root(node) {\n        this.body(node);\n        if ( node.raws.after ) this.builder(node.raws.after);\n    }\n\n    comment(node) {\n        let left  = this.raw(node, 'left',  'commentLeft');\n        let right = this.raw(node, 'right', 'commentRight');\n        this.builder('/*' + left + node.text + right + '*/', node);\n    }\n\n    decl(node, semicolon) {\n        let between = this.raw(node, 'between', 'colon');\n        let string  = node.prop + between + this.rawValue(node, 'value');\n\n        if ( node.important ) {\n            string += node.raws.important || ' !important';\n        }\n\n        if ( semicolon ) string += ';';\n        this.builder(string, node);\n    }\n\n    rule(node) {\n        this.block(node, this.rawValue(node, 'selector'));\n    }\n\n    atrule(node, semicolon) {\n        let name   = '@' + node.name;\n        let params = node.params ? this.rawValue(node, 'params') : '';\n\n        if ( typeof node.raws.afterName !== 'undefined' ) {\n            name += node.raws.afterName;\n        } else if ( params ) {\n            name += ' ';\n        }\n\n        if ( node.nodes ) {\n            this.block(node, name + params);\n        } else {\n            let end = (node.raws.between || '') + (semicolon ? ';' : '');\n            this.builder(name + params + end, node);\n        }\n    }\n\n    body(node) {\n        let last = node.nodes.length - 1;\n        while ( last > 0 ) {\n            if ( node.nodes[last].type !== 'comment' ) break;\n            last -= 1;\n        }\n\n        let semicolon = this.raw(node, 'semicolon');\n        for ( let i = 0; i < node.nodes.length; i++ ) {\n            let child  = node.nodes[i];\n            let before = this.raw(child, 'before');\n            if ( before ) this.builder(before);\n            this.stringify(child, last !== i || semicolon);\n        }\n    }\n\n    block(node, start) {\n        let between = this.raw(node, 'between', 'beforeOpen');\n        this.builder(start + between + '{', node, 'start');\n\n        let after;\n        if ( node.nodes && node.nodes.length ) {\n            this.body(node);\n            after = this.raw(node, 'after');\n        } else {\n            after = this.raw(node, 'after', 'emptyBody');\n        }\n\n        if ( after ) this.builder(after);\n        this.builder('}', node, 'end');\n    }\n\n    raw(node, own, detect) {\n        let value;\n        if ( !detect ) detect = own;\n\n        // Already had\n        if ( own ) {\n            value = node.raws[own];\n            if ( typeof value !== 'undefined' ) return value;\n        }\n\n        let parent = node.parent;\n\n        // Hack for first rule in CSS\n        if ( detect === 'before' ) {\n            if ( !parent || parent.type === 'root' && parent.first === node ) {\n                return '';\n            }\n        }\n\n        // Floating child without parent\n        if ( !parent ) return defaultRaw[detect];\n\n        // Detect style by other nodes\n        let root = node.root();\n        if ( !root.rawCache ) root.rawCache = { };\n        if ( typeof root.rawCache[detect] !== 'undefined' ) {\n            return root.rawCache[detect];\n        }\n\n        if ( detect === 'before' || detect === 'after' ) {\n            return this.beforeAfter(node, detect);\n        } else {\n            let method = 'raw' + capitalize(detect);\n            if ( this[method] ) {\n                value = this[method](root, node);\n            } else {\n                root.walk( i => {\n                    value = i.raws[own];\n                    if ( typeof value !== 'undefined' ) return false;\n                });\n            }\n        }\n\n        if ( typeof value === 'undefined' ) value = defaultRaw[detect];\n\n        root.rawCache[detect] = value;\n        return value;\n    }\n\n    rawSemicolon(root) {\n        let value;\n        root.walk( i => {\n            if ( i.nodes && i.nodes.length && i.last.type === 'decl' ) {\n                value = i.raws.semicolon;\n                if ( typeof value !== 'undefined' ) return false;\n            }\n        });\n        return value;\n    }\n\n    rawEmptyBody(root) {\n        let value;\n        root.walk( i => {\n            if ( i.nodes && i.nodes.length === 0 ) {\n                value = i.raws.after;\n                if ( typeof value !== 'undefined' ) return false;\n            }\n        });\n        return value;\n    }\n\n    rawIndent(root) {\n        if ( root.raws.indent ) return root.raws.indent;\n        let value;\n        root.walk( i => {\n            let p = i.parent;\n            if ( p && p !== root && p.parent && p.parent === root ) {\n                if ( typeof i.raws.before !== 'undefined' ) {\n                    let parts = i.raws.before.split('\\n');\n                    value = parts[parts.length - 1];\n                    value = value.replace(/[^\\s]/g, '');\n                    return false;\n                }\n            }\n        });\n        return value;\n    }\n\n    rawBeforeComment(root, node) {\n        let value;\n        root.walkComments( i => {\n            if ( typeof i.raws.before !== 'undefined' ) {\n                value = i.raws.before;\n                if ( value.indexOf('\\n') !== -1 ) {\n                    value = value.replace(/[^\\n]+$/, '');\n                }\n                return false;\n            }\n        });\n        if ( typeof value === 'undefined' ) {\n            value = this.raw(node, null, 'beforeDecl');\n        }\n        return value;\n    }\n\n    rawBeforeDecl(root, node) {\n        let value;\n        root.walkDecls( i => {\n            if ( typeof i.raws.before !== 'undefined' ) {\n                value = i.raws.before;\n                if ( value.indexOf('\\n') !== -1 ) {\n                    value = value.replace(/[^\\n]+$/, '');\n                }\n                return false;\n            }\n        });\n        if ( typeof value === 'undefined' ) {\n            value = this.raw(node, null, 'beforeRule');\n        }\n        return value;\n    }\n\n    rawBeforeRule(root) {\n        let value;\n        root.walk( i => {\n            if ( i.nodes && (i.parent !== root || root.first !== i) ) {\n                if ( typeof i.raws.before !== 'undefined' ) {\n                    value = i.raws.before;\n                    if ( value.indexOf('\\n') !== -1 ) {\n                        value = value.replace(/[^\\n]+$/, '');\n                    }\n                    return false;\n                }\n            }\n        });\n        return value;\n    }\n\n    rawBeforeClose(root) {\n        let value;\n        root.walk( i => {\n            if ( i.nodes && i.nodes.length > 0 ) {\n                if ( typeof i.raws.after !== 'undefined' ) {\n                    value = i.raws.after;\n                    if ( value.indexOf('\\n') !== -1 ) {\n                        value = value.replace(/[^\\n]+$/, '');\n                    }\n                    return false;\n                }\n            }\n        });\n        return value;\n    }\n\n    rawBeforeOpen(root) {\n        let value;\n        root.walk( i => {\n            if ( i.type !== 'decl' ) {\n                value = i.raws.between;\n                if ( typeof value !== 'undefined' ) return false;\n            }\n        });\n        return value;\n    }\n\n    rawColon(root) {\n        let value;\n        root.walkDecls( i => {\n            if ( typeof i.raws.between !== 'undefined' ) {\n                value = i.raws.between.replace(/[^\\s:]/g, '');\n                return false;\n            }\n        });\n        return value;\n    }\n\n    beforeAfter(node, detect) {\n        let value;\n        if ( node.type === 'decl' ) {\n            value = this.raw(node, null, 'beforeDecl');\n        } else if ( node.type === 'comment' ) {\n            value = this.raw(node, null, 'beforeComment');\n        } else if ( detect === 'before' ) {\n            value = this.raw(node, null, 'beforeRule');\n        } else {\n            value = this.raw(node, null, 'beforeClose');\n        }\n\n        let buf   = node.parent;\n        let depth = 0;\n        while ( buf && buf.type !== 'root' ) {\n            depth += 1;\n            buf = buf.parent;\n        }\n\n        if ( value.indexOf('\\n') !== -1 ) {\n            let indent = this.raw(node, null, 'indent');\n            if ( indent.length ) {\n                for ( let step = 0; step < depth; step++ ) value += indent;\n            }\n        }\n\n        return value;\n    }\n\n    rawValue(node, prop) {\n        let value = node[prop];\n        let raw   = node.raws[prop];\n        if ( raw && raw.value === value ) {\n            return raw.raw;\n        } else {\n            return value;\n        }\n    }\n\n}\n\nexport default Stringifier;\n"]} diff --git a/node_modules/postcss/lib/stringify.js b/node_modules/postcss/lib/stringify.js new file mode 100644 index 00000000..239fad48 --- /dev/null +++ b/node_modules/postcss/lib/stringify.js @@ -0,0 +1,17 @@ +'use strict'; + +exports.__esModule = true; +exports.default = stringify; + +var _stringifier = require('./stringifier'); + +var _stringifier2 = _interopRequireDefault(_stringifier); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function stringify(node, builder) { + var str = new _stringifier2.default(builder); + str.stringify(node); +} +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0cmluZ2lmeS5lczYiXSwibmFtZXMiOlsic3RyaW5naWZ5Iiwibm9kZSIsImJ1aWxkZXIiLCJzdHIiXSwibWFwcGluZ3MiOiI7OztrQkFFd0JBLFM7O0FBRnhCOzs7Ozs7QUFFZSxTQUFTQSxTQUFULENBQW1CQyxJQUFuQixFQUF5QkMsT0FBekIsRUFBa0M7QUFDN0MsUUFBSUMsTUFBTSwwQkFBZ0JELE9BQWhCLENBQVY7QUFDQUMsUUFBSUgsU0FBSixDQUFjQyxJQUFkO0FBQ0giLCJmaWxlIjoic3RyaW5naWZ5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFN0cmluZ2lmaWVyIGZyb20gJy4vc3RyaW5naWZpZXInO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBzdHJpbmdpZnkobm9kZSwgYnVpbGRlcikge1xuICAgIGxldCBzdHIgPSBuZXcgU3RyaW5naWZpZXIoYnVpbGRlcik7XG4gICAgc3RyLnN0cmluZ2lmeShub2RlKTtcbn1cbiJdfQ== diff --git a/node_modules/postcss/lib/terminal-highlight.js b/node_modules/postcss/lib/terminal-highlight.js new file mode 100644 index 00000000..76174745 --- /dev/null +++ b/node_modules/postcss/lib/terminal-highlight.js @@ -0,0 +1,76 @@ +'use strict'; + +exports.__esModule = true; + +var _chalk = require('chalk'); + +var _chalk2 = _interopRequireDefault(_chalk); + +var _tokenize = require('./tokenize'); + +var _tokenize2 = _interopRequireDefault(_tokenize); + +var _input = require('./input'); + +var _input2 = _interopRequireDefault(_input); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var colors = new _chalk2.default.constructor({ enabled: true }); + +var HIGHLIGHT_THEME = { + 'brackets': colors.cyan, + 'at-word': colors.cyan, + 'call': colors.cyan, + 'comment': colors.gray, + 'string': colors.green, + 'class': colors.yellow, + 'hash': colors.magenta, + '(': colors.cyan, + ')': colors.cyan, + '{': colors.yellow, + '}': colors.yellow, + '[': colors.yellow, + ']': colors.yellow, + ':': colors.yellow, + ';': colors.yellow +}; + +function getTokenType(_ref, index, tokens) { + var type = _ref[0], + value = _ref[1]; + + if (type === 'word') { + if (value[0] === '.') { + return 'class'; + } + if (value[0] === '#') { + return 'hash'; + } + } + + var nextToken = tokens[index + 1]; + if (nextToken && (nextToken[0] === 'brackets' || nextToken[0] === '(')) { + return 'call'; + } + + return type; +} + +function terminalHighlight(css) { + var tokens = (0, _tokenize2.default)(new _input2.default(css), { ignoreErrors: true }); + return tokens.map(function (token, index) { + var color = HIGHLIGHT_THEME[getTokenType(token, index, tokens)]; + if (color) { + return token[1].split(/\r?\n/).map(function (i) { + return color(i); + }).join('\n'); + } else { + return token[1]; + } + }).join(''); +} + +exports.default = terminalHighlight; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/tokenize.js b/node_modules/postcss/lib/tokenize.js new file mode 100644 index 00000000..994f1632 --- /dev/null +++ b/node_modules/postcss/lib/tokenize.js @@ -0,0 +1,273 @@ +'use strict'; + +exports.__esModule = true; +exports.default = tokenize; +var SINGLE_QUOTE = 39; +var DOUBLE_QUOTE = 34; +var BACKSLASH = 92; +var SLASH = 47; +var NEWLINE = 10; +var SPACE = 32; +var FEED = 12; +var TAB = 9; +var CR = 13; +var OPEN_SQUARE = 91; +var CLOSE_SQUARE = 93; +var OPEN_PARENTHESES = 40; +var CLOSE_PARENTHESES = 41; +var OPEN_CURLY = 123; +var CLOSE_CURLY = 125; +var SEMICOLON = 59; +var ASTERISK = 42; +var COLON = 58; +var AT = 64; + +var RE_AT_END = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g; +var RE_WORD_END = /[ \n\t\r\f\(\)\{\}:;@!'"\\\]\[#]|\/(?=\*)/g; +var RE_BAD_BRACKET = /.[\\\/\("'\n]/; + +function tokenize(input) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var tokens = []; + var css = input.css.valueOf(); + + var ignore = options.ignoreErrors; + + var code = void 0, + next = void 0, + quote = void 0, + lines = void 0, + last = void 0, + content = void 0, + escape = void 0, + nextLine = void 0, + nextOffset = void 0, + escaped = void 0, + escapePos = void 0, + prev = void 0, + n = void 0; + + var length = css.length; + var offset = -1; + var line = 1; + var pos = 0; + + function unclosed(what) { + throw input.error('Unclosed ' + what, line, pos - offset); + } + + while (pos < length) { + code = css.charCodeAt(pos); + + if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) { + offset = pos; + line += 1; + } + + switch (code) { + case NEWLINE: + case SPACE: + case TAB: + case CR: + case FEED: + next = pos; + do { + next += 1; + code = css.charCodeAt(next); + if (code === NEWLINE) { + offset = next; + line += 1; + } + } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED); + + tokens.push(['space', css.slice(pos, next)]); + pos = next - 1; + break; + + case OPEN_SQUARE: + tokens.push(['[', '[', line, pos - offset]); + break; + + case CLOSE_SQUARE: + tokens.push([']', ']', line, pos - offset]); + break; + + case OPEN_CURLY: + tokens.push(['{', '{', line, pos - offset]); + break; + + case CLOSE_CURLY: + tokens.push(['}', '}', line, pos - offset]); + break; + + case COLON: + tokens.push([':', ':', line, pos - offset]); + break; + + case SEMICOLON: + tokens.push([';', ';', line, pos - offset]); + break; + + case OPEN_PARENTHESES: + prev = tokens.length ? tokens[tokens.length - 1][1] : ''; + n = css.charCodeAt(pos + 1); + if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) { + next = pos; + do { + escaped = false; + next = css.indexOf(')', next + 1); + if (next === -1) { + if (ignore) { + next = pos; + break; + } else { + unclosed('bracket'); + } + } + escapePos = next; + while (css.charCodeAt(escapePos - 1) === BACKSLASH) { + escapePos -= 1; + escaped = !escaped; + } + } while (escaped); + + tokens.push(['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset]); + pos = next; + } else { + next = css.indexOf(')', pos + 1); + content = css.slice(pos, next + 1); + + if (next === -1 || RE_BAD_BRACKET.test(content)) { + tokens.push(['(', '(', line, pos - offset]); + } else { + tokens.push(['brackets', content, line, pos - offset, line, next - offset]); + pos = next; + } + } + + break; + + case CLOSE_PARENTHESES: + tokens.push([')', ')', line, pos - offset]); + break; + + case SINGLE_QUOTE: + case DOUBLE_QUOTE: + quote = code === SINGLE_QUOTE ? '\'' : '"'; + next = pos; + do { + escaped = false; + next = css.indexOf(quote, next + 1); + if (next === -1) { + if (ignore) { + next = pos + 1; + break; + } else { + unclosed('string'); + } + } + escapePos = next; + while (css.charCodeAt(escapePos - 1) === BACKSLASH) { + escapePos -= 1; + escaped = !escaped; + } + } while (escaped); + + content = css.slice(pos, next + 1); + lines = content.split('\n'); + last = lines.length - 1; + + if (last > 0) { + nextLine = line + last; + nextOffset = next - lines[last].length; + } else { + nextLine = line; + nextOffset = offset; + } + + tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset]); + + offset = nextOffset; + line = nextLine; + pos = next; + break; + + case AT: + RE_AT_END.lastIndex = pos + 1; + RE_AT_END.test(css); + if (RE_AT_END.lastIndex === 0) { + next = css.length - 1; + } else { + next = RE_AT_END.lastIndex - 2; + } + tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]); + pos = next; + break; + + case BACKSLASH: + next = pos; + escape = true; + while (css.charCodeAt(next + 1) === BACKSLASH) { + next += 1; + escape = !escape; + } + code = css.charCodeAt(next + 1); + if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) { + next += 1; + } + tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]); + pos = next; + break; + + default: + if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) { + next = css.indexOf('*/', pos + 2) + 1; + if (next === 0) { + if (ignore) { + next = css.length; + } else { + unclosed('comment'); + } + } + + content = css.slice(pos, next + 1); + lines = content.split('\n'); + last = lines.length - 1; + + if (last > 0) { + nextLine = line + last; + nextOffset = next - lines[last].length; + } else { + nextLine = line; + nextOffset = offset; + } + + tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset]); + + offset = nextOffset; + line = nextLine; + pos = next; + } else { + RE_WORD_END.lastIndex = pos + 1; + RE_WORD_END.test(css); + if (RE_WORD_END.lastIndex === 0) { + next = css.length - 1; + } else { + next = RE_WORD_END.lastIndex - 2; + } + + tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset]); + pos = next; + } + + break; + } + + pos++; + } + + return tokens; +} +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["tokenize.es6"],"names":["tokenize","SINGLE_QUOTE","DOUBLE_QUOTE","BACKSLASH","SLASH","NEWLINE","SPACE","FEED","TAB","CR","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","ASTERISK","COLON","AT","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","input","options","tokens","css","valueOf","ignore","ignoreErrors","code","next","quote","lines","last","content","escape","nextLine","nextOffset","escaped","escapePos","prev","n","length","offset","line","pos","unclosed","what","error","charCodeAt","push","slice","indexOf","test","split","lastIndex"],"mappings":"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","file":"tokenize.js","sourcesContent":["const SINGLE_QUOTE      = '\\''.charCodeAt(0);\nconst DOUBLE_QUOTE      =  '\"'.charCodeAt(0);\nconst BACKSLASH         = '\\\\'.charCodeAt(0);\nconst SLASH             =  '/'.charCodeAt(0);\nconst NEWLINE           = '\\n'.charCodeAt(0);\nconst SPACE             =  ' '.charCodeAt(0);\nconst FEED              = '\\f'.charCodeAt(0);\nconst TAB               = '\\t'.charCodeAt(0);\nconst CR                = '\\r'.charCodeAt(0);\nconst OPEN_SQUARE       =  '['.charCodeAt(0);\nconst CLOSE_SQUARE      =  ']'.charCodeAt(0);\nconst OPEN_PARENTHESES  =  '('.charCodeAt(0);\nconst CLOSE_PARENTHESES =  ')'.charCodeAt(0);\nconst OPEN_CURLY        =  '{'.charCodeAt(0);\nconst CLOSE_CURLY       =  '}'.charCodeAt(0);\nconst SEMICOLON         =  ';'.charCodeAt(0);\nconst ASTERISK          =  '*'.charCodeAt(0);\nconst COLON             =  ':'.charCodeAt(0);\nconst AT                =  '@'.charCodeAt(0);\n\nconst RE_AT_END      = /[ \\n\\t\\r\\f\\{\\(\\)'\"\\\\;/\\[\\]#]/g;\nconst RE_WORD_END    = /[ \\n\\t\\r\\f\\(\\)\\{\\}:;@!'\"\\\\\\]\\[#]|\\/(?=\\*)/g;\nconst RE_BAD_BRACKET = /.[\\\\\\/\\(\"'\\n]/;\n\nexport default function tokenize(input, options = { }) {\n    let tokens = [];\n    let css    = input.css.valueOf();\n\n    let ignore = options.ignoreErrors;\n\n    let code, next, quote, lines, last, content, escape,\n        nextLine, nextOffset, escaped, escapePos, prev, n;\n\n    let length = css.length;\n    let offset = -1;\n    let line   =  1;\n    let pos    =  0;\n\n    function unclosed(what) {\n        throw input.error('Unclosed ' + what, line, pos - offset);\n    }\n\n    while ( pos < length ) {\n        code = css.charCodeAt(pos);\n\n        if ( code === NEWLINE || code === FEED ||\n             code === CR && css.charCodeAt(pos + 1) !== NEWLINE ) {\n            offset = pos;\n            line  += 1;\n        }\n\n        switch ( code ) {\n        case NEWLINE:\n        case SPACE:\n        case TAB:\n        case CR:\n        case FEED:\n            next = pos;\n            do {\n                next += 1;\n                code = css.charCodeAt(next);\n                if ( code === NEWLINE ) {\n                    offset = next;\n                    line  += 1;\n                }\n            } while ( code === SPACE   ||\n                      code === NEWLINE ||\n                      code === TAB     ||\n                      code === CR      ||\n                      code === FEED );\n\n            tokens.push(['space', css.slice(pos, next)]);\n            pos = next - 1;\n            break;\n\n        case OPEN_SQUARE:\n            tokens.push(['[', '[', line, pos - offset]);\n            break;\n\n        case CLOSE_SQUARE:\n            tokens.push([']', ']', line, pos - offset]);\n            break;\n\n        case OPEN_CURLY:\n            tokens.push(['{', '{', line, pos - offset]);\n            break;\n\n        case CLOSE_CURLY:\n            tokens.push(['}', '}', line, pos - offset]);\n            break;\n\n        case COLON:\n            tokens.push([':', ':', line, pos - offset]);\n            break;\n\n        case SEMICOLON:\n            tokens.push([';', ';', line, pos - offset]);\n            break;\n\n        case OPEN_PARENTHESES:\n            prev = tokens.length ? tokens[tokens.length - 1][1] : '';\n            n    = css.charCodeAt(pos + 1);\n            if ( prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE &&\n                                   n !== SPACE && n !== NEWLINE && n !== TAB &&\n                                   n !== FEED && n !== CR ) {\n                next = pos;\n                do {\n                    escaped = false;\n                    next    = css.indexOf(')', next + 1);\n                    if ( next === -1 ) {\n                        if ( ignore ) {\n                            next = pos;\n                            break;\n                        } else {\n                            unclosed('bracket');\n                        }\n                    }\n                    escapePos = next;\n                    while ( css.charCodeAt(escapePos - 1) === BACKSLASH ) {\n                        escapePos -= 1;\n                        escaped = !escaped;\n                    }\n                } while ( escaped );\n\n                tokens.push(['brackets', css.slice(pos, next + 1),\n                    line, pos  - offset,\n                    line, next - offset\n                ]);\n                pos = next;\n\n            } else {\n                next    = css.indexOf(')', pos + 1);\n                content = css.slice(pos, next + 1);\n\n                if ( next === -1 || RE_BAD_BRACKET.test(content) ) {\n                    tokens.push(['(', '(', line, pos - offset]);\n                } else {\n                    tokens.push(['brackets', content,\n                        line, pos  - offset,\n                        line, next - offset\n                    ]);\n                    pos = next;\n                }\n            }\n\n            break;\n\n        case CLOSE_PARENTHESES:\n            tokens.push([')', ')', line, pos - offset]);\n            break;\n\n        case SINGLE_QUOTE:\n        case DOUBLE_QUOTE:\n            quote = code === SINGLE_QUOTE ? '\\'' : '\"';\n            next  = pos;\n            do {\n                escaped = false;\n                next    = css.indexOf(quote, next + 1);\n                if ( next === -1 ) {\n                    if ( ignore ) {\n                        next = pos + 1;\n                        break;\n                    } else {\n                        unclosed('string');\n                    }\n                }\n                escapePos = next;\n                while ( css.charCodeAt(escapePos - 1) === BACKSLASH ) {\n                    escapePos -= 1;\n                    escaped = !escaped;\n                }\n            } while ( escaped );\n\n            content = css.slice(pos, next + 1);\n            lines   = content.split('\\n');\n            last    = lines.length - 1;\n\n            if ( last > 0 ) {\n                nextLine   = line + last;\n                nextOffset = next - lines[last].length;\n            } else {\n                nextLine   = line;\n                nextOffset = offset;\n            }\n\n            tokens.push(['string', css.slice(pos, next + 1),\n                line, pos  - offset,\n                nextLine, next - nextOffset\n            ]);\n\n            offset = nextOffset;\n            line   = nextLine;\n            pos    = next;\n            break;\n\n        case AT:\n            RE_AT_END.lastIndex = pos + 1;\n            RE_AT_END.test(css);\n            if ( RE_AT_END.lastIndex === 0 ) {\n                next = css.length - 1;\n            } else {\n                next = RE_AT_END.lastIndex - 2;\n            }\n            tokens.push(['at-word', css.slice(pos, next + 1),\n                line, pos  - offset,\n                line, next - offset\n            ]);\n            pos = next;\n            break;\n\n        case BACKSLASH:\n            next   = pos;\n            escape = true;\n            while ( css.charCodeAt(next + 1) === BACKSLASH ) {\n                next  += 1;\n                escape = !escape;\n            }\n            code = css.charCodeAt(next + 1);\n            if ( escape && (code !== SLASH   &&\n                            code !== SPACE   &&\n                            code !== NEWLINE &&\n                            code !== TAB     &&\n                            code !== CR      &&\n                            code !== FEED ) ) {\n                next += 1;\n            }\n            tokens.push(['word', css.slice(pos, next + 1),\n                line, pos  - offset,\n                line, next - offset\n            ]);\n            pos = next;\n            break;\n\n        default:\n            if ( code === SLASH && css.charCodeAt(pos + 1) === ASTERISK ) {\n                next = css.indexOf('*/', pos + 2) + 1;\n                if ( next === 0 ) {\n                    if ( ignore ) {\n                        next = css.length;\n                    } else {\n                        unclosed('comment');\n                    }\n                }\n\n                content = css.slice(pos, next + 1);\n                lines   = content.split('\\n');\n                last    = lines.length - 1;\n\n                if ( last > 0 ) {\n                    nextLine   = line + last;\n                    nextOffset = next - lines[last].length;\n                } else {\n                    nextLine   = line;\n                    nextOffset = offset;\n                }\n\n                tokens.push(['comment', content,\n                    line,     pos  - offset,\n                    nextLine, next - nextOffset\n                ]);\n\n                offset = nextOffset;\n                line   = nextLine;\n                pos    = next;\n\n            } else {\n                RE_WORD_END.lastIndex = pos + 1;\n                RE_WORD_END.test(css);\n                if ( RE_WORD_END.lastIndex === 0 ) {\n                    next = css.length - 1;\n                } else {\n                    next = RE_WORD_END.lastIndex - 2;\n                }\n\n                tokens.push(['word', css.slice(pos, next + 1),\n                    line, pos  - offset,\n                    line, next - offset\n                ]);\n                pos = next;\n            }\n\n            break;\n        }\n\n        pos++;\n    }\n\n    return tokens;\n}\n"]} diff --git a/node_modules/postcss/lib/vendor.js b/node_modules/postcss/lib/vendor.js new file mode 100644 index 00000000..e8f342e4 --- /dev/null +++ b/node_modules/postcss/lib/vendor.js @@ -0,0 +1,52 @@ +'use strict'; + +exports.__esModule = true; +/** + * Contains helpers for working with vendor prefixes. + * + * @example + * const vendor = postcss.vendor; + * + * @namespace vendor + */ +var vendor = { + + /** + * Returns the vendor prefix extracted from an input string. + * + * @param {string} prop - string with or without vendor prefix + * + * @return {string} vendor prefix or empty string + * + * @example + * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-' + * postcss.vendor.prefix('tab-size') //=> '' + */ + prefix: function prefix(prop) { + var match = prop.match(/^(-\w+-)/); + if (match) { + return match[0]; + } else { + return ''; + } + }, + + + /** + * Returns the input string stripped of its vendor prefix. + * + * @param {string} prop - string with or without vendor prefix + * + * @return {string} string name without vendor prefixes + * + * @example + * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size' + */ + unprefixed: function unprefixed(prop) { + return prop.replace(/^-\w+-/, ''); + } +}; + +exports.default = vendor; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/node_modules/postcss/lib/warn-once.js b/node_modules/postcss/lib/warn-once.js new file mode 100644 index 00000000..00b2e775 --- /dev/null +++ b/node_modules/postcss/lib/warn-once.js @@ -0,0 +1,14 @@ +'use strict'; + +exports.__esModule = true; +exports.default = warnOnce; +var printed = {}; + +function warnOnce(message) { + if (printed[message]) return; + printed[message] = true; + + if (typeof console !== 'undefined' && console.warn) console.warn(message); +} +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndhcm4tb25jZS5lczYiXSwibmFtZXMiOlsid2Fybk9uY2UiLCJwcmludGVkIiwibWVzc2FnZSIsImNvbnNvbGUiLCJ3YXJuIl0sIm1hcHBpbmdzIjoiOzs7a0JBRXdCQSxRO0FBRnhCLElBQUlDLFVBQVUsRUFBZDs7QUFFZSxTQUFTRCxRQUFULENBQWtCRSxPQUFsQixFQUEyQjtBQUN0QyxRQUFLRCxRQUFRQyxPQUFSLENBQUwsRUFBd0I7QUFDeEJELFlBQVFDLE9BQVIsSUFBbUIsSUFBbkI7O0FBRUEsUUFBSyxPQUFPQyxPQUFQLEtBQW1CLFdBQW5CLElBQWtDQSxRQUFRQyxJQUEvQyxFQUFzREQsUUFBUUMsSUFBUixDQUFhRixPQUFiO0FBQ3pEIiwiZmlsZSI6Indhcm4tb25jZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImxldCBwcmludGVkID0geyB9O1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB3YXJuT25jZShtZXNzYWdlKSB7XG4gICAgaWYgKCBwcmludGVkW21lc3NhZ2VdICkgcmV0dXJuO1xuICAgIHByaW50ZWRbbWVzc2FnZV0gPSB0cnVlO1xuXG4gICAgaWYgKCB0eXBlb2YgY29uc29sZSAhPT0gJ3VuZGVmaW5lZCcgJiYgY29uc29sZS53YXJuICkgY29uc29sZS53YXJuKG1lc3NhZ2UpO1xufVxuIl19 diff --git a/node_modules/postcss/lib/warning.js b/node_modules/postcss/lib/warning.js new file mode 100644 index 00000000..bcf0a8b3 --- /dev/null +++ b/node_modules/postcss/lib/warning.js @@ -0,0 +1,122 @@ +'use strict'; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Represents a plugin’s warning. It can be created using {@link Node#warn}. + * + * @example + * if ( decl.important ) { + * decl.warn(result, 'Avoid !important', { word: '!important' }); + * } + */ +var Warning = function () { + + /** + * @param {string} text - warning message + * @param {Object} [opts] - warning options + * @param {Node} opts.node - CSS node that caused the warning + * @param {string} opts.word - word in CSS source that caused the warning + * @param {number} opts.index - index in CSS node string that caused + * the warning + * @param {string} opts.plugin - name of the plugin that created + * this warning. {@link Result#warn} fills + * this property automatically. + */ + function Warning(text) { + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + _classCallCheck(this, Warning); + + /** + * @member {string} - Type to filter warnings from + * {@link Result#messages}. Always equal + * to `"warning"`. + * + * @example + * const nonWarning = result.messages.filter(i => i.type !== 'warning') + */ + this.type = 'warning'; + /** + * @member {string} - The warning message. + * + * @example + * warning.text //=> 'Try to avoid !important' + */ + this.text = text; + + if (opts.node && opts.node.source) { + var pos = opts.node.positionBy(opts); + /** + * @member {number} - Line in the input file + * with this warning’s source + * + * @example + * warning.line //=> 5 + */ + this.line = pos.line; + /** + * @member {number} - Column in the input file + * with this warning’s source. + * + * @example + * warning.column //=> 6 + */ + this.column = pos.column; + } + + for (var opt in opts) { + this[opt] = opts[opt]; + } + } + + /** + * Returns a warning position and message. + * + * @example + * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important' + * + * @return {string} warning position and message + */ + + + Warning.prototype.toString = function toString() { + if (this.node) { + return this.node.error(this.text, { + plugin: this.plugin, + index: this.index, + word: this.word + }).message; + } else if (this.plugin) { + return this.plugin + ': ' + this.text; + } else { + return this.text; + } + }; + + /** + * @memberof Warning# + * @member {string} plugin - The name of the plugin that created + * it will fill this property automatically. + * this warning. When you call {@link Node#warn} + * + * @example + * warning.plugin //=> 'postcss-important' + */ + + /** + * @memberof Warning# + * @member {Node} node - Contains the CSS node that caused the warning. + * + * @example + * warning.node.toString() //=> 'color: white !important' + */ + + return Warning; +}(); + +exports.default = Warning; +module.exports = exports['default']; +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 |