.config/coc/extensions/node_modules/coc-prettier/node_modules/postcss-less/node_modules/postcss/lib/container.js

   1 'use strict';
   2
   3 exports.__esModule = true;
   4
   5 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; }; }();
   6
   7 var _declaration = require('./declaration');
   8
   9 var _declaration2 = _interopRequireDefault(_declaration);
  10
  11 var _warnOnce = require('./warn-once');
  12
  13 var _warnOnce2 = _interopRequireDefault(_warnOnce);
  14
  15 var _comment = require('./comment');
  16
  17 var _comment2 = _interopRequireDefault(_comment);
  18
  19 var _node = require('./node');
  20
  21 var _node2 = _interopRequireDefault(_node);
  22
  23 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  24
  25 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  26
  27 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; }
  28
  29 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; }
  30
  31 function cleanSource(nodes) {
  32     return nodes.map(function (i) {
  33         if (i.nodes) i.nodes = cleanSource(i.nodes);
  34         delete i.source;
  35         return i;
  36     });
  37 }
  38
  39 /**
  40  * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes
  41  * inherit some common methods to help work with their children.
  42  *
  43  * Note that all containers can store any content. If you write a rule inside
  44  * a rule, PostCSS will parse it.
  45  *
  46  * @extends Node
  47  * @abstract
  48  */
  49
  50 var Container = function (_Node) {
  51     _inherits(Container, _Node);
  52
  53     function Container() {
  54         _classCallCheck(this, Container);
  55
  56         return _possibleConstructorReturn(this, _Node.apply(this, arguments));
  57     }
  58
  59     Container.prototype.push = function push(child) {
  60         child.parent = this;
  61         this.nodes.push(child);
  62         return this;
  63     };
  64
  65     /**
  66      * Iterates through the container’s immediate children,
  67      * calling `callback` for each child.
  68      *
  69      * Returning `false` in the callback will break iteration.
  70      *
  71      * This method only iterates through the container’s immediate children.
  72      * If you need to recursively iterate through all the container’s descendant
  73      * nodes, use {@link Container#walk}.
  74      *
  75      * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
  76      * if you are mutating the array of child nodes during iteration.
  77      * PostCSS will adjust the current index to match the mutations.
  78      *
  79      * @param {childIterator} callback - iterator receives each node and index
  80      *
  81      * @return {false|undefined} returns `false` if iteration was broke
  82      *
  83      * @example
  84      * const root = postcss.parse('a { color: black; z-index: 1 }');
  85      * const rule = root.first;
  86      *
  87      * for ( let decl of rule.nodes ) {
  88      *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
  89      *     // Cycle will be infinite, because cloneBefore moves the current node
  90      *     // to the next index
  91      * }
  92      *
  93      * rule.each(decl => {
  94      *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
  95      *     // Will be executed only for color and z-index
  96      * });
  97      */
  98
  99
 100     Container.prototype.each = function each(callback) {
 101         if (!this.lastEach) this.lastEach = 0;
 102         if (!this.indexes) this.indexes = {};
 103
 104         this.lastEach += 1;
 105         var id = this.lastEach;
 106         this.indexes[id] = 0;
 107
 108         if (!this.nodes) return undefined;
 109
 110         var index = void 0,
 111             result = void 0;
 112         while (this.indexes[id] < this.nodes.length) {
 113             index = this.indexes[id];
 114             result = callback(this.nodes[index], index);
 115             if (result === false) break;
 116
 117             this.indexes[id] += 1;
 118         }
 119
 120         delete this.indexes[id];
 121
 122         return result;
 123     };
 124
 125     /**
 126      * Traverses the container’s descendant nodes, calling callback
 127      * for each node.
 128      *
 129      * Like container.each(), this method is safe to use
 130      * if you are mutating arrays during iteration.
 131      *
 132      * If you only need to iterate through the container’s immediate children,
 133      * use {@link Container#each}.
 134      *
 135      * @param {childIterator} callback - iterator receives each node and index
 136      *
 137      * @return {false|undefined} returns `false` if iteration was broke
 138      *
 139      * @example
 140      * root.walk(node => {
 141      *   // Traverses all descendant nodes.
 142      * });
 143      */
 144
 145
 146     Container.prototype.walk = function walk(callback) {
 147         return this.each(function (child, i) {
 148             var result = callback(child, i);
 149             if (result !== false && child.walk) {
 150                 result = child.walk(callback);
 151             }
 152             return result;
 153         });
 154     };
 155
 156     /**
 157      * Traverses the container’s descendant nodes, calling callback
 158      * for each declaration node.
 159      *
 160      * If you pass a filter, iteration will only happen over declarations
 161      * with matching properties.
 162      *
 163      * Like {@link Container#each}, this method is safe
 164      * to use if you are mutating arrays during iteration.
 165      *
 166      * @param {string|RegExp} [prop]   - string or regular expression
 167      *                                   to filter declarations by property name
 168      * @param {childIterator} callback - iterator receives each node and index
 169      *
 170      * @return {false|undefined} returns `false` if iteration was broke
 171      *
 172      * @example
 173      * root.walkDecls(decl => {
 174      *   checkPropertySupport(decl.prop);
 175      * });
 176      *
 177      * root.walkDecls('border-radius', decl => {
 178      *   decl.remove();
 179      * });
 180      *
 181      * root.walkDecls(/^background/, decl => {
 182      *   decl.value = takeFirstColorFromGradient(decl.value);
 183      * });
 184      */
 185
 186
 187     Container.prototype.walkDecls = function walkDecls(prop, callback) {
 188         if (!callback) {
 189             callback = prop;
 190             return this.walk(function (child, i) {
 191                 if (child.type === 'decl') {
 192                     return callback(child, i);
 193                 }
 194             });
 195         } else if (prop instanceof RegExp) {
 196             return this.walk(function (child, i) {
 197                 if (child.type === 'decl' && prop.test(child.prop)) {
 198                     return callback(child, i);
 199                 }
 200             });
 201         } else {
 202             return this.walk(function (child, i) {
 203                 if (child.type === 'decl' && child.prop === prop) {
 204                     return callback(child, i);
 205                 }
 206             });
 207         }
 208     };
 209
 210     /**
 211      * Traverses the container’s descendant nodes, calling callback
 212      * for each rule node.
 213      *
 214      * If you pass a filter, iteration will only happen over rules
 215      * with matching selectors.
 216      *
 217      * Like {@link Container#each}, this method is safe
 218      * to use if you are mutating arrays during iteration.
 219      *
 220      * @param {string|RegExp} [selector] - string or regular expression
 221      *                                     to filter rules by selector
 222      * @param {childIterator} callback   - iterator receives each node and index
 223      *
 224      * @return {false|undefined} returns `false` if iteration was broke
 225      *
 226      * @example
 227      * const selectors = [];
 228      * root.walkRules(rule => {
 229      *   selectors.push(rule.selector);
 230      * });
 231      * console.log(`Your CSS uses ${selectors.length} selectors`);
 232      */
 233
 234
 235     Container.prototype.walkRules = function walkRules(selector, callback) {
 236         if (!callback) {
 237             callback = selector;
 238
 239             return this.walk(function (child, i) {
 240                 if (child.type === 'rule') {
 241                     return callback(child, i);
 242                 }
 243             });
 244         } else if (selector instanceof RegExp) {
 245             return this.walk(function (child, i) {
 246                 if (child.type === 'rule' && selector.test(child.selector)) {
 247                     return callback(child, i);
 248                 }
 249             });
 250         } else {
 251             return this.walk(function (child, i) {
 252                 if (child.type === 'rule' && child.selector === selector) {
 253                     return callback(child, i);
 254                 }
 255             });
 256         }
 257     };
 258
 259     /**
 260      * Traverses the container’s descendant nodes, calling callback
 261      * for each at-rule node.
 262      *
 263      * If you pass a filter, iteration will only happen over at-rules
 264      * that have matching names.
 265      *
 266      * Like {@link Container#each}, this method is safe
 267      * to use if you are mutating arrays during iteration.
 268      *
 269      * @param {string|RegExp} [name]   - string or regular expression
 270      *                                   to filter at-rules by name
 271      * @param {childIterator} callback - iterator receives each node and index
 272      *
 273      * @return {false|undefined} returns `false` if iteration was broke
 274      *
 275      * @example
 276      * root.walkAtRules(rule => {
 277      *   if ( isOld(rule.name) ) rule.remove();
 278      * });
 279      *
 280      * let first = false;
 281      * root.walkAtRules('charset', rule => {
 282      *   if ( !first ) {
 283      *     first = true;
 284      *   } else {
 285      *     rule.remove();
 286      *   }
 287      * });
 288      */
 289
 290
 291     Container.prototype.walkAtRules = function walkAtRules(name, callback) {
 292         if (!callback) {
 293             callback = name;
 294             return this.walk(function (child, i) {
 295                 if (child.type === 'atrule') {
 296                     return callback(child, i);
 297                 }
 298             });
 299         } else if (name instanceof RegExp) {
 300             return this.walk(function (child, i) {
 301                 if (child.type === 'atrule' && name.test(child.name)) {
 302                     return callback(child, i);
 303                 }
 304             });
 305         } else {
 306             return this.walk(function (child, i) {
 307                 if (child.type === 'atrule' && child.name === name) {
 308                     return callback(child, i);
 309                 }
 310             });
 311         }
 312     };
 313
 314     /**
 315      * Traverses the container’s descendant nodes, calling callback
 316      * for each comment node.
 317      *
 318      * Like {@link Container#each}, this method is safe
 319      * to use if you are mutating arrays during iteration.
 320      *
 321      * @param {childIterator} callback - iterator receives each node and index
 322      *
 323      * @return {false|undefined} returns `false` if iteration was broke
 324      *
 325      * @example
 326      * root.walkComments(comment => {
 327      *   comment.remove();
 328      * });
 329      */
 330
 331
 332     Container.prototype.walkComments = function walkComments(callback) {
 333         return this.walk(function (child, i) {
 334             if (child.type === 'comment') {
 335                 return callback(child, i);
 336             }
 337         });
 338     };
 339
 340     /**
 341      * Inserts new nodes to the end of the container.
 342      *
 343      * @param {...(Node|object|string|Node[])} children - new nodes
 344      *
 345      * @return {Node} this node for methods chain
 346      *
 347      * @example
 348      * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
 349      * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
 350      * rule.append(decl1, decl2);
 351      *
 352      * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
 353      * root.append({ selector: 'a' });                       // rule
 354      * rule.append({ prop: 'color', value: 'black' });       // declaration
 355      * rule.append({ text: 'Comment' })                      // comment
 356      *
 357      * root.append('a {}');
 358      * root.first.append('color: black; z-index: 1');
 359      */
 360
 361
 362     Container.prototype.append = function append() {
 363         for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
 364             children[_key] = arguments[_key];
 365         }
 366
 367         for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
 368             var _ref;
 369
 370             if (_isArray) {
 371                 if (_i >= _iterator.length) break;
 372                 _ref = _iterator[_i++];
 373             } else {
 374                 _i = _iterator.next();
 375                 if (_i.done) break;
 376                 _ref = _i.value;
 377             }
 378
 379             var child = _ref;
 380
 381             var nodes = this.normalize(child, this.last);
 382             for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
 383                 var _ref2;
 384
 385                 if (_isArray2) {
 386                     if (_i2 >= _iterator2.length) break;
 387                     _ref2 = _iterator2[_i2++];
 388                 } else {
 389                     _i2 = _iterator2.next();
 390                     if (_i2.done) break;
 391                     _ref2 = _i2.value;
 392                 }
 393
 394                 var node = _ref2;
 395                 this.nodes.push(node);
 396             }
 397         }
 398         return this;
 399     };
 400
 401     /**
 402      * Inserts new nodes to the start of the container.
 403      *
 404      * @param {...(Node|object|string|Node[])} children - new nodes
 405      *
 406      * @return {Node} this node for methods chain
 407      *
 408      * @example
 409      * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
 410      * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
 411      * rule.prepend(decl1, decl2);
 412      *
 413      * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
 414      * root.append({ selector: 'a' });                       // rule
 415      * rule.append({ prop: 'color', value: 'black' });       // declaration
 416      * rule.append({ text: 'Comment' })                      // comment
 417      *
 418      * root.append('a {}');
 419      * root.first.append('color: black; z-index: 1');
 420      */
 421
 422
 423     Container.prototype.prepend = function prepend() {
 424         for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
 425             children[_key2] = arguments[_key2];
 426         }
 427
 428         children = children.reverse();
 429         for (var _iterator3 = children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
 430             var _ref3;
 431
 432             if (_isArray3) {
 433                 if (_i3 >= _iterator3.length) break;
 434                 _ref3 = _iterator3[_i3++];
 435             } else {
 436                 _i3 = _iterator3.next();
 437                 if (_i3.done) break;
 438                 _ref3 = _i3.value;
 439             }
 440
 441             var child = _ref3;
 442
 443             var nodes = this.normalize(child, this.first, 'prepend').reverse();
 444             for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
 445                 var _ref4;
 446
 447                 if (_isArray4) {
 448                     if (_i4 >= _iterator4.length) break;
 449                     _ref4 = _iterator4[_i4++];
 450                 } else {
 451                     _i4 = _iterator4.next();
 452                     if (_i4.done) break;
 453                     _ref4 = _i4.value;
 454                 }
 455
 456                 var node = _ref4;
 457                 this.nodes.unshift(node);
 458             }for (var id in this.indexes) {
 459                 this.indexes[id] = this.indexes[id] + nodes.length;
 460             }
 461         }
 462         return this;
 463     };
 464
 465     Container.prototype.cleanRaws = function cleanRaws(keepBetween) {
 466         _Node.prototype.cleanRaws.call(this, keepBetween);
 467         if (this.nodes) {
 468             for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
 469                 var _ref5;
 470
 471                 if (_isArray5) {
 472                     if (_i5 >= _iterator5.length) break;
 473                     _ref5 = _iterator5[_i5++];
 474                 } else {
 475                     _i5 = _iterator5.next();
 476                     if (_i5.done) break;
 477                     _ref5 = _i5.value;
 478                 }
 479
 480                 var node = _ref5;
 481                 node.cleanRaws(keepBetween);
 482             }
 483         }
 484     };
 485
 486     /**
 487      * Insert new node before old node within the container.
 488      *
 489      * @param {Node|number} exist             - child or child’s index.
 490      * @param {Node|object|string|Node[]} add - new node
 491      *
 492      * @return {Node} this node for methods chain
 493      *
 494      * @example
 495      * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));
 496      */
 497
 498
 499     Container.prototype.insertBefore = function insertBefore(exist, add) {
 500         exist = this.index(exist);
 501
 502         var type = exist === 0 ? 'prepend' : false;
 503         var nodes = this.normalize(add, this.nodes[exist], type).reverse();
 504         for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
 505             var _ref6;
 506
 507             if (_isArray6) {
 508                 if (_i6 >= _iterator6.length) break;
 509                 _ref6 = _iterator6[_i6++];
 510             } else {
 511                 _i6 = _iterator6.next();
 512                 if (_i6.done) break;
 513                 _ref6 = _i6.value;
 514             }
 515
 516             var node = _ref6;
 517             this.nodes.splice(exist, 0, node);
 518         }var index = void 0;
 519         for (var id in this.indexes) {
 520             index = this.indexes[id];
 521             if (exist <= index) {
 522                 this.indexes[id] = index + nodes.length;
 523             }
 524         }
 525
 526         return this;
 527     };
 528
 529     /**
 530      * Insert new node after old node within the container.
 531      *
 532      * @param {Node|number} exist             - child or child’s index
 533      * @param {Node|object|string|Node[]} add - new node
 534      *
 535      * @return {Node} this node for methods chain
 536      */
 537
 538
 539     Container.prototype.insertAfter = function insertAfter(exist, add) {
 540         exist = this.index(exist);
 541
 542         var nodes = this.normalize(add, this.nodes[exist]).reverse();
 543         for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
 544             var _ref7;
 545
 546             if (_isArray7) {
 547                 if (_i7 >= _iterator7.length) break;
 548                 _ref7 = _iterator7[_i7++];
 549             } else {
 550                 _i7 = _iterator7.next();
 551                 if (_i7.done) break;
 552                 _ref7 = _i7.value;
 553             }
 554
 555             var node = _ref7;
 556             this.nodes.splice(exist + 1, 0, node);
 557         }var index = void 0;
 558         for (var id in this.indexes) {
 559             index = this.indexes[id];
 560             if (exist < index) {
 561                 this.indexes[id] = index + nodes.length;
 562             }
 563         }
 564
 565         return this;
 566     };
 567
 568     Container.prototype.remove = function remove(child) {
 569         if (typeof child !== 'undefined') {
 570             (0, _warnOnce2.default)('Container#remove is deprecated. ' + 'Use Container#removeChild');
 571             this.removeChild(child);
 572         } else {
 573             _Node.prototype.remove.call(this);
 574         }
 575         return this;
 576     };
 577
 578     /**
 579      * Removes node from the container and cleans the parent properties
 580      * from the node and its children.
 581      *
 582      * @param {Node|number} child - child or child’s index
 583      *
 584      * @return {Node} this node for methods chain
 585      *
 586      * @example
 587      * rule.nodes.length  //=> 5
 588      * rule.removeChild(decl);
 589      * rule.nodes.length  //=> 4
 590      * decl.parent        //=> undefined
 591      */
 592
 593
 594     Container.prototype.removeChild = function removeChild(child) {
 595         child = this.index(child);
 596         this.nodes[child].parent = undefined;
 597         this.nodes.splice(child, 1);
 598
 599         var index = void 0;
 600         for (var id in this.indexes) {
 601             index = this.indexes[id];
 602             if (index >= child) {
 603                 this.indexes[id] = index - 1;
 604             }
 605         }
 606
 607         return this;
 608     };
 609
 610     /**
 611      * Removes all children from the container
 612      * and cleans their parent properties.
 613      *
 614      * @return {Node} this node for methods chain
 615      *
 616      * @example
 617      * rule.removeAll();
 618      * rule.nodes.length //=> 0
 619      */
 620
 621
 622     Container.prototype.removeAll = function removeAll() {
 623         for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
 624             var _ref8;
 625
 626             if (_isArray8) {
 627                 if (_i8 >= _iterator8.length) break;
 628                 _ref8 = _iterator8[_i8++];
 629             } else {
 630                 _i8 = _iterator8.next();
 631                 if (_i8.done) break;
 632                 _ref8 = _i8.value;
 633             }
 634
 635             var node = _ref8;
 636             node.parent = undefined;
 637         }this.nodes = [];
 638         return this;
 639     };
 640
 641     /**
 642      * Passes all declaration values within the container that match pattern
 643      * through callback, replacing those values with the returned result
 644      * of callback.
 645      *
 646      * This method is useful if you are using a custom unit or function
 647      * and need to iterate through all values.
 648      *
 649      * @param {string|RegExp} pattern      - replace pattern
 650      * @param {object} opts                - options to speed up the search
 651      * @param {string|string[]} opts.props - an array of property names
 652      * @param {string} opts.fast           - string that’s used
 653      *                                       to narrow down values and speed up
 654                                              the regexp search
 655      * @param {function|string} callback   - string to replace pattern
 656      *                                       or callback that returns a new
 657      *                                       value.
 658      *                                       The callback will receive
 659      *                                       the same arguments as those
 660      *                                       passed to a function parameter
 661      *                                       of `String#replace`.
 662      *
 663      * @return {Node} this node for methods chain
 664      *
 665      * @example
 666      * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
 667      *   return 15 * parseInt(string) + 'px';
 668      * });
 669      */
 670
 671
 672     Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) {
 673         if (!callback) {
 674             callback = opts;
 675             opts = {};
 676         }
 677
 678         this.walkDecls(function (decl) {
 679             if (opts.props && opts.props.indexOf(decl.prop) === -1) return;
 680             if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;
 681
 682             decl.value = decl.value.replace(pattern, callback);
 683         });
 684
 685         return this;
 686     };
 687
 688     /**
 689      * Returns `true` if callback returns `true`
 690      * for all of the container’s children.
 691      *
 692      * @param {childCondition} condition - iterator returns true or false.
 693      *
 694      * @return {boolean} is every child pass condition
 695      *
 696      * @example
 697      * const noPrefixes = rule.every(i => i.prop[0] !== '-');
 698      */
 699
 700
 701     Container.prototype.every = function every(condition) {
 702         return this.nodes.every(condition);
 703     };
 704
 705     /**
 706      * Returns `true` if callback returns `true` for (at least) one
 707      * of the container’s children.
 708      *
 709      * @param {childCondition} condition - iterator returns true or false.
 710      *
 711      * @return {boolean} is some child pass condition
 712      *
 713      * @example
 714      * const hasPrefix = rule.some(i => i.prop[0] === '-');
 715      */
 716
 717
 718     Container.prototype.some = function some(condition) {
 719         return this.nodes.some(condition);
 720     };
 721
 722     /**
 723      * Returns a `child`’s index within the {@link Container#nodes} array.
 724      *
 725      * @param {Node} child - child of the current container.
 726      *
 727      * @return {number} child index
 728      *
 729      * @example
 730      * rule.index( rule.nodes[2] ) //=> 2
 731      */
 732
 733
 734     Container.prototype.index = function index(child) {
 735         if (typeof child === 'number') {
 736             return child;
 737         } else {
 738             return this.nodes.indexOf(child);
 739         }
 740     };
 741
 742     /**
 743      * The container’s first child.
 744      *
 745      * @type {Node}
 746      *
 747      * @example
 748      * rule.first == rules.nodes[0];
 749      */
 750
 751
 752     Container.prototype.normalize = function normalize(nodes, sample) {
 753         var _this2 = this;
 754
 755         if (typeof nodes === 'string') {
 756             var parse = require('./parse');
 757             nodes = cleanSource(parse(nodes).nodes);
 758         } else if (!Array.isArray(nodes)) {
 759             if (nodes.type === 'root') {
 760                 nodes = nodes.nodes;
 761             } else if (nodes.type) {
 762                 nodes = [nodes];
 763             } else if (nodes.prop) {
 764                 if (typeof nodes.value === 'undefined') {
 765                     throw new Error('Value field is missed in node creation');
 766                 } else if (typeof nodes.value !== 'string') {
 767                     nodes.value = String(nodes.value);
 768                 }
 769                 nodes = [new _declaration2.default(nodes)];
 770             } else if (nodes.selector) {
 771                 var Rule = require('./rule');
 772                 nodes = [new Rule(nodes)];
 773             } else if (nodes.name) {
 774                 var AtRule = require('./at-rule');
 775                 nodes = [new AtRule(nodes)];
 776             } else if (nodes.text) {
 777                 nodes = [new _comment2.default(nodes)];
 778             } else {
 779                 throw new Error('Unknown node type in node creation');
 780             }
 781         }
 782
 783         var processed = nodes.map(function (i) {
 784             if (typeof i.raws === 'undefined') i = _this2.rebuild(i);
 785
 786             if (i.parent) i = i.clone();
 787             if (typeof i.raws.before === 'undefined') {
 788                 if (sample && typeof sample.raws.before !== 'undefined') {
 789                     i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
 790                 }
 791             }
 792             i.parent = _this2;
 793             return i;
 794         });
 795
 796         return processed;
 797     };
 798
 799     Container.prototype.rebuild = function rebuild(node, parent) {
 800         var _this3 = this;
 801
 802         var fix = void 0;
 803         if (node.type === 'root') {
 804             var Root = require('./root');
 805             fix = new Root();
 806         } else if (node.type === 'atrule') {
 807             var AtRule = require('./at-rule');
 808             fix = new AtRule();
 809         } else if (node.type === 'rule') {
 810             var Rule = require('./rule');
 811             fix = new Rule();
 812         } else if (node.type === 'decl') {
 813             fix = new _declaration2.default();
 814         } else if (node.type === 'comment') {
 815             fix = new _comment2.default();
 816         }
 817
 818         for (var i in node) {
 819             if (i === 'nodes') {
 820                 fix.nodes = node.nodes.map(function (j) {
 821                     return _this3.rebuild(j, fix);
 822                 });
 823             } else if (i === 'parent' && parent) {
 824                 fix.parent = parent;
 825             } else if (node.hasOwnProperty(i)) {
 826                 fix[i] = node[i];
 827             }
 828         }
 829
 830         return fix;
 831     };
 832
 833     Container.prototype.eachInside = function eachInside(callback) {
 834         (0, _warnOnce2.default)('Container#eachInside is deprecated. ' + 'Use Container#walk instead.');
 835         return this.walk(callback);
 836     };
 837
 838     Container.prototype.eachDecl = function eachDecl(prop, callback) {
 839         (0, _warnOnce2.default)('Container#eachDecl is deprecated. ' + 'Use Container#walkDecls instead.');
 840         return this.walkDecls(prop, callback);
 841     };
 842
 843     Container.prototype.eachRule = function eachRule(selector, callback) {
 844         (0, _warnOnce2.default)('Container#eachRule is deprecated. ' + 'Use Container#walkRules instead.');
 845         return this.walkRules(selector, callback);
 846     };
 847
 848     Container.prototype.eachAtRule = function eachAtRule(name, callback) {
 849         (0, _warnOnce2.default)('Container#eachAtRule is deprecated. ' + 'Use Container#walkAtRules instead.');
 850         return this.walkAtRules(name, callback);
 851     };
 852
 853     Container.prototype.eachComment = function eachComment(callback) {
 854         (0, _warnOnce2.default)('Container#eachComment is deprecated. ' + 'Use Container#walkComments instead.');
 855         return this.walkComments(callback);
 856     };
 857
 858     _createClass(Container, [{
 859         key: 'first',
 860         get: function get() {
 861             if (!this.nodes) return undefined;
 862             return this.nodes[0];
 863         }
 864
 865         /**
 866          * The container’s last child.
 867          *
 868          * @type {Node}
 869          *
 870          * @example
 871          * rule.last == rule.nodes[rule.nodes.length - 1];
 872          */
 873
 874     }, {
 875         key: 'last',
 876         get: function get() {
 877             if (!this.nodes) return undefined;
 878             return this.nodes[this.nodes.length - 1];
 879         }
 880     }, {
 881         key: 'semicolon',
 882         get: function get() {
 883             (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon');
 884             return this.raws.semicolon;
 885         },
 886         set: function set(val) {
 887             (0, _warnOnce2.default)('Node#semicolon is deprecated. Use Node#raws.semicolon');
 888             this.raws.semicolon = val;
 889         }
 890     }, {
 891         key: 'after',
 892         get: function get() {
 893             (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after');
 894             return this.raws.after;
 895         },
 896         set: function set(val) {
 897             (0, _warnOnce2.default)('Node#after is deprecated. Use Node#raws.after');
 898             this.raws.after = val;
 899         }
 900
 901         /**
 902          * @memberof Container#
 903          * @member {Node[]} nodes - an array containing the container’s children
 904          *
 905          * @example
 906          * const root = postcss.parse('a { color: black }');
 907          * root.nodes.length           //=> 1
 908          * root.nodes[0].selector      //=> 'a'
 909          * root.nodes[0].nodes[0].prop //=> 'color'
 910          */
 911
 912     }]);
 913
 914     return Container;
 915 }(_node2.default);
 916
 917 exports.default = Container;
 918
 919 /**
 920  * @callback childCondition
 921  * @param {Node} node    - container child
 922  * @param {number} index - child index
 923  * @param {Node[]} nodes - all container children
 924  * @return {boolean}
 925  */
 926
 927 /**
 928  * @callback childIterator
 929  * @param {Node} node    - container child
 930  * @param {number} index - child index
 931  * @return {false|undefined} returning `false` will break iteration
 932  */
 933
 934 module.exports = exports['default'];
 935 //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["container.es6"],"names":["cleanSource","nodes","map","i","source","Container","push","child","parent","each","callback","lastEach","indexes","id","undefined","index","result","length","walk","walkDecls","prop","type","RegExp","test","walkRules","selector","walkAtRules","name","walkComments","append","children","normalize","last","node","prepend","reverse","first","unshift","cleanRaws","keepBetween","insertBefore","exist","add","splice","insertAfter","remove","removeChild","removeAll","replaceValues","pattern","opts","props","indexOf","decl","fast","value","replace","every","condition","some","sample","parse","require","Array","isArray","Error","String","Rule","AtRule","text","processed","raws","rebuild","clone","before","fix","Root","j","hasOwnProperty","eachInside","eachDecl","eachRule","eachAtRule","eachComment","semicolon","val","after"],"mappings":"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","file":"container.js","sourcesContent":["import Declaration from './declaration';\nimport warnOnce    from './warn-once';\nimport Comment     from './comment';\nimport Node        from './node';\n\nfunction cleanSource(nodes) {\n    return nodes.map( i => {\n        if ( i.nodes ) i.nodes = cleanSource(i.nodes);\n        delete i.source;\n        return i;\n    });\n}\n\n/**\n * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes\n * inherit some common methods to help work with their children.\n *\n * Note that all containers can store any content. If you write a rule inside\n * a rule, PostCSS will parse it.\n *\n * @extends Node\n * @abstract\n */\nclass Container extends Node {\n\n    push(child) {\n        child.parent = this;\n        this.nodes.push(child);\n        return this;\n    }\n\n    /**\n     * Iterates through the container’s immediate children,\n     * calling `callback` for each child.\n     *\n     * Returning `false` in the callback will break iteration.\n     *\n     * This method only iterates through the container’s immediate children.\n     * If you need to recursively iterate through all the container’s descendant\n     * nodes, use {@link Container#walk}.\n     *\n     * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe\n     * if you are mutating the array of child nodes during iteration.\n     * PostCSS will adjust the current index to match the mutations.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * const root = postcss.parse('a { color: black; z-index: 1 }');\n     * const rule = root.first;\n     *\n     * for ( let decl of rule.nodes ) {\n     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });\n     *     // Cycle will be infinite, because cloneBefore moves the current node\n     *     // to the next index\n     * }\n     *\n     * rule.each(decl => {\n     *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });\n     *     // Will be executed only for color and z-index\n     * });\n     */\n    each(callback) {\n        if ( !this.lastEach ) this.lastEach = 0;\n        if ( !this.indexes ) this.indexes = { };\n\n        this.lastEach += 1;\n        let id = this.lastEach;\n        this.indexes[id] = 0;\n\n        if ( !this.nodes ) return undefined;\n\n        let index, result;\n        while ( this.indexes[id] < this.nodes.length ) {\n            index  = this.indexes[id];\n            result = callback(this.nodes[index], index);\n            if ( result === false ) break;\n\n            this.indexes[id] += 1;\n        }\n\n        delete this.indexes[id];\n\n        return result;\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each node.\n     *\n     * Like container.each(), this method is safe to use\n     * if you are mutating arrays during iteration.\n     *\n     * If you only need to iterate through the container’s immediate children,\n     * use {@link Container#each}.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walk(node => {\n     *   // Traverses all descendant nodes.\n     * });\n     */\n    walk(callback) {\n        return this.each( (child, i) => {\n            let result = callback(child, i);\n            if ( result !== false && child.walk ) {\n                result = child.walk(callback);\n            }\n            return result;\n        });\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each declaration node.\n     *\n     * If you pass a filter, iteration will only happen over declarations\n     * with matching properties.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [prop]   - string or regular expression\n     *                                   to filter declarations by property name\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkDecls(decl => {\n     *   checkPropertySupport(decl.prop);\n     * });\n     *\n     * root.walkDecls('border-radius', decl => {\n     *   decl.remove();\n     * });\n     *\n     * root.walkDecls(/^background/, decl => {\n     *   decl.value = takeFirstColorFromGradient(decl.value);\n     * });\n     */\n    walkDecls(prop, callback) {\n        if ( !callback ) {\n            callback = prop;\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( prop instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' && prop.test(child.prop) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'decl' && child.prop === prop ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each rule node.\n     *\n     * If you pass a filter, iteration will only happen over rules\n     * with matching selectors.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [selector] - string or regular expression\n     *                                     to filter rules by selector\n     * @param {childIterator} callback   - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * const selectors = [];\n     * root.walkRules(rule => {\n     *   selectors.push(rule.selector);\n     * });\n     * console.log(`Your CSS uses ${selectors.length} selectors`);\n     */\n    walkRules(selector, callback) {\n        if ( !callback ) {\n            callback = selector;\n\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( selector instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' && selector.test(child.selector) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'rule' && child.selector === selector ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each at-rule node.\n     *\n     * If you pass a filter, iteration will only happen over at-rules\n     * that have matching names.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {string|RegExp} [name]   - string or regular expression\n     *                                   to filter at-rules by name\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkAtRules(rule => {\n     *   if ( isOld(rule.name) ) rule.remove();\n     * });\n     *\n     * let first = false;\n     * root.walkAtRules('charset', rule => {\n     *   if ( !first ) {\n     *     first = true;\n     *   } else {\n     *     rule.remove();\n     *   }\n     * });\n     */\n    walkAtRules(name, callback) {\n        if ( !callback ) {\n            callback = name;\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' ) {\n                    return callback(child, i);\n                }\n            });\n        } else if ( name instanceof RegExp ) {\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' && name.test(child.name) ) {\n                    return callback(child, i);\n                }\n            });\n        } else {\n            return this.walk( (child, i) => {\n                if ( child.type === 'atrule' && child.name === name ) {\n                    return callback(child, i);\n                }\n            });\n        }\n    }\n\n    /**\n     * Traverses the container’s descendant nodes, calling callback\n     * for each comment node.\n     *\n     * Like {@link Container#each}, this method is safe\n     * to use if you are mutating arrays during iteration.\n     *\n     * @param {childIterator} callback - iterator receives each node and index\n     *\n     * @return {false|undefined} returns `false` if iteration was broke\n     *\n     * @example\n     * root.walkComments(comment => {\n     *   comment.remove();\n     * });\n     */\n    walkComments(callback) {\n        return this.walk( (child, i) => {\n            if ( child.type === 'comment' ) {\n                return callback(child, i);\n            }\n        });\n    }\n\n    /**\n     * Inserts new nodes to the end of the container.\n     *\n     * @param {...(Node|object|string|Node[])} children - new nodes\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });\n     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });\n     * rule.append(decl1, decl2);\n     *\n     * root.append({ name: 'charset', params: '\"UTF-8\"' });  // at-rule\n     * root.append({ selector: 'a' });                       // rule\n     * rule.append({ prop: 'color', value: 'black' });       // declaration\n     * rule.append({ text: 'Comment' })                      // comment\n     *\n     * root.append('a {}');\n     * root.first.append('color: black; z-index: 1');\n     */\n    append(...children) {\n        for ( let child of children ) {\n            let nodes = this.normalize(child, this.last);\n            for ( let node of nodes ) this.nodes.push(node);\n        }\n        return this;\n    }\n\n    /**\n     * Inserts new nodes to the start of the container.\n     *\n     * @param {...(Node|object|string|Node[])} children - new nodes\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * const decl1 = postcss.decl({ prop: 'color', value: 'black' });\n     * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });\n     * rule.prepend(decl1, decl2);\n     *\n     * root.append({ name: 'charset', params: '\"UTF-8\"' });  // at-rule\n     * root.append({ selector: 'a' });                       // rule\n     * rule.append({ prop: 'color', value: 'black' });       // declaration\n     * rule.append({ text: 'Comment' })                      // comment\n     *\n     * root.append('a {}');\n     * root.first.append('color: black; z-index: 1');\n     */\n    prepend(...children) {\n        children = children.reverse();\n        for ( let child of children ) {\n            let nodes = this.normalize(child, this.first, 'prepend').reverse();\n            for ( let node of nodes ) this.nodes.unshift(node);\n            for ( let id in this.indexes ) {\n                this.indexes[id] = this.indexes[id] + nodes.length;\n            }\n        }\n        return this;\n    }\n\n    cleanRaws(keepBetween) {\n        super.cleanRaws(keepBetween);\n        if ( this.nodes ) {\n            for ( let node of this.nodes ) node.cleanRaws(keepBetween);\n        }\n    }\n\n    /**\n     * Insert new node before old node within the container.\n     *\n     * @param {Node|number} exist             - child or child’s index.\n     * @param {Node|object|string|Node[]} add - new node\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));\n     */\n    insertBefore(exist, add) {\n        exist = this.index(exist);\n\n        let type  = exist === 0 ? 'prepend' : false;\n        let nodes = this.normalize(add, this.nodes[exist], type).reverse();\n        for ( let node of nodes ) this.nodes.splice(exist, 0, node);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( exist <= index ) {\n                this.indexes[id] = index + nodes.length;\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Insert new node after old node within the container.\n     *\n     * @param {Node|number} exist             - child or child’s index\n     * @param {Node|object|string|Node[]} add - new node\n     *\n     * @return {Node} this node for methods chain\n     */\n    insertAfter(exist, add) {\n        exist = this.index(exist);\n\n        let nodes = this.normalize(add, this.nodes[exist]).reverse();\n        for ( let node of nodes ) this.nodes.splice(exist + 1, 0, node);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( exist < index ) {\n                this.indexes[id] = index + nodes.length;\n            }\n        }\n\n        return this;\n    }\n\n    remove(child) {\n        if ( typeof child !== 'undefined' ) {\n            warnOnce('Container#remove is deprecated. ' +\n                     'Use Container#removeChild');\n            this.removeChild(child);\n        } else {\n            super.remove();\n        }\n        return this;\n    }\n\n    /**\n     * Removes node from the container and cleans the parent properties\n     * from the node and its children.\n     *\n     * @param {Node|number} child - child or child’s index\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.nodes.length  //=> 5\n     * rule.removeChild(decl);\n     * rule.nodes.length  //=> 4\n     * decl.parent        //=> undefined\n     */\n    removeChild(child) {\n        child = this.index(child);\n        this.nodes[child].parent = undefined;\n        this.nodes.splice(child, 1);\n\n        let index;\n        for ( let id in this.indexes ) {\n            index = this.indexes[id];\n            if ( index >= child ) {\n                this.indexes[id] = index - 1;\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Removes all children from the container\n     * and cleans their parent properties.\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * rule.removeAll();\n     * rule.nodes.length //=> 0\n     */\n    removeAll() {\n        for ( let node of this.nodes ) node.parent = undefined;\n        this.nodes = [];\n        return this;\n    }\n\n    /**\n     * Passes all declaration values within the container that match pattern\n     * through callback, replacing those values with the returned result\n     * of callback.\n     *\n     * This method is useful if you are using a custom unit or function\n     * and need to iterate through all values.\n     *\n     * @param {string|RegExp} pattern      - replace pattern\n     * @param {object} opts                - options to speed up the search\n     * @param {string|string[]} opts.props - an array of property names\n     * @param {string} opts.fast           - string that’s used\n     *                                       to narrow down values and speed up\n                                             the regexp search\n     * @param {function|string} callback   - string to replace pattern\n     *                                       or callback that returns a new\n     *                                       value.\n     *                                       The callback will receive\n     *                                       the same arguments as those\n     *                                       passed to a function parameter\n     *                                       of `String#replace`.\n     *\n     * @return {Node} this node for methods chain\n     *\n     * @example\n     * root.replaceValues(/\\d+rem/, { fast: 'rem' }, string => {\n     *   return 15 * parseInt(string) + 'px';\n     * });\n     */\n    replaceValues(pattern, opts, callback) {\n        if ( !callback ) {\n            callback = opts;\n            opts = { };\n        }\n\n        this.walkDecls( decl => {\n            if ( opts.props && opts.props.indexOf(decl.prop) === -1 ) return;\n            if ( opts.fast  && decl.value.indexOf(opts.fast) === -1 ) return;\n\n            decl.value = decl.value.replace(pattern, callback);\n        });\n\n        return this;\n    }\n\n    /**\n     * Returns `true` if callback returns `true`\n     * for all of the container’s children.\n     *\n     * @param {childCondition} condition - iterator returns true or false.\n     *\n     * @return {boolean} is every child pass condition\n     *\n     * @example\n     * const noPrefixes = rule.every(i => i.prop[0] !== '-');\n     */\n    every(condition) {\n        return this.nodes.every(condition);\n    }\n\n    /**\n     * Returns `true` if callback returns `true` for (at least) one\n     * of the container’s children.\n     *\n     * @param {childCondition} condition - iterator returns true or false.\n     *\n     * @return {boolean} is some child pass condition\n     *\n     * @example\n     * const hasPrefix = rule.some(i => i.prop[0] === '-');\n     */\n    some(condition) {\n        return this.nodes.some(condition);\n    }\n\n    /**\n     * Returns a `child`’s index within the {@link Container#nodes} array.\n     *\n     * @param {Node} child - child of the current container.\n     *\n     * @return {number} child index\n     *\n     * @example\n     * rule.index( rule.nodes[2] ) //=> 2\n     */\n    index(child) {\n        if ( typeof child === 'number' ) {\n            return child;\n        } else {\n            return this.nodes.indexOf(child);\n        }\n    }\n\n    /**\n     * The container’s first child.\n     *\n     * @type {Node}\n     *\n     * @example\n     * rule.first == rules.nodes[0];\n     */\n    get first() {\n        if ( !this.nodes ) return undefined;\n        return this.nodes[0];\n    }\n\n    /**\n     * The container’s last child.\n     *\n     * @type {Node}\n     *\n     * @example\n     * rule.last == rule.nodes[rule.nodes.length - 1];\n     */\n    get last() {\n        if ( !this.nodes ) return undefined;\n        return this.nodes[this.nodes.length - 1];\n    }\n\n    normalize(nodes, sample) {\n        if ( typeof nodes === 'string' ) {\n            let parse = require('./parse');\n            nodes = cleanSource(parse(nodes).nodes);\n        } else if ( !Array.isArray(nodes) ) {\n            if ( nodes.type === 'root' ) {\n                nodes = nodes.nodes;\n            } else if ( nodes.type ) {\n                nodes = [nodes];\n            } else if ( nodes.prop ) {\n                if ( typeof nodes.value === 'undefined' ) {\n                    throw new Error('Value field is missed in node creation');\n                } else if ( typeof nodes.value !== 'string' ) {\n                    nodes.value = String(nodes.value);\n                }\n                nodes = [new Declaration(nodes)];\n            } else if ( nodes.selector ) {\n                let Rule = require('./rule');\n                nodes = [new Rule(nodes)];\n            } else if ( nodes.name ) {\n                let AtRule = require('./at-rule');\n                nodes = [new AtRule(nodes)];\n            } else if ( nodes.text ) {\n                nodes = [new Comment(nodes)];\n            } else {\n                throw new Error('Unknown node type in node creation');\n            }\n        }\n\n        let processed = nodes.map( i => {\n            if ( typeof i.raws === 'undefined' ) i = this.rebuild(i);\n\n            if ( i.parent ) i = i.clone();\n            if ( typeof i.raws.before === 'undefined' ) {\n                if ( sample && typeof sample.raws.before !== 'undefined' ) {\n                    i.raws.before = sample.raws.before.replace(/[^\\s]/g, '');\n                }\n            }\n            i.parent = this;\n            return i;\n        });\n\n        return processed;\n    }\n\n    rebuild(node, parent) {\n        let fix;\n        if ( node.type === 'root' ) {\n            let Root = require('./root');\n            fix = new Root();\n        } else if ( node.type === 'atrule' ) {\n            let AtRule = require('./at-rule');\n            fix = new AtRule();\n        } else if ( node.type === 'rule' ) {\n            let Rule = require('./rule');\n            fix = new Rule();\n        } else if ( node.type === 'decl' ) {\n            fix = new Declaration();\n        } else if ( node.type === 'comment' ) {\n            fix = new Comment();\n        }\n\n        for ( let i in node ) {\n            if ( i === 'nodes' ) {\n                fix.nodes = node.nodes.map( j => this.rebuild(j, fix) );\n            } else if ( i === 'parent' && parent ) {\n                fix.parent = parent;\n            } else if ( node.hasOwnProperty(i) ) {\n                fix[i] = node[i];\n            }\n        }\n\n        return fix;\n    }\n\n    eachInside(callback) {\n        warnOnce('Container#eachInside is deprecated. ' +\n                 'Use Container#walk instead.');\n        return this.walk(callback);\n    }\n\n    eachDecl(prop, callback) {\n        warnOnce('Container#eachDecl is deprecated. ' +\n                 'Use Container#walkDecls instead.');\n        return this.walkDecls(prop, callback);\n    }\n\n    eachRule(selector, callback) {\n        warnOnce('Container#eachRule is deprecated. ' +\n                 'Use Container#walkRules instead.');\n        return this.walkRules(selector, callback);\n    }\n\n    eachAtRule(name, callback) {\n        warnOnce('Container#eachAtRule is deprecated. ' +\n                 'Use Container#walkAtRules instead.');\n        return this.walkAtRules(name, callback);\n    }\n\n    eachComment(callback) {\n        warnOnce('Container#eachComment is deprecated. ' +\n                 'Use Container#walkComments instead.');\n        return this.walkComments(callback);\n    }\n\n    get semicolon() {\n        warnOnce('Node#semicolon is deprecated. Use Node#raws.semicolon');\n        return this.raws.semicolon;\n    }\n\n    set semicolon(val) {\n        warnOnce('Node#semicolon is deprecated. Use Node#raws.semicolon');\n        this.raws.semicolon = val;\n    }\n\n    get after() {\n        warnOnce('Node#after is deprecated. Use Node#raws.after');\n        return this.raws.after;\n    }\n\n    set after(val) {\n        warnOnce('Node#after is deprecated. Use Node#raws.after');\n        this.raws.after = val;\n    }\n\n    /**\n     * @memberof Container#\n     * @member {Node[]} nodes - an array containing the container’s children\n     *\n     * @example\n     * const root = postcss.parse('a { color: black }');\n     * root.nodes.length           //=> 1\n     * root.nodes[0].selector      //=> 'a'\n     * root.nodes[0].nodes[0].prop //=> 'color'\n     */\n\n}\n\nexport default Container;\n\n\n/**\n * @callback childCondition\n * @param {Node} node    - container child\n * @param {number} index - child index\n * @param {Node[]} nodes - all container children\n * @return {boolean}\n */\n\n/**\n * @callback childIterator\n * @param {Node} node    - container child\n * @param {number} index - child index\n * @return {false|undefined} returning `false` will break iteration\n */\n"]}