postcss 6.0.22 → 7.0.2

package/lib/lazy-result.js

@@ -31,7 +31,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function isPromise(obj) {
-    return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';
+  return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';
 }
 
 /**
@@ -40,383 +40,410 @@ function isPromise(obj) {
  * A `LazyResult` instance is returned by {@link Processor#process}.
  *
  * @example
- * const lazy = postcss([cssnext]).process(css);
+ * const lazy = postcss([cssnext]).process(css)
  */
 
 var LazyResult = function () {
-    function LazyResult(processor, css, opts) {
-        _classCallCheck(this, LazyResult);
-
-        this.stringified = false;
-        this.processed = false;
-
-        var root = void 0;
-        if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css !== null && css.type === 'root') {
-            root = css;
-        } else if (css instanceof LazyResult || css instanceof _result2.default) {
-            root = css.root;
-            if (css.map) {
-                if (typeof opts.map === 'undefined') opts.map = {};
-                if (!opts.map.inline) opts.map.inline = false;
-                opts.map.prev = css.map;
-            }
-        } else {
-            var parser = _parse2.default;
-            if (opts.syntax) parser = opts.syntax.parse;
-            if (opts.parser) parser = opts.parser;
-            if (parser.parse) parser = parser.parse;
-
-            try {
-                root = parser(css, opts);
-            } catch (error) {
-                this.error = error;
-            }
-        }
-
-        this.result = new _result2.default(processor, root, opts);
+  function LazyResult(processor, css, opts) {
+    _classCallCheck(this, LazyResult);
+
+    this.stringified = false;
+    this.processed = false;
+
+    var root = void 0;
+    if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css !== null && css.type === 'root') {
+      root = css;
+    } else if (css instanceof LazyResult || css instanceof _result2.default) {
+      root = css.root;
+      if (css.map) {
+        if (typeof opts.map === 'undefined') opts.map = {};
+        if (!opts.map.inline) opts.map.inline = false;
+        opts.map.prev = css.map;
+      }
+    } else {
+      var parser = _parse2.default;
+      if (opts.syntax) parser = opts.syntax.parse;
+      if (opts.parser) parser = opts.parser;
+      if (parser.parse) parser = parser.parse;
+
+      try {
+        root = parser(css, opts);
+      } catch (error) {
+        this.error = error;
+      }
     }
 
-    /**
-     * Returns a {@link Processor} instance, which will be used
-     * for CSS transformations.
-     * @type {Processor}
-     */
-
-
-    /**
-     * Processes input CSS through synchronous plugins
-     * and calls {@link Result#warnings()}.
-     *
-     * @return {Warning[]} warnings from plugins
-     */
-    LazyResult.prototype.warnings = function warnings() {
-        return this.sync().warnings();
-    };
-
-    /**
-     * Alias for the {@link LazyResult#css} property.
-     *
-     * @example
-     * lazy + '' === lazy.css;
-     *
-     * @return {string} output CSS
-     */
+    this.result = new _result2.default(processor, root, opts);
+  }
+
+  /**
+   * Returns a {@link Processor} instance, which will be used
+   * for CSS transformations.
+   *
+   * @type {Processor}
+   */
+
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and calls {@link Result#warnings()}.
+   *
+   * @return {Warning[]} Warnings from plugins.
+   */
+  LazyResult.prototype.warnings = function warnings() {
+    return this.sync().warnings();
+  };
+
+  /**
+   * Alias for the {@link LazyResult#css} property.
+   *
+   * @example
+   * lazy + '' === lazy.css
+   *
+   * @return {string} Output CSS.
+   */
+
+
+  LazyResult.prototype.toString = function toString() {
+    return this.css;
+  };
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls `onFulfilled` with a Result instance. If a plugin throws
+   * an error, the `onRejected` callback will be executed.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onFulfilled} onFulfilled Callback will be executed
+   *                                  when all plugins will finish work.
+   * @param {onRejected}  onRejected  Callback will be executed on any error.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([cssnext]).process(css, { from: cssPath }).then(result => {
+   *   console.log(result.css)
+   * })
+   */
+
+
+  LazyResult.prototype.then = function then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this.opts)) {
+        (0, _warnOnce2.default)('Without `from` option PostCSS could generate wrong source map ' + 'and will not find Browserslist config. Set it to CSS file path ' + 'or to `undefined` to prevent this warning.');
+      }
+    }
+    return this.async().then(onFulfilled, onRejected);
+  };
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onRejected for each error thrown in any plugin.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onRejected} onRejected Callback will be executed on any error.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([cssnext]).process(css).then(result => {
+   *   console.log(result.css)
+   * }).catch(error => {
+   *   console.error(error)
+   * })
+   */
+
+
+  LazyResult.prototype.catch = function _catch(onRejected) {
+    return this.async().catch(onRejected);
+  };
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onFinally on any error or when all plugins will finish work.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onFinally} onFinally Callback will be executed on any error or
+   *                              when all plugins will finish work.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([cssnext]).process(css).finally(() => {
+   *   console.log('processing ended')
+   * })
+   */
+
+
+  LazyResult.prototype.finally = function _finally(onFinally) {
+    return this.async().then(onFinally, onFinally);
+  };
+
+  LazyResult.prototype.handleError = function handleError(error, plugin) {
+    try {
+      this.error = error;
+      if (error.name === 'CssSyntaxError' && !error.plugin) {
+        error.plugin = plugin.postcssPlugin;
+        error.setMessage();
+      } else if (plugin.postcssVersion) {
+        if (process.env.NODE_ENV !== 'production') {
+          var pluginName = plugin.postcssPlugin;
+          var pluginVer = plugin.postcssVersion;
+          var runtimeVer = this.result.processor.version;
+          var a = pluginVer.split('.');
+          var b = runtimeVer.split('.');
+
+          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+            console.error('Unknown error from PostCSS plugin. Your current PostCSS ' + 'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' + pluginVer + '. Perhaps this is the source of the error below.');
+          }
+        }
+      }
+    } catch (err) {
+      if (console && console.error) console.error(err);
+    }
+  };
 
+  LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {
+    var _this = this;
 
-    LazyResult.prototype.toString = function toString() {
-        return this.css;
-    };
+    if (this.plugin >= this.processor.plugins.length) {
+      this.processed = true;
+      return resolve();
+    }
 
-    /**
-     * Processes input CSS through synchronous and asynchronous plugins
-     * and calls `onFulfilled` with a Result instance. If a plugin throws
-     * an error, the `onRejected` callback will be executed.
-     *
-     * It implements standard Promise API.
-     *
-     * @param {onFulfilled} onFulfilled - callback will be executed
-     *                                    when all plugins will finish work
-     * @param {onRejected}  onRejected  - callback will be executed on any error
-     *
-     * @return {Promise} Promise API to make queue
-     *
-     * @example
-     * postcss([cssnext]).process(css, { from: cssPath }).then(result => {
-     *   console.log(result.css);
-     * });
-     */
+    try {
+      var plugin = this.processor.plugins[this.plugin];
+      var promise = this.run(plugin);
+      this.plugin += 1;
+
+      if (isPromise(promise)) {
+        promise.then(function () {
+          _this.asyncTick(resolve, reject);
+        }).catch(function (error) {
+          _this.handleError(error, plugin);
+          _this.processed = true;
+          reject(error);
+        });
+      } else {
+        this.asyncTick(resolve, reject);
+      }
+    } catch (error) {
+      this.processed = true;
+      reject(error);
+    }
+  };
 
+  LazyResult.prototype.async = function async() {
+    var _this2 = this;
 
-    LazyResult.prototype.then = function then(onFulfilled, onRejected) {
-        if (!('from' in this.opts)) {
-            (0, _warnOnce2.default)('Without `from` option PostCSS could generate wrong ' + 'source map and will not find Browserslist config. ' + 'Set it to CSS file path or to `undefined` to prevent ' + 'this warning.');
+    if (this.processed) {
+      return new Promise(function (resolve, reject) {
+        if (_this2.error) {
+          reject(_this2.error);
+        } else {
+          resolve(_this2.stringify());
         }
-        return this.async().then(onFulfilled, onRejected);
-    };
-
-    /**
-     * Processes input CSS through synchronous and asynchronous plugins
-     * and calls onRejected for each error thrown in any plugin.
-     *
-     * It implements standard Promise API.
-     *
-     * @param {onRejected} onRejected - callback will be executed on any error
-     *
-     * @return {Promise} Promise API to make queue
-     *
-     * @example
-     * postcss([cssnext]).process(css).then(result => {
-     *   console.log(result.css);
-     * }).catch(error => {
-     *   console.error(error);
-     * });
-     */
+      });
+    }
+    if (this.processing) {
+      return this.processing;
+    }
 
+    this.processing = new Promise(function (resolve, reject) {
+      if (_this2.error) return reject(_this2.error);
+      _this2.plugin = 0;
+      _this2.asyncTick(resolve, reject);
+    }).then(function () {
+      _this2.processed = true;
+      return _this2.stringify();
+    });
 
-    LazyResult.prototype.catch = function _catch(onRejected) {
-        return this.async().catch(onRejected);
-    };
-
-    LazyResult.prototype.handleError = function handleError(error, plugin) {
-        try {
-            this.error = error;
-            if (error.name === 'CssSyntaxError' && !error.plugin) {
-                error.plugin = plugin.postcssPlugin;
-                error.setMessage();
-            } else if (plugin.postcssVersion) {
-                var pluginName = plugin.postcssPlugin;
-                var pluginVer = plugin.postcssVersion;
-                var runtimeVer = this.result.processor.version;
-                var a = pluginVer.split('.');
-                var b = runtimeVer.split('.');
-
-                if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
-                    console.error('Unknown error from PostCSS plugin. ' + 'Your current PostCSS version ' + 'is ' + runtimeVer + ', but ' + pluginName + ' ' + 'uses ' + pluginVer + '. Perhaps this is ' + 'the source of the error below.');
-                }
-            }
-        } catch (err) {
-            if (console && console.error) console.error(err);
-        }
-    };
+    return this.processing;
+  };
 
-    LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {
-        var _this = this;
+  LazyResult.prototype.sync = function sync() {
+    if (this.processed) return this.result;
+    this.processed = true;
 
-        if (this.plugin >= this.processor.plugins.length) {
-            this.processed = true;
-            return resolve();
-        }
+    if (this.processing) {
+      throw new Error('Use process(css).then(cb) to work with async plugins');
+    }
 
-        try {
-            var plugin = this.processor.plugins[this.plugin];
-            var promise = this.run(plugin);
-            this.plugin += 1;
-
-            if (isPromise(promise)) {
-                promise.then(function () {
-                    _this.asyncTick(resolve, reject);
-                }).catch(function (error) {
-                    _this.handleError(error, plugin);
-                    _this.processed = true;
-                    reject(error);
-                });
-            } else {
-                this.asyncTick(resolve, reject);
-            }
-        } catch (error) {
-            this.processed = true;
-            reject(error);
-        }
-    };
-
-    LazyResult.prototype.async = function async() {
-        var _this2 = this;
-
-        if (this.processed) {
-            return new Promise(function (resolve, reject) {
-                if (_this2.error) {
-                    reject(_this2.error);
-                } else {
-                    resolve(_this2.stringify());
-                }
-            });
-        }
-        if (this.processing) {
-            return this.processing;
-        }
+    if (this.error) throw this.error;
 
-        this.processing = new Promise(function (resolve, reject) {
-            if (_this2.error) return reject(_this2.error);
-            _this2.plugin = 0;
-            _this2.asyncTick(resolve, reject);
-        }).then(function () {
-            _this2.processed = true;
-            return _this2.stringify();
-        });
+    for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
 
-        return this.processing;
-    };
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
 
-    LazyResult.prototype.sync = function sync() {
-        if (this.processed) return this.result;
-        this.processed = true;
+      var plugin = _ref;
 
-        if (this.processing) {
-            throw new Error('Use process(css).then(cb) to work with async plugins');
-        }
+      var promise = this.run(plugin);
+      if (isPromise(promise)) {
+        throw new Error('Use process(css).then(cb) to work with async plugins');
+      }
+    }
 
-        if (this.error) throw this.error;
+    return this.result;
+  };
 
-        for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-            var _ref;
+  LazyResult.prototype.run = function run(plugin) {
+    this.result.lastPlugin = plugin;
 
-            if (_isArray) {
-                if (_i >= _iterator.length) break;
-                _ref = _iterator[_i++];
-            } else {
-                _i = _iterator.next();
-                if (_i.done) break;
-                _ref = _i.value;
-            }
+    try {
+      return plugin(this.result.root, this.result);
+    } catch (error) {
+      this.handleError(error, plugin);
+      throw error;
+    }
+  };
 
-            var plugin = _ref;
+  LazyResult.prototype.stringify = function stringify() {
+    if (this.stringified) return this.result;
+    this.stringified = true;
 
-            var promise = this.run(plugin);
-            if (isPromise(promise)) {
-                throw new Error('Use process(css).then(cb) to work with async plugins');
-            }
-        }
+    this.sync();
 
-        return this.result;
-    };
+    var opts = this.result.opts;
+    var str = _stringify3.default;
+    if (opts.syntax) str = opts.syntax.stringify;
+    if (opts.stringifier) str = opts.stringifier;
+    if (str.stringify) str = str.stringify;
 
-    LazyResult.prototype.run = function run(plugin) {
-        this.result.lastPlugin = plugin;
+    var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);
+    var data = map.generate();
+    this.result.css = data[0];
+    this.result.map = data[1];
 
-        try {
-            return plugin(this.result.root, this.result);
-        } catch (error) {
-            this.handleError(error, plugin);
-            throw error;
-        }
-    };
+    return this.result;
+  };
 
-    LazyResult.prototype.stringify = function stringify() {
-        if (this.stringified) return this.result;
-        this.stringified = true;
+  _createClass(LazyResult, [{
+    key: 'processor',
+    get: function get() {
+      return this.result.processor;
+    }
 
-        this.sync();
+    /**
+     * Options from the {@link Processor#process} call.
+     *
+     * @type {processOptions}
+     */
 
-        var opts = this.result.opts;
-        var str = _stringify3.default;
-        if (opts.syntax) str = opts.syntax.stringify;
-        if (opts.stringifier) str = opts.stringifier;
-        if (str.stringify) str = str.stringify;
+  }, {
+    key: 'opts',
+    get: function get() {
+      return this.result.opts;
+    }
 
-        var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);
-        var data = map.generate();
-        this.result.css = data[0];
-        this.result.map = data[1];
+    /**
+     * Processes input CSS through synchronous plugins, converts `Root`
+     * to a CSS string and returns {@link Result#css}.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {string}
+     * @see Result#css
+     */
 
-        return this.result;
-    };
+  }, {
+    key: 'css',
+    get: function get() {
+      return this.stringify().css;
+    }
 
-    _createClass(LazyResult, [{
-        key: 'processor',
-        get: function get() {
-            return this.result.processor;
-        }
+    /**
+     * An alias for the `css` property. Use it with syntaxes
+     * that generate non-CSS output.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {string}
+     * @see Result#content
+     */
 
-        /**
-         * Options from the {@link Processor#process} call.
-         * @type {processOptions}
-         */
+  }, {
+    key: 'content',
+    get: function get() {
+      return this.stringify().content;
+    }
 
-    }, {
-        key: 'opts',
-        get: function get() {
-            return this.result.opts;
-        }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#map}.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {SourceMapGenerator}
+     * @see Result#map
+     */
 
-        /**
-         * Processes input CSS through synchronous plugins, converts `Root`
-         * to a CSS string and returns {@link Result#css}.
-         *
-         * This property will only work with synchronous plugins.
-         * If the processor contains any asynchronous plugins
-         * it will throw an error. This is why this method is only
-         * for debug purpose, you should always use {@link LazyResult#then}.
-         *
-         * @type {string}
-         * @see Result#css
-         */
-
-    }, {
-        key: 'css',
-        get: function get() {
-            return this.stringify().css;
-        }
+  }, {
+    key: 'map',
+    get: function get() {
+      return this.stringify().map;
+    }
 
-        /**
-         * An alias for the `css` property. Use it with syntaxes
-         * that generate non-CSS output.
-         *
-         * This property will only work with synchronous plugins.
-         * If the processor contains any asynchronous plugins
-         * it will throw an error. This is why this method is only
-         * for debug purpose, you should always use {@link LazyResult#then}.
-         *
-         * @type {string}
-         * @see Result#content
-         */
-
-    }, {
-        key: 'content',
-        get: function get() {
-            return this.stringify().content;
-        }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#root}.
+     *
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error.
+     *
+     * This is why this method is only for debug purpose,
+     * you should always use {@link LazyResult#then}.
+     *
+     * @type {Root}
+     * @see Result#root
+     */
 
-        /**
-         * Processes input CSS through synchronous plugins
-         * and returns {@link Result#map}.
-         *
-         * This property will only work with synchronous plugins.
-         * If the processor contains any asynchronous plugins
-         * it will throw an error. This is why this method is only
-         * for debug purpose, you should always use {@link LazyResult#then}.
-         *
-         * @type {SourceMapGenerator}
-         * @see Result#map
-         */
-
-    }, {
-        key: 'map',
-        get: function get() {
-            return this.stringify().map;
-        }
+  }, {
+    key: 'root',
+    get: function get() {
+      return this.sync().root;
+    }
 
-        /**
-         * Processes input CSS through synchronous plugins
-         * and returns {@link Result#root}.
-         *
-         * This property will only work with synchronous plugins. If the processor
-         * contains any asynchronous plugins it will throw an error.
-         *
-         * This is why this method is only for debug purpose,
-         * you should always use {@link LazyResult#then}.
-         *
-         * @type {Root}
-         * @see Result#root
-         */
-
-    }, {
-        key: 'root',
-        get: function get() {
-            return this.sync().root;
-        }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#messages}.
+     *
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error.
+     *
+     * This is why this method is only for debug purpose,
+     * you should always use {@link LazyResult#then}.
+     *
+     * @type {Message[]}
+     * @see Result#messages
+     */
 
-        /**
-         * Processes input CSS through synchronous plugins
-         * and returns {@link Result#messages}.
-         *
-         * This property will only work with synchronous plugins. If the processor
-         * contains any asynchronous plugins it will throw an error.
-         *
-         * This is why this method is only for debug purpose,
-         * you should always use {@link LazyResult#then}.
-         *
-         * @type {Message[]}
-         * @see Result#messages
-         */
-
-    }, {
-        key: 'messages',
-        get: function get() {
-            return this.sync().messages;
-        }
-    }]);
+  }, {
+    key: 'messages',
+    get: function get() {
+      return this.sync().messages;
+    }
+  }]);
 
-    return LazyResult;
+  return LazyResult;
 }();
 
 exports.default = LazyResult;
@@ -432,4 +459,4 @@ exports.default = LazyResult;
  */
 
 module.exports = exports['default'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","Result","map","inline","prev","parser","parse","syntax","error","result","warnings","sync","toString","onFulfilled","onRejected","async","catch","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","console","err","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","MapGenerator","data","generate","content","messages"],"mappings":"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","file":"lazy-result.js","sourcesContent":["import MapGenerator from './map-generator';\nimport stringify    from './stringify';\nimport warnOnce     from './warn-once';\nimport Result       from './result';\nimport parse        from './parse';\n\nfunction isPromise(obj) {\n    return typeof obj === 'object' && typeof obj.then === 'function';\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css);\n */\nclass LazyResult {\n\n    constructor(processor, css, opts) {\n        this.stringified = false;\n        this.processed   = false;\n\n        let root;\n        if ( typeof css === 'object' && css !== null && css.type === 'root' ) {\n            root = css;\n        } else if ( css instanceof LazyResult || css instanceof Result ) {\n            root = css.root;\n            if ( css.map ) {\n                if ( typeof opts.map === 'undefined' ) opts.map = { };\n                if ( !opts.map.inline ) opts.map.inline = false;\n                opts.map.prev = css.map;\n            }\n        } else {\n            let parser = parse;\n            if ( opts.syntax )  parser = opts.syntax.parse;\n            if ( opts.parser )  parser = opts.parser;\n            if ( parser.parse ) parser = parser.parse;\n\n            try {\n                root = parser(css, opts);\n            } catch (error) {\n                this.error = error;\n            }\n        }\n\n        this.result = new Result(processor, root, opts);\n    }\n\n    /**\n     * Returns a {@link Processor} instance, which will be used\n     * for CSS transformations.\n     * @type {Processor}\n     */\n    get processor() {\n        return this.result.processor;\n    }\n\n    /**\n     * Options from the {@link Processor#process} call.\n     * @type {processOptions}\n     */\n    get opts() {\n        return this.result.opts;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins, converts `Root`\n     * to a CSS string and returns {@link Result#css}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#css\n     */\n    get css() {\n        return this.stringify().css;\n    }\n\n    /**\n     * An alias for the `css` property. Use it with syntaxes\n     * that generate non-CSS output.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#content\n     */\n    get content() {\n        return this.stringify().content;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#map}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {SourceMapGenerator}\n     * @see Result#map\n     */\n    get map() {\n        return this.stringify().map;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#root}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Root}\n     * @see Result#root\n     */\n    get root() {\n        return this.sync().root;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#messages}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Message[]}\n     * @see Result#messages\n     */\n    get messages() {\n        return this.sync().messages;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and calls {@link Result#warnings()}.\n     *\n     * @return {Warning[]} warnings from plugins\n     */\n    warnings() {\n        return this.sync().warnings();\n    }\n\n    /**\n     * Alias for the {@link LazyResult#css} property.\n     *\n     * @example\n     * lazy + '' === lazy.css;\n     *\n     * @return {string} output CSS\n     */\n    toString() {\n        return this.css;\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls `onFulfilled` with a Result instance. If a plugin throws\n     * an error, the `onRejected` callback will be executed.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onFulfilled} onFulfilled - callback will be executed\n     *                                    when all plugins will finish work\n     * @param {onRejected}  onRejected  - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css, { from: cssPath }).then(result => {\n     *   console.log(result.css);\n     * });\n     */\n    then(onFulfilled, onRejected) {\n        if (!('from' in this.opts)) {\n            warnOnce(\n                'Without `from` option PostCSS could generate wrong ' +\n                'source map and will not find Browserslist config. ' +\n                'Set it to CSS file path or to `undefined` to prevent ' +\n                'this warning.'\n            );\n        }\n        return this.async().then(onFulfilled, onRejected);\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls onRejected for each error thrown in any plugin.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onRejected} onRejected - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css).then(result => {\n     *   console.log(result.css);\n     * }).catch(error => {\n     *   console.error(error);\n     * });\n     */\n    catch(onRejected) {\n        return this.async().catch(onRejected);\n    }\n\n    handleError(error, plugin) {\n        try {\n            this.error = error;\n            if ( error.name === 'CssSyntaxError' && !error.plugin ) {\n                error.plugin = plugin.postcssPlugin;\n                error.setMessage();\n            } else if ( plugin.postcssVersion ) {\n                let pluginName = plugin.postcssPlugin;\n                let pluginVer  = plugin.postcssVersion;\n                let runtimeVer = this.result.processor.version;\n                let a = pluginVer.split('.');\n                let b = runtimeVer.split('.');\n\n                if ( a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1]) ) {\n                    console.error(\n                        'Unknown error from PostCSS plugin. ' +\n                        'Your current PostCSS version ' +\n                        'is ' + runtimeVer + ', but ' + pluginName + ' ' +\n                        'uses ' + pluginVer + '. Perhaps this is ' +\n                        'the source of the error below.');\n                }\n            }\n        } catch (err) {\n            if ( console && console.error ) console.error(err);\n        }\n    }\n\n    asyncTick(resolve, reject) {\n        if ( this.plugin >= this.processor.plugins.length ) {\n            this.processed = true;\n            return resolve();\n        }\n\n        try {\n            let plugin  = this.processor.plugins[this.plugin];\n            let promise = this.run(plugin);\n            this.plugin += 1;\n\n            if ( isPromise(promise) ) {\n                promise.then( () => {\n                    this.asyncTick(resolve, reject);\n                }).catch( error => {\n                    this.handleError(error, plugin);\n                    this.processed = true;\n                    reject(error);\n                });\n            } else {\n                this.asyncTick(resolve, reject);\n            }\n\n        } catch (error) {\n            this.processed = true;\n            reject(error);\n        }\n    }\n\n    async() {\n        if ( this.processed ) {\n            return new Promise( (resolve, reject) => {\n                if ( this.error ) {\n                    reject(this.error);\n                } else {\n                    resolve(this.stringify());\n                }\n            });\n        }\n        if ( this.processing ) {\n            return this.processing;\n        }\n\n        this.processing = new Promise( (resolve, reject) => {\n            if ( this.error ) return reject(this.error);\n            this.plugin = 0;\n            this.asyncTick(resolve, reject);\n        }).then( () => {\n            this.processed = true;\n            return this.stringify();\n        });\n\n        return this.processing;\n    }\n\n    sync() {\n        if ( this.processed ) return this.result;\n        this.processed = true;\n\n        if ( this.processing ) {\n            throw new Error(\n                'Use process(css).then(cb) to work with async plugins');\n        }\n\n        if ( this.error ) throw this.error;\n\n        for ( let plugin of this.result.processor.plugins ) {\n            let promise = this.run(plugin);\n            if ( isPromise(promise) ) {\n                throw new Error(\n                    'Use process(css).then(cb) to work with async plugins');\n            }\n        }\n\n        return this.result;\n    }\n\n    run(plugin) {\n        this.result.lastPlugin = plugin;\n\n        try {\n            return plugin(this.result.root, this.result);\n        } catch (error) {\n            this.handleError(error, plugin);\n            throw error;\n        }\n    }\n\n    stringify() {\n        if ( this.stringified ) return this.result;\n        this.stringified = true;\n\n        this.sync();\n\n        let opts = this.result.opts;\n        let str  = stringify;\n        if ( opts.syntax )      str = opts.syntax.stringify;\n        if ( opts.stringifier ) str = opts.stringifier;\n        if ( str.stringify )    str = str.stringify;\n\n        let map  = new MapGenerator(str, this.result.root, this.result.opts);\n        let data = map.generate();\n        this.result.css = data[0];\n        this.result.map = data[1];\n\n        return this.result;\n    }\n\n}\n\nexport default LazyResult;\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","Result","map","inline","prev","parser","parse","syntax","error","result","warnings","sync","toString","onFulfilled","onRejected","process","env","NODE_ENV","async","catch","finally","onFinally","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","console","err","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","MapGenerator","data","generate","content","messages"],"mappings":"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","file":"lazy-result.js","sourcesContent":["import MapGenerator from './map-generator'\nimport stringify from './stringify'\nimport warnOnce from './warn-once'\nimport Result from './result'\nimport parse from './parse'\n\nfunction isPromise (obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css)\n */\nclass LazyResult {\n  constructor (processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (typeof css === 'object' && css !== null && css.type === 'root') {\n      root = css\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = css.root\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = { }\n        if (!opts.map.inline) opts.map.inline = false\n        opts.map.prev = css.map\n      }\n    } else {\n      let parser = parse\n      if (opts.syntax) parser = opts.syntax.parse\n      if (opts.parser) parser = opts.parser\n      if (parser.parse) parser = parser.parse\n\n      try {\n        root = parser(css, opts)\n      } catch (error) {\n        this.error = error\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n  }\n\n  /**\n   * Returns a {@link Processor} instance, which will be used\n   * for CSS transformations.\n   *\n   * @type {Processor}\n   */\n  get processor () {\n    return this.result.processor\n  }\n\n  /**\n   * Options from the {@link Processor#process} call.\n   *\n   * @type {processOptions}\n   */\n  get opts () {\n    return this.result.opts\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins, converts `Root`\n   * to a CSS string and returns {@link Result#css}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#css\n   */\n  get css () {\n    return this.stringify().css\n  }\n\n  /**\n   * An alias for the `css` property. Use it with syntaxes\n   * that generate non-CSS output.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#content\n   */\n  get content () {\n    return this.stringify().content\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#map}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {SourceMapGenerator}\n   * @see Result#map\n   */\n  get map () {\n    return this.stringify().map\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#root}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Root}\n   * @see Result#root\n   */\n  get root () {\n    return this.sync().root\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#messages}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Message[]}\n   * @see Result#messages\n   */\n  get messages () {\n    return this.sync().messages\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and calls {@link Result#warnings()}.\n   *\n   * @return {Warning[]} Warnings from plugins.\n   */\n  warnings () {\n    return this.sync().warnings()\n  }\n\n  /**\n   * Alias for the {@link LazyResult#css} property.\n   *\n   * @example\n   * lazy + '' === lazy.css\n   *\n   * @return {string} Output CSS.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls `onFulfilled` with a Result instance. If a plugin throws\n   * an error, the `onRejected` callback will be executed.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFulfilled} onFulfilled Callback will be executed\n   *                                  when all plugins will finish work.\n   * @param {onRejected}  onRejected  Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css, { from: cssPath }).then(result => {\n   *   console.log(result.css)\n   * })\n   */\n  then (onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n          'and will not find Browserslist config. Set it to CSS file path ' +\n          'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onRejected for each error thrown in any plugin.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onRejected} onRejected Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).then(result => {\n   *   console.log(result.css)\n   * }).catch(error => {\n   *   console.error(error)\n   * })\n   */\n  catch (onRejected) {\n    return this.async().catch(onRejected)\n  }\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onFinally on any error or when all plugins will finish work.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFinally} onFinally Callback will be executed on any error or\n   *                              when all plugins will finish work.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([cssnext]).process(css).finally(() => {\n   *   console.log('processing ended')\n   * })\n   */\n  finally (onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  handleError (error, plugin) {\n    try {\n      this.error = error\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin\n        error.setMessage()\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          let pluginName = plugin.postcssPlugin\n          let pluginVer = plugin.postcssVersion\n          let runtimeVer = this.result.processor.version\n          let a = pluginVer.split('.')\n          let b = runtimeVer.split('.')\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n              'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' +\n              pluginVer + '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      if (console && console.error) console.error(err)\n    }\n  }\n\n  asyncTick (resolve, reject) {\n    if (this.plugin >= this.processor.plugins.length) {\n      this.processed = true\n      return resolve()\n    }\n\n    try {\n      let plugin = this.processor.plugins[this.plugin]\n      let promise = this.run(plugin)\n      this.plugin += 1\n\n      if (isPromise(promise)) {\n        promise.then(() => {\n          this.asyncTick(resolve, reject)\n        }).catch(error => {\n          this.handleError(error, plugin)\n          this.processed = true\n          reject(error)\n        })\n      } else {\n        this.asyncTick(resolve, reject)\n      }\n    } catch (error) {\n      this.processed = true\n      reject(error)\n    }\n  }\n\n  async () {\n    if (this.processed) {\n      return new Promise((resolve, reject) => {\n        if (this.error) {\n          reject(this.error)\n        } else {\n          resolve(this.stringify())\n        }\n      })\n    }\n    if (this.processing) {\n      return this.processing\n    }\n\n    this.processing = new Promise((resolve, reject) => {\n      if (this.error) return reject(this.error)\n      this.plugin = 0\n      this.asyncTick(resolve, reject)\n    }).then(() => {\n      this.processed = true\n      return this.stringify()\n    })\n\n    return this.processing\n  }\n\n  sync () {\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw new Error(\n        'Use process(css).then(cb) to work with async plugins')\n    }\n\n    if (this.error) throw this.error\n\n    for (let plugin of this.result.processor.plugins) {\n      let promise = this.run(plugin)\n      if (isPromise(promise)) {\n        throw new Error(\n          'Use process(css).then(cb) to work with async plugins')\n      }\n    }\n\n    return this.result\n  }\n\n  run (plugin) {\n    this.result.lastPlugin = plugin\n\n    try {\n      return plugin(this.result.root, this.result)\n    } catch (error) {\n      this.handleError(error, plugin)\n      throw error\n    }\n  }\n\n  stringify () {\n    if (this.stringified) return this.result\n    this.stringified = true\n\n    this.sync()\n\n    let opts = this.result.opts\n    let str = stringify\n    if (opts.syntax) str = opts.syntax.stringify\n    if (opts.stringifier) str = opts.stringifier\n    if (str.stringify) str = str.stringify\n\n    let map = new MapGenerator(str, this.result.root, this.result.opts)\n    let data = map.generate()\n    this.result.css = data[0]\n    this.result.map = data[1]\n\n    return this.result\n  }\n}\n\nexport default LazyResult\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"]}