udia

'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;
    });
}

/**
 * @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
 */

/**
 * 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
 * @ignore
 */

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 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.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 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.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} opts.prop         - 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 every child pass condition
     *
     * @example
     * const hasPrefix = rule.every(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;
module.exports = exports['default'];
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["container.es6"],"names":[],"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 * @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\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 * @ignore\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 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.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 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.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} opts.prop         - 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 value.\n     *                                     The callback will receive\n     *                                     the same arguments as those passed\n     *                                     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 every child pass condition\n     *\n     * @example\n     * const hasPrefix = rule.every(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"],"sourceRoot":"/source/"}