www.aleph1.co.uk Git - yaffs-website/blob - node_modules/postcss/lib/node.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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
   8
   9 var _cssSyntaxError = require('./css-syntax-error');
  10
  11 var _cssSyntaxError2 = _interopRequireDefault(_cssSyntaxError);
  12
  13 var _stringifier = require('./stringifier');
  14
  15 var _stringifier2 = _interopRequireDefault(_stringifier);
  16
  17 var _stringify = require('./stringify');
  18
  19 var _stringify2 = _interopRequireDefault(_stringify);
  20
  21 var _warnOnce = require('./warn-once');
  22
  23 var _warnOnce2 = _interopRequireDefault(_warnOnce);
  24
  25 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  26
  27 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  28
  29 var cloneNode = function cloneNode(obj, parent) {
  30     var cloned = new obj.constructor();
  31
  32     for (var i in obj) {
  33         if (!obj.hasOwnProperty(i)) continue;
  34         var value = obj[i];
  35         var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
  36
  37         if (i === 'parent' && type === 'object') {
  38             if (parent) cloned[i] = parent;
  39         } else if (i === 'source') {
  40             cloned[i] = value;
  41         } else if (value instanceof Array) {
  42             cloned[i] = value.map(function (j) {
  43                 return cloneNode(j, cloned);
  44             });
  45         } else if (i !== 'before' && i !== 'after' && i !== 'between' && i !== 'semicolon') {
  46             if (type === 'object' && value !== null) value = cloneNode(value);
  47             cloned[i] = value;
  48         }
  49     }
  50
  51     return cloned;
  52 };
  53
  54 /**
  55  * All node classes inherit the following common methods.
  56  *
  57  * @abstract
  58  */
  59
  60 var Node = function () {
  61
  62     /**
  63      * @param {object} [defaults] - value for node properties
  64      */
  65     function Node() {
  66         var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  67
  68         _classCallCheck(this, Node);
  69
  70         this.raws = {};
  71         if ((typeof defaults === 'undefined' ? 'undefined' : _typeof(defaults)) !== 'object' && typeof defaults !== 'undefined') {
  72             throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults));
  73         }
  74         for (var name in defaults) {
  75             this[name] = defaults[name];
  76         }
  77     }
  78
  79     /**
  80      * Returns a CssSyntaxError instance containing the original position
  81      * of the node in the source, showing line and column numbers and also
  82      * a small excerpt to facilitate debugging.
  83      *
  84      * If present, an input source map will be used to get the original position
  85      * of the source, even from a previous compilation step
  86      * (e.g., from Sass compilation).
  87      *
  88      * This method produces very useful error messages.
  89      *
  90      * @param {string} message     - error description
  91      * @param {object} [opts]      - options
  92      * @param {string} opts.plugin - plugin name that created this error.
  93      *                               PostCSS will set it automatically.
  94      * @param {string} opts.word   - a word inside a node’s string that should
  95      *                               be highlighted as the source of the error
  96      * @param {number} opts.index  - an index inside a node’s string that should
  97      *                               be highlighted as the source of the error
  98      *
  99      * @return {CssSyntaxError} error object to throw it
 100      *
 101      * @example
 102      * if ( !variables[name] ) {
 103      *   throw decl.error('Unknown variable ' + name, { word: name });
 104      *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
 105      *   //   color: $black
 106      *   // a
 107      *   //          ^
 108      *   //   background: white
 109      * }
 110      */
 111
 112
 113     Node.prototype.error = function error(message) {
 114         var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 115
 116         if (this.source) {
 117             var pos = this.positionBy(opts);
 118             return this.source.input.error(message, pos.line, pos.column, opts);
 119         } else {
 120             return new _cssSyntaxError2.default(message);
 121         }
 122     };
 123
 124     /**
 125      * This method is provided as a convenience wrapper for {@link Result#warn}.
 126      *
 127      * @param {Result} result      - the {@link Result} instance
 128      *                               that will receive the warning
 129      * @param {string} text        - warning message
 130      * @param {object} [opts]      - options
 131      * @param {string} opts.plugin - plugin name that created this warning.
 132      *                               PostCSS will set it automatically.
 133      * @param {string} opts.word   - a word inside a node’s string that should
 134      *                               be highlighted as the source of the warning
 135      * @param {number} opts.index  - an index inside a node’s string that should
 136      *                               be highlighted as the source of the warning
 137      *
 138      * @return {Warning} created warning object
 139      *
 140      * @example
 141      * const plugin = postcss.plugin('postcss-deprecated', () => {
 142      *   return (root, result) => {
 143      *     root.walkDecls('bad', decl => {
 144      *       decl.warn(result, 'Deprecated property bad');
 145      *     });
 146      *   };
 147      * });
 148      */
 149
 150
 151     Node.prototype.warn = function warn(result, text, opts) {
 152         var data = { node: this };
 153         for (var i in opts) {
 154             data[i] = opts[i];
 155         }return result.warn(text, data);
 156     };
 157
 158     /**
 159      * Removes the node from its parent and cleans the parent properties
 160      * from the node and its children.
 161      *
 162      * @example
 163      * if ( decl.prop.match(/^-webkit-/) ) {
 164      *   decl.remove();
 165      * }
 166      *
 167      * @return {Node} node to make calls chain
 168      */
 169
 170
 171     Node.prototype.remove = function remove() {
 172         if (this.parent) {
 173             this.parent.removeChild(this);
 174         }
 175         this.parent = undefined;
 176         return this;
 177     };
 178
 179     /**
 180      * Returns a CSS string representing the node.
 181      *
 182      * @param {stringifier|syntax} [stringifier] - a syntax to use
 183      *                                             in string generation
 184      *
 185      * @return {string} CSS string of this node
 186      *
 187      * @example
 188      * postcss.rule({ selector: 'a' }).toString() //=> "a {}"
 189      */
 190
 191
 192     Node.prototype.toString = function toString() {
 193         var stringifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _stringify2.default;
 194
 195         if (stringifier.stringify) stringifier = stringifier.stringify;
 196         var result = '';
 197         stringifier(this, function (i) {
 198             result += i;
 199         });
 200         return result;
 201     };
 202
 203     /**
 204      * Returns a clone of the node.
 205      *
 206      * The resulting cloned node and its (cloned) children will have
 207      * a clean parent and code style properties.
 208      *
 209      * @param {object} [overrides] - new properties to override in the clone.
 210      *
 211      * @example
 212      * const cloned = decl.clone({ prop: '-moz-' + decl.prop });
 213      * cloned.raws.before  //=> undefined
 214      * cloned.parent       //=> undefined
 215      * cloned.toString()   //=> -moz-transform: scale(0)
 216      *
 217      * @return {Node} clone of the node
 218      */
 219
 220
 221     Node.prototype.clone = function clone() {
 222         var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 223
 224         var cloned = cloneNode(this);
 225         for (var name in overrides) {
 226             cloned[name] = overrides[name];
 227         }
 228         return cloned;
 229     };
 230
 231     /**
 232      * Shortcut to clone the node and insert the resulting cloned node
 233      * before the current node.
 234      *
 235      * @param {object} [overrides] - new properties to override in the clone.
 236      *
 237      * @example
 238      * decl.cloneBefore({ prop: '-moz-' + decl.prop });
 239      *
 240      * @return {Node} - new node
 241      */
 242
 243
 244     Node.prototype.cloneBefore = function cloneBefore() {
 245         var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 246
 247         var cloned = this.clone(overrides);
 248         this.parent.insertBefore(this, cloned);
 249         return cloned;
 250     };
 251
 252     /**
 253      * Shortcut to clone the node and insert the resulting cloned node
 254      * after the current node.
 255      *
 256      * @param {object} [overrides] - new properties to override in the clone.
 257      *
 258      * @return {Node} - new node
 259      */
 260
 261
 262     Node.prototype.cloneAfter = function cloneAfter() {
 263         var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 264
 265         var cloned = this.clone(overrides);
 266         this.parent.insertAfter(this, cloned);
 267         return cloned;
 268     };
 269
 270     /**
 271      * Inserts node(s) before the current node and removes the current node.
 272      *
 273      * @param {...Node} nodes - node(s) to replace current one
 274      *
 275      * @example
 276      * if ( atrule.name == 'mixin' ) {
 277      *   atrule.replaceWith(mixinRules[atrule.params]);
 278      * }
 279      *
 280      * @return {Node} current node to methods chain
 281      */
 282
 283
 284     Node.prototype.replaceWith = function replaceWith() {
 285         if (this.parent) {
 286             for (var _len = arguments.length, nodes = Array(_len), _key = 0; _key < _len; _key++) {
 287                 nodes[_key] = arguments[_key];
 288             }
 289
 290             for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
 291                 var _ref;
 292
 293                 if (_isArray) {
 294                     if (_i >= _iterator.length) break;
 295                     _ref = _iterator[_i++];
 296                 } else {
 297                     _i = _iterator.next();
 298                     if (_i.done) break;
 299                     _ref = _i.value;
 300                 }
 301
 302                 var node = _ref;
 303
 304                 this.parent.insertBefore(this, node);
 305             }
 306
 307             this.remove();
 308         }
 309
 310         return this;
 311     };
 312
 313     /**
 314      * Removes the node from its current parent and inserts it
 315      * at the end of `newParent`.
 316      *
 317      * This will clean the `before` and `after` code {@link Node#raws} data
 318      * from the node and replace them with the indentation style of `newParent`.
 319      * It will also clean the `between` property
 320      * if `newParent` is in another {@link Root}.
 321      *
 322      * @param {Container} newParent - container node where the current node
 323      *                                will be moved
 324      *
 325      * @example
 326      * atrule.moveTo(atrule.root());
 327      *
 328      * @return {Node} current node to methods chain
 329      */
 330
 331
 332     Node.prototype.moveTo = function moveTo(newParent) {
 333         this.cleanRaws(this.root() === newParent.root());
 334         this.remove();
 335         newParent.append(this);
 336         return this;
 337     };
 338
 339     /**
 340      * Removes the node from its current parent and inserts it into
 341      * a new parent before `otherNode`.
 342      *
 343      * This will also clean the node’s code style properties just as it would
 344      * in {@link Node#moveTo}.
 345      *
 346      * @param {Node} otherNode - node that will be before current node
 347      *
 348      * @return {Node} current node to methods chain
 349      */
 350
 351
 352     Node.prototype.moveBefore = function moveBefore(otherNode) {
 353         this.cleanRaws(this.root() === otherNode.root());
 354         this.remove();
 355         otherNode.parent.insertBefore(otherNode, this);
 356         return this;
 357     };
 358
 359     /**
 360      * Removes the node from its current parent and inserts it into
 361      * a new parent after `otherNode`.
 362      *
 363      * This will also clean the node’s code style properties just as it would
 364      * in {@link Node#moveTo}.
 365      *
 366      * @param {Node} otherNode - node that will be after current node
 367      *
 368      * @return {Node} current node to methods chain
 369      */
 370
 371
 372     Node.prototype.moveAfter = function moveAfter(otherNode) {
 373         this.cleanRaws(this.root() === otherNode.root());
 374         this.remove();
 375         otherNode.parent.insertAfter(otherNode, this);
 376         return this;
 377     };
 378
 379     /**
 380      * Returns the next child of the node’s parent.
 381      * Returns `undefined` if the current node is the last child.
 382      *
 383      * @return {Node|undefined} next node
 384      *
 385      * @example
 386      * if ( comment.text === 'delete next' ) {
 387      *   const next = comment.next();
 388      *   if ( next ) {
 389      *     next.remove();
 390      *   }
 391      * }
 392      */
 393
 394
 395     Node.prototype.next = function next() {
 396         var index = this.parent.index(this);
 397         return this.parent.nodes[index + 1];
 398     };
 399
 400     /**
 401      * Returns the previous child of the node’s parent.
 402      * Returns `undefined` if the current node is the first child.
 403      *
 404      * @return {Node|undefined} previous node
 405      *
 406      * @example
 407      * const annotation = decl.prev();
 408      * if ( annotation.type == 'comment' ) {
 409      *  readAnnotation(annotation.text);
 410      * }
 411      */
 412
 413
 414     Node.prototype.prev = function prev() {
 415         var index = this.parent.index(this);
 416         return this.parent.nodes[index - 1];
 417     };
 418
 419     Node.prototype.toJSON = function toJSON() {
 420         var fixed = {};
 421
 422         for (var name in this) {
 423             if (!this.hasOwnProperty(name)) continue;
 424             if (name === 'parent') continue;
 425             var value = this[name];
 426
 427             if (value instanceof Array) {
 428                 fixed[name] = value.map(function (i) {
 429                     if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && i.toJSON) {
 430                         return i.toJSON();
 431                     } else {
 432                         return i;
 433                     }
 434                 });
 435             } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.toJSON) {
 436                 fixed[name] = value.toJSON();
 437             } else {
 438                 fixed[name] = value;
 439             }
 440         }
 441
 442         return fixed;
 443     };
 444
 445     /**
 446      * Returns a {@link Node#raws} value. If the node is missing
 447      * the code style property (because the node was manually built or cloned),
 448      * PostCSS will try to autodetect the code style property by looking
 449      * at other nodes in the tree.
 450      *
 451      * @param {string} prop          - name of code style property
 452      * @param {string} [defaultType] - name of default value, it can be missed
 453      *                                 if the value is the same as prop
 454      *
 455      * @example
 456      * const root = postcss.parse('a { background: white }');
 457      * root.nodes[0].append({ prop: 'color', value: 'black' });
 458      * root.nodes[0].nodes[1].raws.before   //=> undefined
 459      * root.nodes[0].nodes[1].raw('before') //=> ' '
 460      *
 461      * @return {string} code style value
 462      */
 463
 464
 465     Node.prototype.raw = function raw(prop, defaultType) {
 466         var str = new _stringifier2.default();
 467         return str.raw(this, prop, defaultType);
 468     };
 469
 470     /**
 471      * Finds the Root instance of the node’s tree.
 472      *
 473      * @example
 474      * root.nodes[0].nodes[0].root() === root
 475      *
 476      * @return {Root} root parent
 477      */
 478
 479
 480     Node.prototype.root = function root() {
 481         var result = this;
 482         while (result.parent) {
 483             result = result.parent;
 484         }return result;
 485     };
 486
 487     Node.prototype.cleanRaws = function cleanRaws(keepBetween) {
 488         delete this.raws.before;
 489         delete this.raws.after;
 490         if (!keepBetween) delete this.raws.between;
 491     };
 492
 493     Node.prototype.positionInside = function positionInside(index) {
 494         var string = this.toString();
 495         var column = this.source.start.column;
 496         var line = this.source.start.line;
 497
 498         for (var i = 0; i < index; i++) {
 499             if (string[i] === '\n') {
 500                 column = 1;
 501                 line += 1;
 502             } else {
 503                 column += 1;
 504             }
 505         }
 506
 507         return { line: line, column: column };
 508     };
 509
 510     Node.prototype.positionBy = function positionBy(opts) {
 511         var pos = this.source.start;
 512         if (opts.index) {
 513             pos = this.positionInside(opts.index);
 514         } else if (opts.word) {
 515             var index = this.toString().indexOf(opts.word);
 516             if (index !== -1) pos = this.positionInside(index);
 517         }
 518         return pos;
 519     };
 520
 521     Node.prototype.removeSelf = function removeSelf() {
 522         (0, _warnOnce2.default)('Node#removeSelf is deprecated. Use Node#remove.');
 523         return this.remove();
 524     };
 525
 526     Node.prototype.replace = function replace(nodes) {
 527         (0, _warnOnce2.default)('Node#replace is deprecated. Use Node#replaceWith');
 528         return this.replaceWith(nodes);
 529     };
 530
 531     Node.prototype.style = function style(own, detect) {
 532         (0, _warnOnce2.default)('Node#style() is deprecated. Use Node#raw()');
 533         return this.raw(own, detect);
 534     };
 535
 536     Node.prototype.cleanStyles = function cleanStyles(keepBetween) {
 537         (0, _warnOnce2.default)('Node#cleanStyles() is deprecated. Use Node#cleanRaws()');
 538         return this.cleanRaws(keepBetween);
 539     };
 540
 541     _createClass(Node, [{
 542         key: 'before',
 543         get: function get() {
 544             (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before');
 545             return this.raws.before;
 546         },
 547         set: function set(val) {
 548             (0, _warnOnce2.default)('Node#before is deprecated. Use Node#raws.before');
 549             this.raws.before = val;
 550         }
 551     }, {
 552         key: 'between',
 553         get: function get() {
 554             (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between');
 555             return this.raws.between;
 556         },
 557         set: function set(val) {
 558             (0, _warnOnce2.default)('Node#between is deprecated. Use Node#raws.between');
 559             this.raws.between = val;
 560         }
 561
 562         /**
 563          * @memberof Node#
 564          * @member {string} type - String representing the node’s type.
 565          *                         Possible values are `root`, `atrule`, `rule`,
 566          *                         `decl`, or `comment`.
 567          *
 568          * @example
 569          * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'
 570          */
 571
 572         /**
 573          * @memberof Node#
 574          * @member {Container} parent - the node’s parent node.
 575          *
 576          * @example
 577          * root.nodes[0].parent == root;
 578          */
 579
 580         /**
 581          * @memberof Node#
 582          * @member {source} source - the input source of the node
 583          *
 584          * The property is used in source map generation.
 585          *
 586          * If you create a node manually (e.g., with `postcss.decl()`),
 587          * that node will not have a `source` property and will be absent
 588          * from the source map. For this reason, the plugin developer should
 589          * consider cloning nodes to create new ones (in which case the new node’s
 590          * source will reference the original, cloned node) or setting
 591          * the `source` property manually.
 592          *
 593          * ```js
 594          * // Bad
 595          * const prefixed = postcss.decl({
 596          *   prop: '-moz-' + decl.prop,
 597          *   value: decl.value
 598          * });
 599          *
 600          * // Good
 601          * const prefixed = decl.clone({ prop: '-moz-' + decl.prop });
 602          * ```
 603          *
 604          * ```js
 605          * if ( atrule.name == 'add-link' ) {
 606          *   const rule = postcss.rule({ selector: 'a', source: atrule.source });
 607          *   atrule.parent.insertBefore(atrule, rule);
 608          * }
 609          * ```
 610          *
 611          * @example
 612          * decl.source.input.from //=> '/home/ai/a.sass'
 613          * decl.source.start      //=> { line: 10, column: 2 }
 614          * decl.source.end        //=> { line: 10, column: 12 }
 615          */
 616
 617         /**
 618          * @memberof Node#
 619          * @member {object} raws - Information to generate byte-to-byte equal
 620          *                         node string as it was in the origin input.
 621          *
 622          * Every parser saves its own properties,
 623          * but the default CSS parser uses:
 624          *
 625          * * `before`: the space symbols before the node. It also stores `*`
 626          *   and `_` symbols before the declaration (IE hack).
 627          * * `after`: the space symbols after the last child of the node
 628          *   to the end of the node.
 629          * * `between`: the symbols between the property and value
 630          *   for declarations, selector and `{` for rules, or last parameter
 631          *   and `{` for at-rules.
 632          * * `semicolon`: contains true if the last child has
 633          *   an (optional) semicolon.
 634          * * `afterName`: the space between the at-rule name and its parameters.
 635          * * `left`: the space symbols between `/*` and the comment’s text.
 636          * * `right`: the space symbols between the comment’s text
 637          *   and <code>*&#47;</code>.
 638          * * `important`: the content of the important statement,
 639          *   if it is not just `!important`.
 640          *
 641          * PostCSS cleans selectors, declaration values and at-rule parameters
 642          * from comments and extra spaces, but it stores origin content in raws
 643          * properties. As such, if you don’t change a declaration’s value,
 644          * PostCSS will use the raw value with comments.
 645          *
 646          * @example
 647          * const root = postcss.parse('a {\n  color:black\n}')
 648          * root.first.first.raws //=> { before: '\n  ', between: ':' }
 649          */
 650
 651     }]);
 652
 653     return Node;
 654 }();
 655
 656 exports.default = Node;
 657
 658 /**
 659  * @typedef {object} position
 660  * @property {number} line   - source line in file
 661  * @property {number} column - source column in file
 662  */
 663
 664 /**
 665  * @typedef {object} source
 666  * @property {Input} input    - {@link Input} with input file
 667  * @property {position} start - The starting position of the node’s source
 668  * @property {position} end   - The ending position of the node’s source
 669  */
 670
 671 module.exports = exports['default'];
 672 //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["node.es6"],"names":["cloneNode","obj","parent","cloned","constructor","i","hasOwnProperty","value","type","Array","map","j","Node","defaults","raws","Error","JSON","stringify","name","error","message","opts","source","pos","positionBy","input","line","column","warn","result","text","data","node","remove","removeChild","undefined","toString","stringifier","clone","overrides","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","nodes","moveTo","newParent","cleanRaws","root","append","moveBefore","otherNode","moveAfter","next","index","prev","toJSON","fixed","raw","prop","defaultType","str","keepBetween","before","after","between","positionInside","string","start","word","indexOf","removeSelf","replace","style","own","detect","cleanStyles","val"],"mappings":"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","file":"node.js","sourcesContent":["import CssSyntaxError from './css-syntax-error';\nimport Stringifier    from './stringifier';\nimport stringify      from './stringify';\nimport warnOnce       from './warn-once';\n\nlet cloneNode = function (obj, parent) {\n    let cloned = new obj.constructor();\n\n    for ( let i in obj ) {\n        if ( !obj.hasOwnProperty(i) ) continue;\n        let value = obj[i];\n        let type  = typeof value;\n\n        if ( i === 'parent' && type === 'object' ) {\n            if (parent) cloned[i] = parent;\n        } else if ( i === 'source' ) {\n            cloned[i] = value;\n        } else if ( value instanceof Array ) {\n            cloned[i] = value.map( j => cloneNode(j, cloned) );\n        } else if ( i !== 'before'  && i !== 'after' &&\n                    i !== 'between' && i !== 'semicolon' ) {\n            if ( type === 'object' && value !== null ) value = cloneNode(value);\n            cloned[i] = value;\n        }\n    }\n\n    return cloned;\n};\n\n/**\n * All node classes inherit the following common methods.\n *\n * @abstract\n */\nclass Node {\n\n    /**\n     * @param {object} [defaults] - value for node properties\n     */\n    constructor(defaults = { }) {\n        this.raws = { };\n        if ( typeof defaults !== 'object' && typeof defaults !== 'undefined' ) {\n            throw new Error(\n                'PostCSS nodes constructor accepts object, not ' +\n                JSON.stringify(defaults));\n        }\n        for ( let name in defaults ) {\n            this[name] = defaults[name];\n        }\n    }\n\n    /**\n     * Returns a CssSyntaxError instance containing the original position\n     * of the node in the source, showing line and column numbers and also\n     * a small excerpt to facilitate debugging.\n     *\n     * If present, an input source map will be used to get the original position\n     * of the source, even from a previous compilation step\n     * (e.g., from Sass compilation).\n     *\n     * This method produces very useful error messages.\n     *\n     * @param {string} message     - error description\n     * @param {object} [opts]      - options\n     * @param {string} opts.plugin - plugin name that created this error.\n     *                               PostCSS will set it automatically.\n     * @param {string} opts.word   - a word inside a node’s string that should\n     *                               be highlighted as the source of the error\n     * @param {number} opts.index  - an index inside a node’s string that should\n     *                               be highlighted as the source of the error\n     *\n     * @return {CssSyntaxError} error object to throw it\n     *\n     * @example\n     * if ( !variables[name] ) {\n     *   throw decl.error('Unknown variable ' + name, { word: name });\n     *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black\n     *   //   color: $black\n     *   // a\n     *   //          ^\n     *   //   background: white\n     * }\n     */\n    error(message, opts = { }) {\n        if ( this.source ) {\n            let pos = this.positionBy(opts);\n            return this.source.input.error(message, pos.line, pos.column, opts);\n        } else {\n            return new CssSyntaxError(message);\n        }\n    }\n\n    /**\n     * This method is provided as a convenience wrapper for {@link Result#warn}.\n     *\n     * @param {Result} result      - the {@link Result} instance\n     *                               that will receive the warning\n     * @param {string} text        - warning message\n     * @param {object} [opts]      - options\n     * @param {string} opts.plugin - plugin name that created this warning.\n     *                               PostCSS will set it automatically.\n     * @param {string} opts.word   - a word inside a node’s string that should\n     *                               be highlighted as the source of the warning\n     * @param {number} opts.index  - an index inside a node’s string that should\n     *                               be highlighted as the source of the warning\n     *\n     * @return {Warning} created warning object\n     *\n     * @example\n     * const plugin = postcss.plugin('postcss-deprecated', () => {\n     *   return (root, result) => {\n     *     root.walkDecls('bad', decl => {\n     *       decl.warn(result, 'Deprecated property bad');\n     *     });\n     *   };\n     * });\n     */\n    warn(result, text, opts) {\n        let data = { node: this };\n        for ( let i in opts ) data[i] = opts[i];\n        return result.warn(text, data);\n    }\n\n    /**\n     * Removes the node from its parent and cleans the parent properties\n     * from the node and its children.\n     *\n     * @example\n     * if ( decl.prop.match(/^-webkit-/) ) {\n     *   decl.remove();\n     * }\n     *\n     * @return {Node} node to make calls chain\n     */\n    remove() {\n        if ( this.parent ) {\n            this.parent.removeChild(this);\n        }\n        this.parent = undefined;\n        return this;\n    }\n\n    /**\n     * Returns a CSS string representing the node.\n     *\n     * @param {stringifier|syntax} [stringifier] - a syntax to use\n     *                                             in string generation\n     *\n     * @return {string} CSS string of this node\n     *\n     * @example\n     * postcss.rule({ selector: 'a' }).toString() //=> \"a {}\"\n     */\n    toString(stringifier = stringify) {\n        if ( stringifier.stringify ) stringifier = stringifier.stringify;\n        let result  = '';\n        stringifier(this, i => {\n            result += i;\n        });\n        return result;\n    }\n\n    /**\n     * Returns a clone of the node.\n     *\n     * The resulting cloned node and its (cloned) children will have\n     * a clean parent and code style properties.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @example\n     * const cloned = decl.clone({ prop: '-moz-' + decl.prop });\n     * cloned.raws.before  //=> undefined\n     * cloned.parent       //=> undefined\n     * cloned.toString()   //=> -moz-transform: scale(0)\n     *\n     * @return {Node} clone of the node\n     */\n    clone(overrides = { }) {\n        let cloned = cloneNode(this);\n        for ( let name in overrides ) {\n            cloned[name] = overrides[name];\n        }\n        return cloned;\n    }\n\n    /**\n     * Shortcut to clone the node and insert the resulting cloned node\n     * before the current node.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @example\n     * decl.cloneBefore({ prop: '-moz-' + decl.prop });\n     *\n     * @return {Node} - new node\n     */\n    cloneBefore(overrides = { }) {\n        let cloned = this.clone(overrides);\n        this.parent.insertBefore(this, cloned);\n        return cloned;\n    }\n\n    /**\n     * Shortcut to clone the node and insert the resulting cloned node\n     * after the current node.\n     *\n     * @param {object} [overrides] - new properties to override in the clone.\n     *\n     * @return {Node} - new node\n     */\n    cloneAfter(overrides = { }) {\n        let cloned = this.clone(overrides);\n        this.parent.insertAfter(this, cloned);\n        return cloned;\n    }\n\n    /**\n     * Inserts node(s) before the current node and removes the current node.\n     *\n     * @param {...Node} nodes - node(s) to replace current one\n     *\n     * @example\n     * if ( atrule.name == 'mixin' ) {\n     *   atrule.replaceWith(mixinRules[atrule.params]);\n     * }\n     *\n     * @return {Node} current node to methods chain\n     */\n    replaceWith(...nodes) {\n        if (this.parent) {\n            for (let node of nodes) {\n                this.parent.insertBefore(this, node);\n            }\n\n            this.remove();\n        }\n\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it\n     * at the end of `newParent`.\n     *\n     * This will clean the `before` and `after` code {@link Node#raws} data\n     * from the node and replace them with the indentation style of `newParent`.\n     * It will also clean the `between` property\n     * if `newParent` is in another {@link Root}.\n     *\n     * @param {Container} newParent - container node where the current node\n     *                                will be moved\n     *\n     * @example\n     * atrule.moveTo(atrule.root());\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveTo(newParent) {\n        this.cleanRaws(this.root() === newParent.root());\n        this.remove();\n        newParent.append(this);\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it into\n     * a new parent before `otherNode`.\n     *\n     * This will also clean the node’s code style properties just as it would\n     * in {@link Node#moveTo}.\n     *\n     * @param {Node} otherNode - node that will be before current node\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveBefore(otherNode) {\n        this.cleanRaws(this.root() === otherNode.root());\n        this.remove();\n        otherNode.parent.insertBefore(otherNode, this);\n        return this;\n    }\n\n    /**\n     * Removes the node from its current parent and inserts it into\n     * a new parent after `otherNode`.\n     *\n     * This will also clean the node’s code style properties just as it would\n     * in {@link Node#moveTo}.\n     *\n     * @param {Node} otherNode - node that will be after current node\n     *\n     * @return {Node} current node to methods chain\n     */\n    moveAfter(otherNode) {\n        this.cleanRaws(this.root() === otherNode.root());\n        this.remove();\n        otherNode.parent.insertAfter(otherNode, this);\n        return this;\n    }\n\n    /**\n     * Returns the next child of the node’s parent.\n     * Returns `undefined` if the current node is the last child.\n     *\n     * @return {Node|undefined} next node\n     *\n     * @example\n     * if ( comment.text === 'delete next' ) {\n     *   const next = comment.next();\n     *   if ( next ) {\n     *     next.remove();\n     *   }\n     * }\n     */\n    next() {\n        let index = this.parent.index(this);\n        return this.parent.nodes[index + 1];\n    }\n\n    /**\n     * Returns the previous child of the node’s parent.\n     * Returns `undefined` if the current node is the first child.\n     *\n     * @return {Node|undefined} previous node\n     *\n     * @example\n     * const annotation = decl.prev();\n     * if ( annotation.type == 'comment' ) {\n     *  readAnnotation(annotation.text);\n     * }\n     */\n    prev() {\n        let index = this.parent.index(this);\n        return this.parent.nodes[index - 1];\n    }\n\n    toJSON() {\n        let fixed = { };\n\n        for ( let name in this ) {\n            if ( !this.hasOwnProperty(name) ) continue;\n            if ( name === 'parent' ) continue;\n            let value = this[name];\n\n            if ( value instanceof Array ) {\n                fixed[name] = value.map( i => {\n                    if ( typeof i === 'object' && i.toJSON ) {\n                        return i.toJSON();\n                    } else {\n                        return i;\n                    }\n                });\n            } else if ( typeof value === 'object' && value.toJSON ) {\n                fixed[name] = value.toJSON();\n            } else {\n                fixed[name] = value;\n            }\n        }\n\n        return fixed;\n    }\n\n    /**\n     * Returns a {@link Node#raws} value. If the node is missing\n     * the code style property (because the node was manually built or cloned),\n     * PostCSS will try to autodetect the code style property by looking\n     * at other nodes in the tree.\n     *\n     * @param {string} prop          - name of code style property\n     * @param {string} [defaultType] - name of default value, it can be missed\n     *                                 if the value is the same as prop\n     *\n     * @example\n     * const root = postcss.parse('a { background: white }');\n     * root.nodes[0].append({ prop: 'color', value: 'black' });\n     * root.nodes[0].nodes[1].raws.before   //=> undefined\n     * root.nodes[0].nodes[1].raw('before') //=> ' '\n     *\n     * @return {string} code style value\n     */\n    raw(prop, defaultType) {\n        let str = new Stringifier();\n        return str.raw(this, prop, defaultType);\n    }\n\n    /**\n     * Finds the Root instance of the node’s tree.\n     *\n     * @example\n     * root.nodes[0].nodes[0].root() === root\n     *\n     * @return {Root} root parent\n     */\n    root() {\n        let result = this;\n        while ( result.parent ) result = result.parent;\n        return result;\n    }\n\n    cleanRaws(keepBetween) {\n        delete this.raws.before;\n        delete this.raws.after;\n        if ( !keepBetween ) delete this.raws.between;\n    }\n\n    positionInside(index) {\n        let string = this.toString();\n        let column = this.source.start.column;\n        let line   = this.source.start.line;\n\n        for ( let i = 0; i < index; i++ ) {\n            if ( string[i] === '\\n' ) {\n                column = 1;\n                line  += 1;\n            } else {\n                column += 1;\n            }\n        }\n\n        return { line, column };\n    }\n\n    positionBy(opts) {\n        let pos = this.source.start;\n        if ( opts.index ) {\n            pos = this.positionInside(opts.index);\n        } else if ( opts.word ) {\n            let index = this.toString().indexOf(opts.word);\n            if ( index !== -1 ) pos = this.positionInside(index);\n        }\n        return pos;\n    }\n\n    removeSelf() {\n        warnOnce('Node#removeSelf is deprecated. Use Node#remove.');\n        return this.remove();\n    }\n\n    replace(nodes) {\n        warnOnce('Node#replace is deprecated. Use Node#replaceWith');\n        return this.replaceWith(nodes);\n    }\n\n    style(own, detect) {\n        warnOnce('Node#style() is deprecated. Use Node#raw()');\n        return this.raw(own, detect);\n    }\n\n    cleanStyles(keepBetween) {\n        warnOnce('Node#cleanStyles() is deprecated. Use Node#cleanRaws()');\n        return this.cleanRaws(keepBetween);\n    }\n\n    get before() {\n        warnOnce('Node#before is deprecated. Use Node#raws.before');\n        return this.raws.before;\n    }\n\n    set before(val) {\n        warnOnce('Node#before is deprecated. Use Node#raws.before');\n        this.raws.before = val;\n    }\n\n    get between() {\n        warnOnce('Node#between is deprecated. Use Node#raws.between');\n        return this.raws.between;\n    }\n\n    set between(val) {\n        warnOnce('Node#between is deprecated. Use Node#raws.between');\n        this.raws.between = val;\n    }\n\n    /**\n     * @memberof Node#\n     * @member {string} type - String representing the node’s type.\n     *                         Possible values are `root`, `atrule`, `rule`,\n     *                         `decl`, or `comment`.\n     *\n     * @example\n     * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'\n     */\n\n    /**\n     * @memberof Node#\n     * @member {Container} parent - the node’s parent node.\n     *\n     * @example\n     * root.nodes[0].parent == root;\n     */\n\n    /**\n     * @memberof Node#\n     * @member {source} source - the input source of the node\n     *\n     * The property is used in source map generation.\n     *\n     * If you create a node manually (e.g., with `postcss.decl()`),\n     * that node will not have a `source` property and will be absent\n     * from the source map. For this reason, the plugin developer should\n     * consider cloning nodes to create new ones (in which case the new node’s\n     * source will reference the original, cloned node) or setting\n     * the `source` property manually.\n     *\n     * ```js\n     * // Bad\n     * const prefixed = postcss.decl({\n     *   prop: '-moz-' + decl.prop,\n     *   value: decl.value\n     * });\n     *\n     * // Good\n     * const prefixed = decl.clone({ prop: '-moz-' + decl.prop });\n     * ```\n     *\n     * ```js\n     * if ( atrule.name == 'add-link' ) {\n     *   const rule = postcss.rule({ selector: 'a', source: atrule.source });\n     *   atrule.parent.insertBefore(atrule, rule);\n     * }\n     * ```\n     *\n     * @example\n     * decl.source.input.from //=> '/home/ai/a.sass'\n     * decl.source.start      //=> { line: 10, column: 2 }\n     * decl.source.end        //=> { line: 10, column: 12 }\n     */\n\n    /**\n     * @memberof Node#\n     * @member {object} raws - Information to generate byte-to-byte equal\n     *                         node string as it was in the origin input.\n     *\n     * Every parser saves its own properties,\n     * but the default CSS parser uses:\n     *\n     * * `before`: the space symbols before the node. It also stores `*`\n     *   and `_` symbols before the declaration (IE hack).\n     * * `after`: the space symbols after the last child of the node\n     *   to the end of the node.\n     * * `between`: the symbols between the property and value\n     *   for declarations, selector and `{` for rules, or last parameter\n     *   and `{` for at-rules.\n     * * `semicolon`: contains true if the last child has\n     *   an (optional) semicolon.\n     * * `afterName`: the space between the at-rule name and its parameters.\n     * * `left`: the space symbols between `/*` and the comment’s text.\n     * * `right`: the space symbols between the comment’s text\n     *   and <code>*&#47;</code>.\n     * * `important`: the content of the important statement,\n     *   if it is not just `!important`.\n     *\n     * PostCSS cleans selectors, declaration values and at-rule parameters\n     * from comments and extra spaces, but it stores origin content in raws\n     * properties. As such, if you don’t change a declaration’s value,\n     * PostCSS will use the raw value with comments.\n     *\n     * @example\n     * const root = postcss.parse('a {\\n  color:black\\n}')\n     * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n     */\n\n}\n\nexport default Node;\n\n/**\n * @typedef {object} position\n * @property {number} line   - source line in file\n * @property {number} column - source column in file\n */\n\n/**\n * @typedef {object} source\n * @property {Input} input    - {@link Input} with input file\n * @property {position} start - The starting position of the node’s source\n * @property {position} end   - The ending position of the node’s source\n */\n"]}