|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
exports.default = void 0;
|
|
|
|
|
|
var _declaration = _interopRequireDefault(require("./declaration"));
|
|
|
|
|
|
var _comment = _interopRequireDefault(require("./comment"));
|
|
|
|
|
|
var _node = _interopRequireDefault(require("./node"));
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
|
|
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); } }
|
|
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
|
|
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; 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 =
|
|
|
/*#__PURE__*/
|
|
|
function (_Node) {
|
|
|
_inheritsLoose(Container, _Node);
|
|
|
|
|
|
function Container() {
|
|
|
return _Node.apply(this, arguments) || this;
|
|
|
}
|
|
|
|
|
|
var _proto = Container.prototype;
|
|
|
|
|
|
_proto.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 (const 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
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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, result;
|
|
|
|
|
|
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.
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.walk = function walk(callback) {
|
|
|
return this.each(function (child, i) {
|
|
|
var result;
|
|
|
|
|
|
try {
|
|
|
result = callback(child, i);
|
|
|
} catch (e) {
|
|
|
e.postcssNode = child;
|
|
|
|
|
|
if (e.stack && child.source && /\n\s{4}at /.test(e.stack)) {
|
|
|
var s = child.source;
|
|
|
e.stack = e.stack.replace(/\n\s{4}at /, "$&" + s.input.from + ":" + s.start.line + ":" + s.start.column + "$&");
|
|
|
}
|
|
|
|
|
|
throw e;
|
|
|
}
|
|
|
|
|
|
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)
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.walkDecls = function walkDecls(prop, callback) {
|
|
|
if (!callback) {
|
|
|
callback = prop;
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'decl') {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (prop instanceof RegExp) {
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'decl' && prop.test(child.prop)) {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
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`)
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.walkRules = function walkRules(selector, callback) {
|
|
|
if (!callback) {
|
|
|
callback = selector;
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'rule') {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (selector instanceof RegExp) {
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'rule' && selector.test(child.selector)) {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
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()
|
|
|
* }
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.walkAtRules = function walkAtRules(name, callback) {
|
|
|
if (!callback) {
|
|
|
callback = name;
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'atrule') {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (name instanceof RegExp) {
|
|
|
return this.walk(function (child, i) {
|
|
|
if (child.type === 'atrule' && name.test(child.name)) {
|
|
|
return callback(child, i);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
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()
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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')
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.append = function append() {
|
|
|
for (var _len = arguments.length, children = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
|
children[_key] = arguments[_key];
|
|
|
}
|
|
|
|
|
|
for (var _i = 0, _children = children; _i < _children.length; _i++) {
|
|
|
var child = _children[_i];
|
|
|
var nodes = this.normalize(child, this.last);
|
|
|
|
|
|
for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
|
|
|
var _ref;
|
|
|
|
|
|
if (_isArray) {
|
|
|
if (_i2 >= _iterator.length) break;
|
|
|
_ref = _iterator[_i2++];
|
|
|
} else {
|
|
|
_i2 = _iterator.next();
|
|
|
if (_i2.done) break;
|
|
|
_ref = _i2.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref;
|
|
|
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')
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.prepend = function prepend() {
|
|
|
for (var _len2 = arguments.length, children = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
|
children[_key2] = arguments[_key2];
|
|
|
}
|
|
|
|
|
|
children = children.reverse();
|
|
|
|
|
|
for (var _iterator2 = children, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
|
|
|
var _ref2;
|
|
|
|
|
|
if (_isArray2) {
|
|
|
if (_i3 >= _iterator2.length) break;
|
|
|
_ref2 = _iterator2[_i3++];
|
|
|
} else {
|
|
|
_i3 = _iterator2.next();
|
|
|
if (_i3.done) break;
|
|
|
_ref2 = _i3.value;
|
|
|
}
|
|
|
|
|
|
var child = _ref2;
|
|
|
var nodes = this.normalize(child, this.first, 'prepend').reverse();
|
|
|
|
|
|
for (var _iterator3 = nodes, _isArray3 = Array.isArray(_iterator3), _i4 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
|
|
|
var _ref3;
|
|
|
|
|
|
if (_isArray3) {
|
|
|
if (_i4 >= _iterator3.length) break;
|
|
|
_ref3 = _iterator3[_i4++];
|
|
|
} else {
|
|
|
_i4 = _iterator3.next();
|
|
|
if (_i4.done) break;
|
|
|
_ref3 = _i4.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref3;
|
|
|
this.nodes.unshift(node);
|
|
|
}
|
|
|
|
|
|
for (var id in this.indexes) {
|
|
|
this.indexes[id] = this.indexes[id] + nodes.length;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return this;
|
|
|
};
|
|
|
|
|
|
_proto.cleanRaws = function cleanRaws(keepBetween) {
|
|
|
_Node.prototype.cleanRaws.call(this, keepBetween);
|
|
|
|
|
|
if (this.nodes) {
|
|
|
for (var _iterator4 = this.nodes, _isArray4 = Array.isArray(_iterator4), _i5 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
|
|
|
var _ref4;
|
|
|
|
|
|
if (_isArray4) {
|
|
|
if (_i5 >= _iterator4.length) break;
|
|
|
_ref4 = _iterator4[_i5++];
|
|
|
} else {
|
|
|
_i5 = _iterator4.next();
|
|
|
if (_i5.done) break;
|
|
|
_ref4 = _i5.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref4;
|
|
|
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 }))
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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 _iterator5 = nodes, _isArray5 = Array.isArray(_iterator5), _i6 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
|
|
|
var _ref5;
|
|
|
|
|
|
if (_isArray5) {
|
|
|
if (_i6 >= _iterator5.length) break;
|
|
|
_ref5 = _iterator5[_i6++];
|
|
|
} else {
|
|
|
_i6 = _iterator5.next();
|
|
|
if (_i6.done) break;
|
|
|
_ref5 = _i6.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref5;
|
|
|
this.nodes.splice(exist, 0, node);
|
|
|
}
|
|
|
|
|
|
var index;
|
|
|
|
|
|
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.
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.insertAfter = function insertAfter(exist, add) {
|
|
|
exist = this.index(exist);
|
|
|
var nodes = this.normalize(add, this.nodes[exist]).reverse();
|
|
|
|
|
|
for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i7 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
|
|
|
var _ref6;
|
|
|
|
|
|
if (_isArray6) {
|
|
|
if (_i7 >= _iterator6.length) break;
|
|
|
_ref6 = _iterator6[_i7++];
|
|
|
} else {
|
|
|
_i7 = _iterator6.next();
|
|
|
if (_i7.done) break;
|
|
|
_ref6 = _i7.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref6;
|
|
|
this.nodes.splice(exist + 1, 0, node);
|
|
|
}
|
|
|
|
|
|
var index;
|
|
|
|
|
|
for (var id in this.indexes) {
|
|
|
index = this.indexes[id];
|
|
|
|
|
|
if (exist < index) {
|
|
|
this.indexes[id] = index + nodes.length;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.removeChild = function removeChild(child) {
|
|
|
child = this.index(child);
|
|
|
this.nodes[child].parent = undefined;
|
|
|
this.nodes.splice(child, 1);
|
|
|
var index;
|
|
|
|
|
|
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
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.removeAll = function removeAll() {
|
|
|
for (var _iterator7 = this.nodes, _isArray7 = Array.isArray(_iterator7), _i8 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
|
|
|
var _ref7;
|
|
|
|
|
|
if (_isArray7) {
|
|
|
if (_i8 >= _iterator7.length) break;
|
|
|
_ref7 = _iterator7[_i8++];
|
|
|
} else {
|
|
|
_i8 = _iterator7.next();
|
|
|
if (_i8.done) break;
|
|
|
_ref7 = _i8.value;
|
|
|
}
|
|
|
|
|
|
var node = _ref7;
|
|
|
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'
|
|
|
* })
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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] !== '-')
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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] === '-')
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.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
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.index = function index(child) {
|
|
|
if (typeof child === 'number') {
|
|
|
return child;
|
|
|
}
|
|
|
|
|
|
return this.nodes.indexOf(child);
|
|
|
}
|
|
|
/**
|
|
|
* The container’s first child.
|
|
|
*
|
|
|
* @type {Node}
|
|
|
*
|
|
|
* @example
|
|
|
* rule.first === rules.nodes[0]
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_proto.normalize = function normalize(nodes, sample) {
|
|
|
var _this = this;
|
|
|
|
|
|
if (typeof nodes === 'string') {
|
|
|
var parse = require('./parse');
|
|
|
|
|
|
nodes = cleanSource(parse(nodes).nodes);
|
|
|
} else if (Array.isArray(nodes)) {
|
|
|
nodes = nodes.slice(0);
|
|
|
|
|
|
for (var _iterator8 = nodes, _isArray8 = Array.isArray(_iterator8), _i9 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
|
|
|
var _ref8;
|
|
|
|
|
|
if (_isArray8) {
|
|
|
if (_i9 >= _iterator8.length) break;
|
|
|
_ref8 = _iterator8[_i9++];
|
|
|
} else {
|
|
|
_i9 = _iterator8.next();
|
|
|
if (_i9.done) break;
|
|
|
_ref8 = _i9.value;
|
|
|
}
|
|
|
|
|
|
var i = _ref8;
|
|
|
if (i.parent) i.parent.removeChild(i, 'ignore');
|
|
|
}
|
|
|
} else if (nodes.type === 'root') {
|
|
|
nodes = nodes.nodes.slice(0);
|
|
|
|
|
|
for (var _iterator9 = nodes, _isArray9 = Array.isArray(_iterator9), _i10 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
|
|
|
var _ref9;
|
|
|
|
|
|
if (_isArray9) {
|
|
|
if (_i10 >= _iterator9.length) break;
|
|
|
_ref9 = _iterator9[_i10++];
|
|
|
} else {
|
|
|
_i10 = _iterator9.next();
|
|
|
if (_i10.done) break;
|
|
|
_ref9 = _i10.value;
|
|
|
}
|
|
|
|
|
|
var _i11 = _ref9;
|
|
|
if (_i11.parent) _i11.parent.removeChild(_i11, 'ignore');
|
|
|
}
|
|
|
} 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 _declaration.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 _comment.default(nodes)];
|
|
|
} else {
|
|
|
throw new Error('Unknown node type in node creation');
|
|
|
}
|
|
|
|
|
|
var processed = nodes.map(function (i) {
|
|
|
if (i.parent) i.parent.removeChild(i);
|
|
|
|
|
|
if (typeof i.raws.before === 'undefined') {
|
|
|
if (sample && typeof sample.raws.before !== 'undefined') {
|
|
|
i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
|
|
|
}
|
|
|
}
|
|
|
|
|
|
i.parent = _this;
|
|
|
return i;
|
|
|
});
|
|
|
return processed;
|
|
|
}
|
|
|
/**
|
|
|
* @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'
|
|
|
*/
|
|
|
;
|
|
|
|
|
|
_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];
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return Container;
|
|
|
}(_node.default);
|
|
|
|
|
|
var _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.
|
|
|
*/
|
|
|
|
|
|
exports.default = _default;
|
|
|
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","e","postcssNode","stack","test","s","replace","input","from","start","line","column","walkDecls","prop","type","RegExp","walkRules","selector","walkAtRules","name","walkComments","append","children","normalize","last","node","prepend","reverse","first","unshift","cleanRaws","keepBetween","insertBefore","exist","add","splice","insertAfter","removeChild","removeAll","replaceValues","pattern","opts","decl","props","indexOf","fast","value","every","condition","some","sample","parse","require","Array","isArray","slice","Error","String","Declaration","Rule","AtRule","text","Comment","processed","raws","before","Node"],"mappings":"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","sourcesContent":["import Declaration from './declaration'\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  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 (const 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\n      try {\n        result = callback(child, i)\n      } catch (e) {\n        e.postcssNode = child\n        if (e.stack && child.source && /\\n\\s{4}at /.test(e.stack)) {\n          let s = child.source\n          e.stack = e.stack.replace(/\\n\\s{4}at /,\n            `$&${ s.input.from }:${ s.start.line }:${ s.start.column }$&`)\n        }\n        throw e\n      }\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    }\n    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    }\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   * 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    }\n    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    }\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   * 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    }\n    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    }\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   * 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  /**\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 to narrow down\n   *                                     values and speed up the regexp search.\n   * @param {function|string} callback   String to replace pattern or callback\n   *                                     that returns a new value. The callback\n   *                                     will receive the same arguments\n   *                                     as those 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    }\n    return this.nodes.indexOf(child)\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      nodes = nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type === 'root') {\n      nodes = nodes.nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\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    let processed = nodes.map(i => {\n      if (i.parent) i.parent.removeChild(i)\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  /**\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\nexport default Container\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"],"file":"container.js"}
|
