postcss 6.0.22 → 7.0.2

package/lib/processor.js

@@ -17,15 +17,14 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
  * initialize its plugins, and then use that instance on numerous CSS files.
  *
  * @example
- * const processor = postcss([autoprefixer, precss]);
- * processor.process(css1).then(result => console.log(result.css));
- * processor.process(css2).then(result => console.log(result.css));
+ * const processor = postcss([autoprefixer, precss])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
  */
 var Processor = function () {
-
   /**
-   * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS
-   *        plugins. See {@link Processor#use} for plugin format.
+   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.
+   *        See {@link Processor#use} for plugin format.
    */
   function Processor() {
     var plugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
@@ -33,19 +32,23 @@ var Processor = function () {
     _classCallCheck(this, Processor);
 
     /**
-     * @member {string} - Current PostCSS version.
+     * Current PostCSS version.
+     *
+     * @type {string}
      *
      * @example
-     * if ( result.processor.version.split('.')[0] !== '6' ) {
-     *   throw new Error('This plugin works only with PostCSS 6');
+     * if (result.processor.version.split('.')[0] !== '6') {
+     *   throw new Error('This plugin works only with PostCSS 6')
      * }
      */
-    this.version = '6.0.22';
+    this.version = '7.0.2';
     /**
-     * @member {pluginFunction[]} - Plugins added to this processor.
+     * Plugins added to this processor.
+     *
+     * @type {pluginFunction[]}
      *
      * @example
-     * const processor = postcss([autoprefixer, precss]);
+     * const processor = postcss([autoprefixer, precss])
      * processor.plugins.length //=> 2
      */
     this.plugins = this.normalize(plugins);
@@ -69,16 +72,16 @@ var Processor = function () {
    *
    * Asynchronous plugins should return a `Promise` instance.
    *
-   * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin
-   *                                                   or {@link Processor}
-   *                                                   with plugins
+   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin
+   *                                                 or {@link Processor}
+   *                                                 with plugins.
    *
    * @example
    * const processor = postcss()
    *   .use(autoprefixer)
-   *   .use(precss);
+   *   .use(precss)
    *
-   * @return {Processes} current processor to make methods chain
+   * @return {Processes} Current processor to make methods chain.
    */
 
 
@@ -93,29 +96,46 @@ var Processor = function () {
    * any transformations. Transformations will be applied
    * in the {@link LazyResult} methods.
    *
-   * @param {string|toString|Result} css - String with input CSS or
-   *                                       any object with a `toString()`
-   *                                       method, like a Buffer.
-   *                                       Optionally, send a {@link Result}
-   *                                       instance and the processor will
-   *                                       take the {@link Root} from it.
-   * @param {processOptions} [opts]      - options
+   * @param {string|toString|Result} css String with input CSS or any object
+   *                                     with a `toString()` method,
+   *                                     like a Buffer. Optionally, send
+   *                                     a {@link Result} instance
+   *                                     and the processor will take
+   *                                     the {@link Root} from it.
+   * @param {processOptions} [opts]      Options.
    *
-   * @return {LazyResult} Promise proxy
+   * @return {LazyResult} Promise proxy.
    *
    * @example
    * processor.process(css, { from: 'a.css', to: 'a.out.css' })
    *   .then(result => {
-   *      console.log(result.css);
-   *   });
+   *      console.log(result.css)
+   *   })
    */
 
 
-  Processor.prototype.process = function process(css) {
+  Processor.prototype.process = function (_process) {
+    function process(_x) {
+      return _process.apply(this, arguments);
+    }
+
+    process.toString = function () {
+      return _process.toString();
+    };
+
+    return process;
+  }(function (css) {
     var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
+    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn('You did not set any plugins, parser, or stringifier. ' + 'Right now PostCSS do nothing. Pick plugins for your case ' + 'on https://www.postcss.parts/ and use them in postcss.config.js.');
+        }
+      }
+    }
     return new _lazyResult2.default(this, css, opts);
-  };
+  });
 
   Processor.prototype.normalize = function normalize(plugins) {
     var normalized = [];
@@ -140,7 +160,9 @@ var Processor = function () {
       } else if (typeof i === 'function') {
         normalized.push(i);
       } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object' && (i.parse || i.stringify)) {
-        throw new Error('PostCSS syntaxes cannot be used as plugins. ' + 'Instead, please use one of the ' + 'syntax/parser/stringifier options as ' + 'outlined in your PostCSS ' + 'runner documentation.');
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error('PostCSS syntaxes cannot be used as plugins. Instead, please use ' + 'one of the syntax/parser/stringifier options as outlined ' + 'in your PostCSS runner documentation.');
+        }
       } else {
         throw new Error(i + ' is not a PostCSS plugin');
       }
@@ -155,17 +177,17 @@ exports.default = Processor;
 
 /**
  * @callback builder
- * @param {string} part          - part of generated CSS connected to this node
- * @param {Node}   node          - AST node
- * @param {"start"|"end"} [type] - node’s part type
+ * @param {string} part          Part of generated CSS connected to this node.
+ * @param {Node}   node          AST node.
+ * @param {"start"|"end"} [type] Node’s part type.
  */
 
 /**
  * @callback parser
  *
- * @param {string|toString} css   - string with input CSS or any object
- *                                  with toString() method, like a Buffer
- * @param {processOptions} [opts] - options with only `from` and `map` keys
+ * @param {string|toString} css   String with input CSS or any object
+ *                                with toString() method, like a Buffer.
+ * @param {processOptions} [opts] Options with only `from` and `map` keys.
  *
  * @return {Root} PostCSS AST
  */
@@ -173,17 +195,17 @@ exports.default = Processor;
 /**
  * @callback stringifier
  *
- * @param {Node} node       - start node for stringifing. Usually {@link Root}.
- * @param {builder} builder - function to concatenate CSS from node’s parts
- *                            or generate string and source map
+ * @param {Node} node       Start node for stringifing. Usually {@link Root}.
+ * @param {builder} builder Function to concatenate CSS from node’s parts
+ *                          or generate string and source map.
  *
  * @return {void}
  */
 
 /**
  * @typedef {object} syntax
- * @property {parser} parse          - function to generate AST by string
- * @property {stringifier} stringify - function to generate string by AST
+ * @property {parser} parse          Function to generate AST by string.
+ * @property {stringifier} stringify Function to generate string by AST.
  */
 
 /**
@@ -193,48 +215,47 @@ exports.default = Processor;
 
 /**
  * @callback pluginFunction
- * @param {Root} root     - parsed input CSS
- * @param {Result} result - result to set warnings or check other plugins
+ * @param {Root} root     Parsed input CSS.
+ * @param {Result} result Result to set warnings or check other plugins.
  */
 
 /**
  * @typedef {object} Plugin
- * @property {function} postcss - PostCSS plugin function
+ * @property {function} postcss PostCSS plugin function.
  */
 
 /**
  * @typedef {object} processOptions
- * @property {string} from             - the path of the CSS source file.
- *                                       You should always set `from`,
- *                                       because it is used in source map
- *                                       generation and syntax error messages.
- * @property {string} to               - the path where you’ll put the output
- *                                       CSS file. You should always set `to`
- *                                       to generate correct source maps.
- * @property {parser} parser           - function to generate AST by string
- * @property {stringifier} stringifier - class to generate string by AST
- * @property {syntax} syntax           - object with `parse` and `stringify`
- * @property {object} map              - source map options
- * @property {boolean} map.inline                    - does source map should
- *                                                     be embedded in the output
- *                                                     CSS as a base64-encoded
- *                                                     comment
- * @property {string|object|false|function} map.prev - source map content
- *                                                     from a previous
- *                                                     processing step
- *                                                     (for example, Sass).
- *                                                     PostCSS will try to find
- *                                                     previous map
- *                                                     automatically, so you
- *                                                     could disable it by
- *                                                     `false` value.
- * @property {boolean} map.sourcesContent            - does PostCSS should set
- *                                                     the origin content to map
- * @property {string|false} map.annotation           - does PostCSS should set
- *                                                     annotation comment to map
- * @property {string} map.from                       - override `from` in map’s
- *                                                     `sources`
+ * @property {string} from             The path of the CSS source file.
+ *                                     You should always set `from`,
+ *                                     because it is used in source map
+ *                                     generation and syntax error messages.
+ * @property {string} to               The path where you’ll put the output
+ *                                     CSS file. You should always set `to`
+ *                                     to generate correct source maps.
+ * @property {parser} parser           Function to generate AST by string.
+ * @property {stringifier} stringifier Class to generate string by AST.
+ * @property {syntax} syntax           Object with `parse` and `stringify`.
+ * @property {object} map              Source map options.
+ * @property {boolean} map.inline                    Does source map should
+ *                                                   be embedded in the output
+ *                                                   CSS as a base64-encoded
+ *                                                   comment.
+ * @property {string|object|false|function} map.prev Source map content
+ *                                                   from a previous
+ *                                                   processing step
+ *                                                   (for example, Sass).
+ *                                                   PostCSS will try to find
+ *                                                   previous map automatically,
+ *                                                   so you could disable it by
+ *                                                   `false` value.
+ * @property {boolean} map.sourcesContent            Does PostCSS should set
+ *                                                   the origin content to map.
+ * @property {string|false} map.annotation           Does PostCSS should set
+ *                                                   annotation comment to map.
+ * @property {string} map.from                       Override `from` in map’s
+ *                                                   sources`.
  */
 
 module.exports = exports['default'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["processor.es6"],"names":["Processor","plugins","version","normalize","use","plugin","concat","process","css","opts","LazyResult","normalized","i","postcss","Array","isArray","push","parse","stringify","Error"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;IASMA,S;;AAEF;;;;AAIA,uBAA0B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AACtB;;;;;;;;AAQA,SAAKC,OAAL,GAAe,QAAf;AACA;;;;;;;AAOA,SAAKD,OAAL,GAAe,KAAKE,SAAL,CAAeF,OAAf,CAAf;AACH;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6BAG,G,gBAAIC,M,EAAQ;AACR,SAAKJ,OAAL,GAAe,KAAKA,OAAL,CAAaK,MAAb,CAAoB,KAAKH,SAAL,CAAe,CAACE,MAAD,CAAf,CAApB,CAAf;AACA,WAAO,IAAP;AACH,G;;AAED;;;;;;;;;;;;;;;;;;;;;;;;sBAsBAE,O,oBAAQC,G,EAAiB;AAAA,QAAZC,IAAY,uEAAL,EAAK;;AACrB,WAAO,IAAIC,oBAAJ,CAAe,IAAf,EAAqBF,GAArB,EAA0BC,IAA1B,CAAP;AACH,G;;sBAEDN,S,sBAAUF,O,EAAS;AACf,QAAIU,aAAa,EAAjB;AACA,yBAAeV,OAAf,kHAAyB;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,UAAfW,CAAe;;AACrB,UAAKA,EAAEC,OAAP,EAAiBD,IAAIA,EAAEC,OAAN;;AAEjB,UAAK,QAAOD,CAAP,yCAAOA,CAAP,OAAa,QAAb,IAAyBE,MAAMC,OAAN,CAAcH,EAAEX,OAAhB,CAA9B,EAAyD;AACrDU,qBAAaA,WAAWL,MAAX,CAAkBM,EAAEX,OAApB,CAAb;AACH,OAFD,MAEO,IAAK,OAAOW,CAAP,KAAa,UAAlB,EAA+B;AAClCD,mBAAWK,IAAX,CAAgBJ,CAAhB;AACH,OAFM,MAEA,IAAK,QAAOA,CAAP,yCAAOA,CAAP,OAAa,QAAb,KAA0BA,EAAEK,KAAF,IAAWL,EAAEM,SAAvC,CAAL,EAAyD;AAC5D,cAAM,IAAIC,KAAJ,CAAU,iDACA,iCADA,GAEA,uCAFA,GAGA,2BAHA,GAIA,uBAJV,CAAN;AAKH,OANM,MAMA;AACH,cAAM,IAAIA,KAAJ,CAAUP,IAAI,0BAAd,CAAN;AACH;AACJ;AACD,WAAOD,UAAP;AACH,G;;;;;kBAIUX,S;;AAEf;;;;;;;AAOA;;;;;;;;;;AAUA;;;;;;;;;;AAUA;;;;;;AAMA;;;;;AAKA;;;;;;AAMA;;;;;AAKA","file":"processor.js","sourcesContent":["import LazyResult from './lazy-result';\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss]);\n * processor.process(css1).then(result => console.log(result.css));\n * processor.process(css2).then(result => console.log(result.css));\n */\nclass Processor {\n\n    /**\n     * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS\n     *        plugins. See {@link Processor#use} for plugin format.\n     */\n    constructor(plugins = []) {\n        /**\n         * @member {string} - Current PostCSS version.\n         *\n         * @example\n         * if ( result.processor.version.split('.')[0] !== '6' ) {\n         *   throw new Error('This plugin works only with PostCSS 6');\n         * }\n         */\n        this.version = '6.0.22';\n        /**\n         * @member {pluginFunction[]} - Plugins added to this processor.\n         *\n         * @example\n         * const processor = postcss([autoprefixer, precss]);\n         * processor.plugins.length //=> 2\n         */\n        this.plugins = this.normalize(plugins);\n    }\n\n    /**\n     * Adds a plugin to be used as a CSS processor.\n     *\n     * PostCSS plugin can be in 4 formats:\n     * * A plugin created by {@link postcss.plugin} method.\n     * * A function. PostCSS will pass the function a @{link Root}\n     *   as the first argument and current {@link Result} instance\n     *   as the second.\n     * * An object with a `postcss` method. PostCSS will use that method\n     *   as described in #2.\n     * * Another {@link Processor} instance. PostCSS will copy plugins\n     *   from that instance into this one.\n     *\n     * Plugins can also be added by passing them as arguments when creating\n     * a `postcss` instance (see [`postcss(plugins)`]).\n     *\n     * Asynchronous plugins should return a `Promise` instance.\n     *\n     * @param {Plugin|pluginFunction|Processor} plugin - PostCSS plugin\n     *                                                   or {@link Processor}\n     *                                                   with plugins\n     *\n     * @example\n     * const processor = postcss()\n     *   .use(autoprefixer)\n     *   .use(precss);\n     *\n     * @return {Processes} current processor to make methods chain\n     */\n    use(plugin) {\n        this.plugins = this.plugins.concat(this.normalize([plugin]));\n        return this;\n    }\n\n    /**\n     * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n     * Because some plugins can be asynchronous it doesn’t make\n     * any transformations. Transformations will be applied\n     * in the {@link LazyResult} methods.\n     *\n     * @param {string|toString|Result} css - String with input CSS or\n     *                                       any object with a `toString()`\n     *                                       method, like a Buffer.\n     *                                       Optionally, send a {@link Result}\n     *                                       instance and the processor will\n     *                                       take the {@link Root} from it.\n     * @param {processOptions} [opts]      - options\n     *\n     * @return {LazyResult} Promise proxy\n     *\n     * @example\n     * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n     *   .then(result => {\n     *      console.log(result.css);\n     *   });\n     */\n    process(css, opts = { }) {\n        return new LazyResult(this, css, opts);\n    }\n\n    normalize(plugins) {\n        let normalized = [];\n        for ( let i of plugins ) {\n            if ( i.postcss ) i = i.postcss;\n\n            if ( typeof i === 'object' && Array.isArray(i.plugins) ) {\n                normalized = normalized.concat(i.plugins);\n            } else if ( typeof i === 'function' ) {\n                normalized.push(i);\n            } else if ( typeof i === 'object' && (i.parse || i.stringify) ) {\n                throw new Error('PostCSS syntaxes cannot be used as plugins. ' +\n                                'Instead, please use one of the ' +\n                                'syntax/parser/stringifier options as ' +\n                                'outlined in your PostCSS ' +\n                                'runner documentation.');\n            } else {\n                throw new Error(i + ' is not a PostCSS plugin');\n            }\n        }\n        return normalized;\n    }\n\n}\n\nexport default Processor;\n\n/**\n * @callback builder\n * @param {string} part          - part of generated CSS connected to this node\n * @param {Node}   node          - AST node\n * @param {\"start\"|\"end\"} [type] - node’s part type\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   - string with input CSS or any object\n *                                  with toString() method, like a Buffer\n * @param {processOptions} [opts] - options with only `from` and `map` keys\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       - start node for stringifing. Usually {@link Root}.\n * @param {builder} builder - function to concatenate CSS from node’s parts\n *                            or generate string and source map\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          - function to generate AST by string\n * @property {stringifier} stringify - function to generate string by AST\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     - parsed input CSS\n * @param {Result} result - result to set warnings or check other plugins\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss - PostCSS plugin function\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             - the path of the CSS source file.\n *                                       You should always set `from`,\n *                                       because it is used in source map\n *                                       generation and syntax error messages.\n * @property {string} to               - the path where you’ll put the output\n *                                       CSS file. You should always set `to`\n *                                       to generate correct source maps.\n * @property {parser} parser           - function to generate AST by string\n * @property {stringifier} stringifier - class to generate string by AST\n * @property {syntax} syntax           - object with `parse` and `stringify`\n * @property {object} map              - source map options\n * @property {boolean} map.inline                    - does source map should\n *                                                     be embedded in the output\n *                                                     CSS as a base64-encoded\n *                                                     comment\n * @property {string|object|false|function} map.prev - source map content\n *                                                     from a previous\n *                                                     processing step\n *                                                     (for example, Sass).\n *                                                     PostCSS will try to find\n *                                                     previous map\n *                                                     automatically, so you\n *                                                     could disable it by\n *                                                     `false` value.\n * @property {boolean} map.sourcesContent            - does PostCSS should set\n *                                                     the origin content to map\n * @property {string|false} map.annotation           - does PostCSS should set\n *                                                     annotation comment to map\n * @property {string} map.from                       - override `from` in map’s\n *                                                     `sources`\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["processor.es6"],"names":["Processor","plugins","version","normalize","use","plugin","concat","process","css","opts","length","parser","stringifier","env","NODE_ENV","console","warn","LazyResult","normalized","i","postcss","Array","isArray","push","parse","stringify","Error"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;IASMA,S;AACJ;;;;AAIA,uBAA2B;AAAA,QAAdC,OAAc,uEAAJ,EAAI;;AAAA;;AACzB;;;;;;;;;;AAUA,SAAKC,OAAL,GAAe,OAAf;AACA;;;;;;;;;AASA,SAAKD,OAAL,GAAe,KAAKE,SAAL,CAAeF,OAAf,CAAf;AACD;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6BAG,G,gBAAKC,M,EAAQ;AACX,SAAKJ,OAAL,GAAe,KAAKA,OAAL,CAAaK,MAAb,CAAoB,KAAKH,SAAL,CAAe,CAACE,MAAD,CAAf,CAApB,CAAf;AACA,WAAO,IAAP;AACD,G;;AAED;;;;;;;;;;;;;;;;;;;;;;;;sBAsBAE,O;;;;;;;;;;cAASC,G,EAAiB;AAAA,QAAZC,IAAY,uEAAL,EAAK;;AACxB,QAAI,KAAKR,OAAL,CAAaS,MAAb,KAAwB,CAAxB,IAA6BD,KAAKE,MAAL,KAAgBF,KAAKG,WAAtD,EAAmE;AACjE,UAAIL,QAAQM,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,YAAI,OAAOC,OAAP,KAAmB,WAAnB,IAAkCA,QAAQC,IAA9C,EAAoD;AAClDD,kBAAQC,IAAR,CACE,0DACA,2DADA,GAEA,kEAHF;AAKD;AACF;AACF;AACD,WAAO,IAAIC,oBAAJ,CAAe,IAAf,EAAqBT,GAArB,EAA0BC,IAA1B,CAAP;AACD,G;;sBAEDN,S,sBAAWF,O,EAAS;AAClB,QAAIiB,aAAa,EAAjB;AACA,yBAAcjB,OAAd,kHAAuB;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,UAAdkB,CAAc;;AACrB,UAAIA,EAAEC,OAAN,EAAeD,IAAIA,EAAEC,OAAN;;AAEf,UAAI,QAAOD,CAAP,yCAAOA,CAAP,OAAa,QAAb,IAAyBE,MAAMC,OAAN,CAAcH,EAAElB,OAAhB,CAA7B,EAAuD;AACrDiB,qBAAaA,WAAWZ,MAAX,CAAkBa,EAAElB,OAApB,CAAb;AACD,OAFD,MAEO,IAAI,OAAOkB,CAAP,KAAa,UAAjB,EAA6B;AAClCD,mBAAWK,IAAX,CAAgBJ,CAAhB;AACD,OAFM,MAEA,IAAI,QAAOA,CAAP,yCAAOA,CAAP,OAAa,QAAb,KAA0BA,EAAEK,KAAF,IAAWL,EAAEM,SAAvC,CAAJ,EAAuD;AAC5D,YAAIlB,QAAQM,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC,gBAAM,IAAIY,KAAJ,CACJ,qEACA,2DADA,GAEA,uCAHI,CAAN;AAKD;AACF,OARM,MAQA;AACL,cAAM,IAAIA,KAAJ,CAAUP,IAAI,0BAAd,CAAN;AACD;AACF;AACD,WAAOD,UAAP;AACD,G;;;;;kBAGYlB,S;;AAEf;;;;;;;AAOA;;;;;;;;;;AAUA;;;;;;;;;;AAUA;;;;;;AAMA;;;;;AAKA;;;;;;AAMA;;;;;AAKA","file":"processor.js","sourcesContent":["import LazyResult from './lazy-result'\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss])\n * processor.process(css1).then(result => console.log(result.css))\n * processor.process(css2).then(result => console.log(result.css))\n */\nclass Processor {\n  /**\n   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n   *        See {@link Processor#use} for plugin format.\n   */\n  constructor (plugins = []) {\n    /**\n     * Current PostCSS version.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (result.processor.version.split('.')[0] !== '6') {\n     *   throw new Error('This plugin works only with PostCSS 6')\n     * }\n     */\n    this.version = '7.0.2'\n    /**\n     * Plugins added to this processor.\n     *\n     * @type {pluginFunction[]}\n     *\n     * @example\n     * const processor = postcss([autoprefixer, precss])\n     * processor.plugins.length //=> 2\n     */\n    this.plugins = this.normalize(plugins)\n  }\n\n  /**\n   * Adds a plugin to be used as a CSS processor.\n   *\n   * PostCSS plugin can be in 4 formats:\n   * * A plugin created by {@link postcss.plugin} method.\n   * * A function. PostCSS will pass the function a @{link Root}\n   *   as the first argument and current {@link Result} instance\n   *   as the second.\n   * * An object with a `postcss` method. PostCSS will use that method\n   *   as described in #2.\n   * * Another {@link Processor} instance. PostCSS will copy plugins\n   *   from that instance into this one.\n   *\n   * Plugins can also be added by passing them as arguments when creating\n   * a `postcss` instance (see [`postcss(plugins)`]).\n   *\n   * Asynchronous plugins should return a `Promise` instance.\n   *\n   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin\n   *                                                 or {@link Processor}\n   *                                                 with plugins.\n   *\n   * @example\n   * const processor = postcss()\n   *   .use(autoprefixer)\n   *   .use(precss)\n   *\n   * @return {Processes} Current processor to make methods chain.\n   */\n  use (plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n\n  /**\n   * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n   * Because some plugins can be asynchronous it doesn’t make\n   * any transformations. Transformations will be applied\n   * in the {@link LazyResult} methods.\n   *\n   * @param {string|toString|Result} css String with input CSS or any object\n   *                                     with a `toString()` method,\n   *                                     like a Buffer. Optionally, send\n   *                                     a {@link Result} instance\n   *                                     and the processor will take\n   *                                     the {@link Root} from it.\n   * @param {processOptions} [opts]      Options.\n   *\n   * @return {LazyResult} Promise proxy.\n   *\n   * @example\n   * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n   *   .then(result => {\n   *      console.log(result.css)\n   *   })\n   */\n  process (css, opts = { }) {\n    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof console !== 'undefined' && console.warn) {\n          console.warn(\n            'You did not set any plugins, parser, or stringifier. ' +\n            'Right now PostCSS do nothing. Pick plugins for your case ' +\n            'on https://www.postcss.parts/ and use them in postcss.config.js.'\n          )\n        }\n      }\n    }\n    return new LazyResult(this, css, opts)\n  }\n\n  normalize (plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss) i = i.postcss\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'function') {\n        normalized.push(i)\n      } else if (typeof i === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +\n            'one of the syntax/parser/stringifier options as outlined ' +\n            'in your PostCSS runner documentation.'\n          )\n        }\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin')\n      }\n    }\n    return normalized\n  }\n}\n\nexport default Processor\n\n/**\n * @callback builder\n * @param {string} part          Part of generated CSS connected to this node.\n * @param {Node}   node          AST node.\n * @param {\"start\"|\"end\"} [type] Node’s part type.\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer.\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          Function to generate AST by string.\n * @property {stringifier} stringify Function to generate string by AST.\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     Parsed input CSS.\n * @param {Result} result Result to set warnings or check other plugins.\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss PostCSS plugin function.\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             The path of the CSS source file.\n *                                     You should always set `from`,\n *                                     because it is used in source map\n *                                     generation and syntax error messages.\n * @property {string} to               The path where you’ll put the output\n *                                     CSS file. You should always set `to`\n *                                     to generate correct source maps.\n * @property {parser} parser           Function to generate AST by string.\n * @property {stringifier} stringifier Class to generate string by AST.\n * @property {syntax} syntax           Object with `parse` and `stringify`.\n * @property {object} map              Source map options.\n * @property {boolean} map.inline                    Does source map should\n *                                                   be embedded in the output\n *                                                   CSS as a base64-encoded\n *                                                   comment.\n * @property {string|object|false|function} map.prev Source map content\n *                                                   from a previous\n *                                                   processing step\n *                                                   (for example, Sass).\n *                                                   PostCSS will try to find\n *                                                   previous map automatically,\n *                                                   so you could disable it by\n *                                                   `false` value.\n * @property {boolean} map.sourcesContent            Does PostCSS should set\n *                                                   the origin content to map.\n * @property {string|false} map.annotation           Does PostCSS should set\n *                                                   annotation comment to map.\n * @property {string} map.from                       Override `from` in map’s\n *                                                   sources`.\n */\n"]}

package/lib/result.js

@@ -19,90 +19,95 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
  * or {@link Root#toResult} methods.
  *
  * @example
- * postcss([cssnext]).process(css).then(function (result) {
- *    console.log(result.css);
- * });
+ * postcss([cssnext]).process(css).then(result => {
+ *  console.log(result.css)
+ * })
  *
  * @example
- * var result2 = postcss.parse(css).toResult();
+ * const result2 = postcss.parse(css).toResult()
  */
 var Result = function () {
-
   /**
-   * @param {Processor} processor - processor used for this transformation.
-   * @param {Root}      root      - Root node after all transformations.
-   * @param {processOptions} opts - options from the {@link Processor#process}
-   *                                or {@link Root#toResult}
+   * @param {Processor} processor Processor used for this transformation.
+   * @param {Root}      root      Root node after all transformations.
+   * @param {processOptions} opts Options from the {@link Processor#process}
+   *                              or {@link Root#toResult}.
    */
   function Result(processor, root, opts) {
     _classCallCheck(this, Result);
 
     /**
-     * @member {Processor} - The Processor instance used
-     *                       for this transformation.
+     * The Processor instance used for this transformation.
+     *
+     * @type {Processor}
      *
      * @example
-     * for ( let plugin of result.processor.plugins) {
-     *   if ( plugin.postcssPlugin === 'postcss-bad' ) {
-     *     throw 'postcss-good is incompatible with postcss-bad';
+     * for (const plugin of result.processor.plugins) {
+     *   if (plugin.postcssPlugin === 'postcss-bad') {
+     *     throw 'postcss-good is incompatible with postcss-bad'
      *   }
-     * });
+     * })
      */
     this.processor = processor;
     /**
-     * @member {Message[]} - Contains messages from plugins
-     *                       (e.g., warnings or custom messages).
-     *                       Each message should have type
-     *                       and plugin properties.
+     * Contains messages from plugins (e.g., warnings or custom messages).
+     * Each message should have type and plugin properties.
+     *
+     * @type {Message[]}
      *
      * @example
      * postcss.plugin('postcss-min-browser', () => {
      *   return (root, result) => {
-     *     var browsers = detectMinBrowsersByCanIUse(root);
+     *     const browsers = detectMinBrowsersByCanIUse(root)
      *     result.messages.push({
-     *       type:    'min-browser',
-     *       plugin:  'postcss-min-browser',
-     *       browsers: browsers
-     *     });
-     *   };
-     * });
+     *       type: 'min-browser',
+     *       plugin: 'postcss-min-browser',
+     *       browsers
+     *     })
+     *   }
+     * })
      */
     this.messages = [];
     /**
-     * @member {Root} - Root node after all transformations.
+     * Root node after all transformations.
+     *
+     * @type {Root}
      *
      * @example
-     * root.toResult().root == root;
+     * root.toResult().root === root
      */
     this.root = root;
     /**
-     * @member {processOptions} - Options from the {@link Processor#process}
-     *                            or {@link Root#toResult} call
-     *                            that produced this Result instance.
+     * Options from the {@link Processor#process} or {@link Root#toResult} call
+     * that produced this Result instance.
+     *
+     * @type {processOptions}
      *
      * @example
-     * root.toResult(opts).opts == opts;
+     * root.toResult(opts).opts === opts
      */
     this.opts = opts;
     /**
-     * @member {string} - A CSS string representing of {@link Result#root}.
+     * A CSS string representing of {@link Result#root}.
+     *
+     * @type {string}
      *
      * @example
      * postcss.parse('a{}').toResult().css //=> "a{}"
      */
     this.css = undefined;
     /**
-     * @member {SourceMapGenerator} - An instance of `SourceMapGenerator`
-     *                                class from the `source-map` library,
-     *                                representing changes
-     *                                to the {@link Result#root} instance.
+     * An instance of `SourceMapGenerator` class from the `source-map` library,
+     * representing changes to the {@link Result#root} instance.
+     *
+     * @type {SourceMapGenerator}
      *
      * @example
      * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
      *
      * @example
-     * if ( result.map ) {
-     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString());
+     * if (result.map) {
+     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
      * }
      */
     this.map = undefined;
@@ -114,7 +119,7 @@ var Result = function () {
    * @example
    * result + '' === result.css
    *
-   * @return {string} string representing of {@link Result#root}
+   * @return {string} String representing of {@link Result#root}.
    */
 
 
@@ -126,17 +131,17 @@ var Result = function () {
    * Creates an instance of {@link Warning} and adds it
    * to {@link Result#messages}.
    *
-   * @param {string} text        - warning message
-   * @param {Object} [opts]      - warning options
-   * @param {Node}   opts.node   - CSS node that caused the warning
-   * @param {string} opts.word   - word in CSS source that caused the warning
-   * @param {number} opts.index  - index in CSS node string that caused
-   *                               the warning
-   * @param {string} opts.plugin - name of the plugin that created
-   *                               this warning. {@link Result#warn} fills
-   *                               this property automatically.
+   * @param {string} text        Warning message.
+   * @param {Object} [opts]      Warning options.
+   * @param {Node}   opts.node   CSS node that caused the warning.
+   * @param {string} opts.word   Word in CSS source that caused the warning.
+   * @param {number} opts.index  Index in CSS node string that caused
+   *                             the warning.
+   * @param {string} opts.plugin Name of the plugin that created
+   *                             this warning. {@link Result#warn} fills
+   *                             this property automatically.
    *
-   * @return {Warning} created warning
+   * @return {Warning} Created warning.
    */
 
 
@@ -156,16 +161,16 @@ var Result = function () {
   };
 
   /**
-   * Returns warnings from plugins. Filters {@link Warning} instances
-   * from {@link Result#messages}.
-   *
-   * @example
-   * result.warnings().forEach(warn => {
-   *   console.warn(warn.toString());
-   * });
-   *
-   * @return {Warning[]} warnings from plugins
-   */
+     * Returns warnings from plugins. Filters {@link Warning} instances
+     * from {@link Result#messages}.
+     *
+     * @example
+     * result.warnings().forEach(warn => {
+     *   console.warn(warn.toString())
+     * })
+     *
+     * @return {Warning[]} Warnings from plugins.
+     */
 
 
   Result.prototype.warnings = function warnings() {
@@ -177,10 +182,11 @@ var Result = function () {
   /**
    * An alias for the {@link Result#css} property.
    * Use it with syntaxes that generate non-CSS output.
+   *
    * @type {string}
    *
    * @example
-   * result.css === result.content;
+   * result.css === result.content
    */
 
 
@@ -198,9 +204,9 @@ exports.default = Result;
 
 /**
  * @typedef  {object} Message
- * @property {string} type   - message type
- * @property {string} plugin - source PostCSS plugin name
+ * @property {string} type   Message type.
+ * @property {string} plugin Source PostCSS plugin name.
  */
 
 module.exports = exports['default'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["result.es6"],"names":["Result","processor","root","opts","messages","css","undefined","map","toString","warn","text","plugin","lastPlugin","postcssPlugin","warning","Warning","push","warnings","filter","i","type"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;;;;;;IAcMA,M;;AAEF;;;;;;AAMA,kBAAYC,SAAZ,EAAuBC,IAAvB,EAA6BC,IAA7B,EAAmC;AAAA;;AAC/B;;;;;;;;;;;AAWA,SAAKF,SAAL,GAAiBA,SAAjB;AACA;;;;;;;;;;;;;;;;;;AAkBA,SAAKG,QAAL,GAAgB,EAAhB;AACA;;;;;;AAMA,SAAKF,IAAL,GAAYA,IAAZ;AACA;;;;;;;;AAQA,SAAKC,IAAL,GAAYA,IAAZ;AACA;;;;;;AAMA,SAAKE,GAAL,GAAWC,SAAX;AACA;;;;;;;;;;;;;;AAcA,SAAKC,GAAL,GAAWD,SAAX;AACH;;AAED;;;;;;;;;;mBAQAE,Q,uBAAW;AACP,WAAO,KAAKH,GAAZ;AACH,G;;AAED;;;;;;;;;;;;;;;;;;mBAgBAI,I,iBAAKC,I,EAAkB;AAAA,QAAZP,IAAY,uEAAL,EAAK;;AACnB,QAAK,CAACA,KAAKQ,MAAX,EAAoB;AAChB,UAAK,KAAKC,UAAL,IAAmB,KAAKA,UAAL,CAAgBC,aAAxC,EAAwD;AACpDV,aAAKQ,MAAL,GAAc,KAAKC,UAAL,CAAgBC,aAA9B;AACH;AACJ;;AAED,QAAIC,UAAU,IAAIC,iBAAJ,CAAYL,IAAZ,EAAkBP,IAAlB,CAAd;AACA,SAAKC,QAAL,CAAcY,IAAd,CAAmBF,OAAnB;;AAEA,WAAOA,OAAP;AACH,G;;AAED;;;;;;;;;;;;;mBAWAG,Q,uBAAW;AACP,WAAO,KAAKb,QAAL,CAAcc,MAAd,CAAsB;AAAA,aAAKC,EAAEC,IAAF,KAAW,SAAhB;AAAA,KAAtB,CAAP;AACH,G;;AAED;;;;;;;;;;;;wBAQc;AACV,aAAO,KAAKf,GAAZ;AACH;;;;;;kBAIUL,M;;AAEf","file":"result.js","sourcesContent":["import Warning from './warning';\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([cssnext]).process(css).then(function (result) {\n *    console.log(result.css);\n * });\n *\n * @example\n * var result2 = postcss.parse(css).toResult();\n */\nclass Result {\n\n    /**\n     * @param {Processor} processor - processor used for this transformation.\n     * @param {Root}      root      - Root node after all transformations.\n     * @param {processOptions} opts - options from the {@link Processor#process}\n     *                                or {@link Root#toResult}\n     */\n    constructor(processor, root, opts) {\n        /**\n         * @member {Processor} - The Processor instance used\n         *                       for this transformation.\n         *\n         * @example\n         * for ( let plugin of result.processor.plugins) {\n         *   if ( plugin.postcssPlugin === 'postcss-bad' ) {\n         *     throw 'postcss-good is incompatible with postcss-bad';\n         *   }\n         * });\n         */\n        this.processor = processor;\n        /**\n         * @member {Message[]} - Contains messages from plugins\n         *                       (e.g., warnings or custom messages).\n         *                       Each message should have type\n         *                       and plugin properties.\n         *\n         * @example\n         * postcss.plugin('postcss-min-browser', () => {\n         *   return (root, result) => {\n         *     var browsers = detectMinBrowsersByCanIUse(root);\n         *     result.messages.push({\n         *       type:    'min-browser',\n         *       plugin:  'postcss-min-browser',\n         *       browsers: browsers\n         *     });\n         *   };\n         * });\n         */\n        this.messages = [];\n        /**\n         * @member {Root} - Root node after all transformations.\n         *\n         * @example\n         * root.toResult().root == root;\n         */\n        this.root = root;\n        /**\n         * @member {processOptions} - Options from the {@link Processor#process}\n         *                            or {@link Root#toResult} call\n         *                            that produced this Result instance.\n         *\n         * @example\n         * root.toResult(opts).opts == opts;\n         */\n        this.opts = opts;\n        /**\n         * @member {string} - A CSS string representing of {@link Result#root}.\n         *\n         * @example\n         * postcss.parse('a{}').toResult().css //=> \"a{}\"\n         */\n        this.css = undefined;\n        /**\n         * @member {SourceMapGenerator} - An instance of `SourceMapGenerator`\n         *                                class from the `source-map` library,\n         *                                representing changes\n         *                                to the {@link Result#root} instance.\n         *\n         * @example\n         * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n         *\n         * @example\n         * if ( result.map ) {\n         *   fs.writeFileSync(result.opts.to + '.map', result.map.toString());\n         * }\n         */\n        this.map = undefined;\n    }\n\n    /**\n     * Returns for @{link Result#css} content.\n     *\n     * @example\n     * result + '' === result.css\n     *\n     * @return {string} string representing of {@link Result#root}\n     */\n    toString() {\n        return this.css;\n    }\n\n    /**\n     * Creates an instance of {@link Warning} and adds it\n     * to {@link Result#messages}.\n     *\n     * @param {string} text        - warning message\n     * @param {Object} [opts]      - warning options\n     * @param {Node}   opts.node   - CSS node that caused the warning\n     * @param {string} opts.word   - word in CSS source that caused the warning\n     * @param {number} opts.index  - index in CSS node string that caused\n     *                               the warning\n     * @param {string} opts.plugin - name of the plugin that created\n     *                               this warning. {@link Result#warn} fills\n     *                               this property automatically.\n     *\n     * @return {Warning} created warning\n     */\n    warn(text, opts = { }) {\n        if ( !opts.plugin ) {\n            if ( this.lastPlugin && this.lastPlugin.postcssPlugin ) {\n                opts.plugin = this.lastPlugin.postcssPlugin;\n            }\n        }\n\n        let warning = new Warning(text, opts);\n        this.messages.push(warning);\n\n        return warning;\n    }\n\n    /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString());\n     * });\n     *\n     * @return {Warning[]} warnings from plugins\n     */\n    warnings() {\n        return this.messages.filter( i => i.type === 'warning' );\n    }\n\n    /**\n     * An alias for the {@link Result#css} property.\n     * Use it with syntaxes that generate non-CSS output.\n     * @type {string}\n     *\n     * @example\n     * result.css === result.content;\n     */\n    get content() {\n        return this.css;\n    }\n\n}\n\nexport default Result;\n\n/**\n * @typedef  {object} Message\n * @property {string} type   - message type\n * @property {string} plugin - source PostCSS plugin name\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["result.es6"],"names":["Result","processor","root","opts","messages","css","undefined","map","toString","warn","text","plugin","lastPlugin","postcssPlugin","warning","Warning","push","warnings","filter","i","type"],"mappings":";;;;;;AAAA;;;;;;;;AAEA;;;;;;;;;;;;;;IAcMA,M;AACJ;;;;;;AAMA,kBAAaC,SAAb,EAAwBC,IAAxB,EAA8BC,IAA9B,EAAoC;AAAA;;AAClC;;;;;;;;;;;;AAYA,SAAKF,SAAL,GAAiBA,SAAjB;AACA;;;;;;;;;;;;;;;;;;AAkBA,SAAKG,QAAL,GAAgB,EAAhB;AACA;;;;;;;;AAQA,SAAKF,IAAL,GAAYA,IAAZ;AACA;;;;;;;;;AASA,SAAKC,IAAL,GAAYA,IAAZ;AACA;;;;;;;;AAQA,SAAKE,GAAL,GAAWC,SAAX;AACA;;;;;;;;;;;;;;AAcA,SAAKC,GAAL,GAAWD,SAAX;AACD;;AAED;;;;;;;;;;mBAQAE,Q,uBAAY;AACV,WAAO,KAAKH,GAAZ;AACD,G;;AAED;;;;;;;;;;;;;;;;;;mBAgBAI,I,iBAAMC,I,EAAkB;AAAA,QAAZP,IAAY,uEAAL,EAAK;;AACtB,QAAI,CAACA,KAAKQ,MAAV,EAAkB;AAChB,UAAI,KAAKC,UAAL,IAAmB,KAAKA,UAAL,CAAgBC,aAAvC,EAAsD;AACpDV,aAAKQ,MAAL,GAAc,KAAKC,UAAL,CAAgBC,aAA9B;AACD;AACF;;AAED,QAAIC,UAAU,IAAIC,iBAAJ,CAAYL,IAAZ,EAAkBP,IAAlB,CAAd;AACA,SAAKC,QAAL,CAAcY,IAAd,CAAmBF,OAAnB;;AAEA,WAAOA,OAAP;AACD,G;;AAED;;;;;;;;;;;;;mBAWAG,Q,uBAAY;AACV,WAAO,KAAKb,QAAL,CAAcc,MAAd,CAAqB;AAAA,aAAKC,EAAEC,IAAF,KAAW,SAAhB;AAAA,KAArB,CAAP;AACD,G;;AAED;;;;;;;;;;;;;wBASe;AACb,aAAO,KAAKf,GAAZ;AACD;;;;;;kBAGYL,M;;AAEf","file":"result.js","sourcesContent":["import Warning from './warning'\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([cssnext]).process(css).then(result => {\n *  console.log(result.css)\n * })\n *\n * @example\n * const result2 = postcss.parse(css).toResult()\n */\nclass Result {\n  /**\n   * @param {Processor} processor Processor used for this transformation.\n   * @param {Root}      root      Root node after all transformations.\n   * @param {processOptions} opts Options from the {@link Processor#process}\n   *                              or {@link Root#toResult}.\n   */\n  constructor (processor, root, opts) {\n    /**\n     * The Processor instance used for this transformation.\n     *\n     * @type {Processor}\n     *\n     * @example\n     * for (const plugin of result.processor.plugins) {\n     *   if (plugin.postcssPlugin === 'postcss-bad') {\n     *     throw 'postcss-good is incompatible with postcss-bad'\n     *   }\n     * })\n     */\n    this.processor = processor\n    /**\n     * Contains messages from plugins (e.g., warnings or custom messages).\n     * Each message should have type and plugin properties.\n     *\n     * @type {Message[]}\n     *\n     * @example\n     * postcss.plugin('postcss-min-browser', () => {\n     *   return (root, result) => {\n     *     const browsers = detectMinBrowsersByCanIUse(root)\n     *     result.messages.push({\n     *       type: 'min-browser',\n     *       plugin: 'postcss-min-browser',\n     *       browsers\n     *     })\n     *   }\n     * })\n     */\n    this.messages = []\n    /**\n     * Root node after all transformations.\n     *\n     * @type {Root}\n     *\n     * @example\n     * root.toResult().root === root\n     */\n    this.root = root\n    /**\n     * Options from the {@link Processor#process} or {@link Root#toResult} call\n     * that produced this Result instance.\n     *\n     * @type {processOptions}\n     *\n     * @example\n     * root.toResult(opts).opts === opts\n     */\n    this.opts = opts\n    /**\n     * A CSS string representing of {@link Result#root}.\n     *\n     * @type {string}\n     *\n     * @example\n     * postcss.parse('a{}').toResult().css //=> \"a{}\"\n     */\n    this.css = undefined\n    /**\n     * An instance of `SourceMapGenerator` class from the `source-map` library,\n     * representing changes to the {@link Result#root} instance.\n     *\n     * @type {SourceMapGenerator}\n     *\n     * @example\n     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n     *\n     * @example\n     * if (result.map) {\n     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())\n     * }\n     */\n    this.map = undefined\n  }\n\n  /**\n   * Returns for @{link Result#css} content.\n   *\n   * @example\n   * result + '' === result.css\n   *\n   * @return {string} String representing of {@link Result#root}.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Creates an instance of {@link Warning} and adds it\n   * to {@link Result#messages}.\n   *\n   * @param {string} text        Warning message.\n   * @param {Object} [opts]      Warning options.\n   * @param {Node}   opts.node   CSS node that caused the warning.\n   * @param {string} opts.word   Word in CSS source that caused the warning.\n   * @param {number} opts.index  Index in CSS node string that caused\n   *                             the warning.\n   * @param {string} opts.plugin Name of the plugin that created\n   *                             this warning. {@link Result#warn} fills\n   *                             this property automatically.\n   *\n   * @return {Warning} Created warning.\n   */\n  warn (text, opts = { }) {\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin\n      }\n    }\n\n    let warning = new Warning(text, opts)\n    this.messages.push(warning)\n\n    return warning\n  }\n\n  /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString())\n     * })\n     *\n     * @return {Warning[]} Warnings from plugins.\n     */\n  warnings () {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  /**\n   * An alias for the {@link Result#css} property.\n   * Use it with syntaxes that generate non-CSS output.\n   *\n   * @type {string}\n   *\n   * @example\n   * result.css === result.content\n   */\n  get content () {\n    return this.css\n  }\n}\n\nexport default Result\n\n/**\n * @typedef  {object} Message\n * @property {string} type   Message type.\n * @property {string} plugin Source PostCSS plugin name.\n */\n"]}