postcss 6.0.22 → 7.0.2

package/lib/postcss.js

@@ -48,17 +48,17 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * Create a new {@link Processor} instance that will apply `plugins`
  * as CSS processors.
  *
- * @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.
  *
- * @return {Processor} Processor to process multiple CSS
+ * @return {Processor} Processor to process multiple CSS.
  *
  * @example
- * import postcss from 'postcss';
+ * import postcss from 'postcss'
  *
  * postcss(plugins).process(css, { from, to }).then(result => {
- *   console.log(result.css);
- * });
+ *   console.log(result.css)
+ * })
  *
  * @namespace postcss
  */
@@ -80,9 +80,9 @@ function postcss() {
  * version of the plugin.
  *
  * ```js
- *  const processor = postcss([replace]);
- *  processor.plugins[0].postcssPlugin  //=> 'postcss-replace'
- *  processor.plugins[0].postcssVersion //=> '5.1.0'
+ * const processor = postcss([replace])
+ * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'
+ * processor.plugins[0].postcssVersion //=> '6.0.0'
  * ```
  *
  * The plugin function receives 2 arguments: {@link Root}
@@ -93,18 +93,18 @@ function postcss() {
  * ```js
  * const cleaner = postcss.plugin('postcss-cleaner', () => {
  *   return (root, result) => {
- *     result.root = postcss.root();
- *   };
- * });
+ *     result.root = postcss.root()
+ *   }
+ * })
  * ```
  *
  * As a convenience, plugins also expose a `process` method so that you can use
  * them as standalone tools.
  *
  * ```js
- * cleaner.process(css, processOpts, pluginOpts);
+ * cleaner.process(css, processOpts, pluginOpts)
  * // This is equivalent to:
- * postcss([ cleaner(pluginOpts) ]).process(css, processOpts);
+ * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)
  * ```
  *
  * Asynchronous plugins should return a `Promise` instance.
@@ -114,12 +114,12 @@ function postcss() {
  *   return (root, result) => {
  *     return new Promise( (resolve, reject) => {
  *       fs.readFile('base.css', (base) => {
- *         root.prepend(base);
- *         resolve();
- *       });
- *     });
- *   };
- * });
+ *         root.prepend(base)
+ *         resolve()
+ *       })
+ *     })
+ *   }
+ * })
  * ```
  *
  * Add warnings using the {@link Node#warn} method.
@@ -128,30 +128,30 @@ function postcss() {
  * ```js
  * postcss.plugin('postcss-caniuse-test', () => {
  *   return (root, result) => {
- *     css.walkDecls(decl => {
- *       if ( !caniuse.support(decl.prop) ) {
- *         decl.warn(result, 'Some browsers do not support ' + decl.prop);
+ *     root.walkDecls(decl => {
+ *       if (!caniuse.support(decl.prop)) {
+ *         decl.warn(result, 'Some browsers do not support ' + decl.prop)
  *       }
- *     });
- *   };
- * });
+ *     })
+ *   }
+ * })
  * ```
  *
- * @param {string} name          - PostCSS plugin name. Same as in `name`
- *                                 property in `package.json`. It will be saved
- *                                 in `plugin.postcssPlugin` property.
- * @param {function} initializer - will receive plugin options
- *                                 and should return {@link pluginFunction}
+ * @param {string} name          PostCSS plugin name. Same as in `name`
+ *                               property in `package.json`. It will be saved
+ *                               in `plugin.postcssPlugin` property.
+ * @param {function} initializer Will receive plugin options
+ *                               and should return {@link pluginFunction}
  *
- * @return {Plugin} PostCSS plugin
+ * @return {Plugin} PostCSS plugin.
  */
 postcss.plugin = function plugin(name, initializer) {
-  var creator = function creator() {
+  function creator() {
     var transformer = initializer.apply(undefined, arguments);
     transformer.postcssPlugin = name;
     transformer.postcssVersion = new _processor2.default().version;
     return transformer;
-  };
+  }
 
   var cache = void 0;
   Object.defineProperty(creator, 'postcss', {
@@ -171,9 +171,9 @@ postcss.plugin = function plugin(name, initializer) {
 /**
  * Default function to convert a node tree into a CSS string.
  *
- * @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}
  *
@@ -185,24 +185,26 @@ postcss.stringify = _stringify2.default;
  * Parses source css and returns a new {@link Root} node,
  * which contains the source CSS nodes.
  *
- * @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
+ * @return {Root} PostCSS AST.
  *
  * @example
  * // Simple CSS concatenation with source map support
- * const root1 = postcss.parse(css1, { from: file1 });
- * const root2 = postcss.parse(css2, { from: file2 });
- * root1.append(root2).toResult().css;
+ * const root1 = postcss.parse(css1, { from: file1 })
+ * const root2 = postcss.parse(css2, { from: file2 })
+ * root1.append(root2).toResult().css
  *
  * @function
  */
 postcss.parse = _parse2.default;
 
 /**
- * @member {vendor} - Contains the {@link vendor} module.
+ * Contains the {@link vendor} module.
+ *
+ * @type {vendor}
  *
  * @example
  * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']
@@ -210,7 +212,9 @@ postcss.parse = _parse2.default;
 postcss.vendor = _vendor2.default;
 
 /**
- * @member {list} - Contains the {@link list} module.
+ * Contains the {@link list} module.
+ *
+ * @member {list}
  *
  * @example
  * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']
@@ -220,9 +224,9 @@ postcss.list = _list2.default;
 /**
  * Creates a new {@link Comment} node.
  *
- * @param {object} [defaults] - properties for the new node.
+ * @param {object} [defaults] Properties for the new node.
  *
- * @return {Comment} new Comment node
+ * @return {Comment} New comment node
  *
  * @example
  * postcss.comment({ text: 'test' })
@@ -234,9 +238,9 @@ postcss.comment = function (defaults) {
 /**
  * Creates a new {@link AtRule} node.
  *
- * @param {object} [defaults] - properties for the new node.
+ * @param {object} [defaults] Properties for the new node.
  *
- * @return {AtRule} new AtRule node
+ * @return {AtRule} new at-rule node
  *
  * @example
  * postcss.atRule({ name: 'charset' }).toString() //=> "@charset"
@@ -248,9 +252,9 @@ postcss.atRule = function (defaults) {
 /**
  * Creates a new {@link Declaration} node.
  *
- * @param {object} [defaults] - properties for the new node.
+ * @param {object} [defaults] Properties for the new node.
  *
- * @return {Declaration} new Declaration node
+ * @return {Declaration} new declaration node
  *
  * @example
  * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> "color: red"
@@ -262,9 +266,9 @@ postcss.decl = function (defaults) {
 /**
  * Creates a new {@link Rule} node.
  *
- * @param {object} [defaults] - properties for the new node.
+ * @param {object} [defaults] Properties for the new node.
  *
- * @return {Rule} new Rule node
+ * @return {Rule} new rule node
  *
  * @example
  * postcss.rule({ selector: 'a' }).toString() //=> "a {\n}"
@@ -276,9 +280,9 @@ postcss.rule = function (defaults) {
 /**
  * Creates a new {@link Root} node.
  *
- * @param {object} [defaults] - properties for the new node.
+ * @param {object} [defaults] Properties for the new node.
  *
- * @return {Root} new Root node
+ * @return {Root} new root node.
  *
  * @example
  * postcss.root({ after: '\n' }).toString() //=> "\n"
@@ -289,4 +293,4 @@ postcss.root = function (defaults) {
 
 exports.default = postcss;
 module.exports = exports['default'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["postcss.es6"],"names":["postcss","plugins","length","Array","isArray","Processor","plugin","name","initializer","creator","transformer","postcssPlugin","postcssVersion","version","cache","Object","defineProperty","get","process","css","processOpts","pluginOpts","stringify","parse","vendor","list","comment","Comment","defaults","atRule","AtRule","decl","Declaration","rule","Rule","root","Root"],"mappings":";;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA;;;;;;;;;;;;;;;;;;AAkBA,SAASA,OAAT,GAA6B;AAAA,oCAATC,OAAS;AAATA,WAAS;AAAA;;AACzB,MAAKA,QAAQC,MAAR,KAAmB,CAAnB,IAAwBC,MAAMC,OAAN,CAAcH,QAAQ,CAAR,CAAd,CAA7B,EAAyD;AACrDA,cAAUA,QAAQ,CAAR,CAAV;AACH;AACD,SAAO,IAAII,mBAAJ,CAAcJ,OAAd,CAAP;AACH;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEAD,QAAQM,MAAR,GAAiB,SAASA,MAAT,CAAgBC,IAAhB,EAAsBC,WAAtB,EAAmC;AAChD,MAAIC,UAAU,SAAVA,OAAU,GAAmB;AAC7B,QAAIC,cAAcF,uCAAlB;AACAE,gBAAYC,aAAZ,GAA6BJ,IAA7B;AACAG,gBAAYE,cAAZ,GAA8B,IAAIP,mBAAJ,EAAD,CAAkBQ,OAA/C;AACA,WAAOH,WAAP;AACH,GALD;;AAOA,MAAII,cAAJ;AACAC,SAAOC,cAAP,CAAsBP,OAAtB,EAA+B,SAA/B,EAA0C;AACtCQ,OADsC,iBAChC;AACF,UAAK,CAACH,KAAN,EAAcA,QAAQL,SAAR;AACd,aAAOK,KAAP;AACH;AAJqC,GAA1C;;AAOAL,UAAQS,OAAR,GAAkB,UAAUC,GAAV,EAAeC,WAAf,EAA4BC,UAA5B,EAAwC;AACtD,WAAOrB,QAAQ,CAAES,QAAQY,UAAR,CAAF,CAAR,EAAiCH,OAAjC,CAAyCC,GAAzC,EAA8CC,WAA9C,CAAP;AACH,GAFD;;AAIA,SAAOX,OAAP;AACH,CArBD;;AAuBA;;;;;;;;;;;AAWAT,QAAQsB,SAAR,GAAoBA,mBAApB;;AAEA;;;;;;;;;;;;;;;;;;AAkBAtB,QAAQuB,KAAR,GAAgBA,eAAhB;;AAEA;;;;;;AAMAvB,QAAQwB,MAAR,GAAiBA,gBAAjB;;AAEA;;;;;;AAMAxB,QAAQyB,IAAR,GAAeA,cAAf;;AAEA;;;;;;;;;;AAUAzB,QAAQ0B,OAAR,GAAkB;AAAA,SAAY,IAAIC,iBAAJ,CAAYC,QAAZ,CAAZ;AAAA,CAAlB;;AAEA;;;;;;;;;;AAUA5B,QAAQ6B,MAAR,GAAiB;AAAA,SAAY,IAAIC,gBAAJ,CAAWF,QAAX,CAAZ;AAAA,CAAjB;;AAEA;;;;;;;;;;AAUA5B,QAAQ+B,IAAR,GAAe;AAAA,SAAY,IAAIC,qBAAJ,CAAgBJ,QAAhB,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQiC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASN,QAAT,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQmC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASR,QAAT,CAAZ;AAAA,CAAf;;kBAEe5B,O","file":"postcss.js","sourcesContent":["import Declaration from './declaration';\nimport Processor   from './processor';\nimport stringify   from './stringify';\nimport Comment     from './comment';\nimport AtRule      from './at-rule';\nimport vendor      from './vendor';\nimport parse       from './parse';\nimport list        from './list';\nimport Rule        from './rule';\nimport Root        from './root';\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins - PostCSS\n *        plugins. See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS\n *\n * @example\n * import postcss from 'postcss';\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css);\n * });\n *\n * @namespace postcss\n */\nfunction postcss(...plugins) {\n    if ( plugins.length === 1 && Array.isArray(plugins[0]) ) {\n        plugins = plugins[0];\n    }\n    return new Processor(plugins);\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n *  const processor = postcss([replace]);\n *  processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n *  processor.plugins[0].postcssVersion //=> '5.1.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root();\n *   };\n * });\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, processOpts, pluginOpts);\n * // This is equivalent to:\n * postcss([ cleaner(pluginOpts) ]).process(css, processOpts);\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base);\n *         resolve();\n *       });\n *     });\n *   };\n * });\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     css.walkDecls(decl => {\n *       if ( !caniuse.support(decl.prop) ) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop);\n *       }\n *     });\n *   };\n * });\n * ```\n *\n * @param {string} name          - PostCSS plugin name. Same as in `name`\n *                                 property in `package.json`. It will be saved\n *                                 in `plugin.postcssPlugin` property.\n * @param {function} initializer - will receive plugin options\n *                                 and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin\n */\npostcss.plugin = function plugin(name, initializer) {\n    let creator = function (...args) {\n        let transformer = initializer(...args);\n        transformer.postcssPlugin  = name;\n        transformer.postcssVersion = (new Processor()).version;\n        return transformer;\n    };\n\n    let cache;\n    Object.defineProperty(creator, 'postcss', {\n        get() {\n            if ( !cache ) cache = creator();\n            return cache;\n        }\n    });\n\n    creator.process = function (css, processOpts, pluginOpts) {\n        return postcss([ creator(pluginOpts) ]).process(css, processOpts);\n    };\n\n    return creator;\n};\n\n/**\n * Default function to convert a node tree into a CSS string.\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 * @function\n */\npostcss.stringify = stringify;\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\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 * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 });\n * const root2 = postcss.parse(css2, { from: file2 });\n * root1.append(root2).toResult().css;\n *\n * @function\n */\npostcss.parse = parse;\n\n/**\n * @member {vendor} - Contains the {@link vendor} module.\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = vendor;\n\n/**\n * @member {list} - Contains the {@link list} module.\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = list;\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Comment} new Comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = defaults => new Comment(defaults);\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {AtRule} new AtRule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = defaults => new AtRule(defaults);\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Declaration} new Declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = defaults => new Declaration(defaults);\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Rule} new Rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = defaults => new Rule(defaults);\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] - properties for the new node.\n *\n * @return {Root} new Root node\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = defaults => new Root(defaults);\n\nexport default postcss;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["postcss.es6"],"names":["postcss","plugins","length","Array","isArray","Processor","plugin","name","initializer","creator","transformer","postcssPlugin","postcssVersion","version","cache","Object","defineProperty","get","process","css","processOpts","pluginOpts","stringify","parse","vendor","list","comment","Comment","defaults","atRule","AtRule","decl","Declaration","rule","Rule","root","Root"],"mappings":";;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA;;;;;;;;;;;;;;;;;;AAkBA,SAASA,OAAT,GAA8B;AAAA,oCAATC,OAAS;AAATA,WAAS;AAAA;;AAC5B,MAAIA,QAAQC,MAAR,KAAmB,CAAnB,IAAwBC,MAAMC,OAAN,CAAcH,QAAQ,CAAR,CAAd,CAA5B,EAAuD;AACrDA,cAAUA,QAAQ,CAAR,CAAV;AACD;AACD,SAAO,IAAII,mBAAJ,CAAcJ,OAAd,CAAP;AACD;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEAD,QAAQM,MAAR,GAAiB,SAASA,MAAT,CAAiBC,IAAjB,EAAuBC,WAAvB,EAAoC;AACnD,WAASC,OAAT,GAA2B;AACzB,QAAIC,cAAcF,uCAAlB;AACAE,gBAAYC,aAAZ,GAA4BJ,IAA5B;AACAG,gBAAYE,cAAZ,GAA8B,IAAIP,mBAAJ,EAAD,CAAkBQ,OAA/C;AACA,WAAOH,WAAP;AACD;;AAED,MAAII,cAAJ;AACAC,SAAOC,cAAP,CAAsBP,OAAtB,EAA+B,SAA/B,EAA0C;AACxCQ,OADwC,iBACjC;AACL,UAAI,CAACH,KAAL,EAAYA,QAAQL,SAAR;AACZ,aAAOK,KAAP;AACD;AAJuC,GAA1C;;AAOAL,UAAQS,OAAR,GAAkB,UAAUC,GAAV,EAAeC,WAAf,EAA4BC,UAA5B,EAAwC;AACxD,WAAOrB,QAAQ,CAACS,QAAQY,UAAR,CAAD,CAAR,EAA+BH,OAA/B,CAAuCC,GAAvC,EAA4CC,WAA5C,CAAP;AACD,GAFD;;AAIA,SAAOX,OAAP;AACD,CArBD;;AAuBA;;;;;;;;;;;AAWAT,QAAQsB,SAAR,GAAoBA,mBAApB;;AAEA;;;;;;;;;;;;;;;;;;AAkBAtB,QAAQuB,KAAR,GAAgBA,eAAhB;;AAEA;;;;;;;;AAQAvB,QAAQwB,MAAR,GAAiBA,gBAAjB;;AAEA;;;;;;;;AAQAxB,QAAQyB,IAAR,GAAeA,cAAf;;AAEA;;;;;;;;;;AAUAzB,QAAQ0B,OAAR,GAAkB;AAAA,SAAY,IAAIC,iBAAJ,CAAYC,QAAZ,CAAZ;AAAA,CAAlB;;AAEA;;;;;;;;;;AAUA5B,QAAQ6B,MAAR,GAAiB;AAAA,SAAY,IAAIC,gBAAJ,CAAWF,QAAX,CAAZ;AAAA,CAAjB;;AAEA;;;;;;;;;;AAUA5B,QAAQ+B,IAAR,GAAe;AAAA,SAAY,IAAIC,qBAAJ,CAAgBJ,QAAhB,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQiC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASN,QAAT,CAAZ;AAAA,CAAf;;AAEA;;;;;;;;;;AAUA5B,QAAQmC,IAAR,GAAe;AAAA,SAAY,IAAIC,cAAJ,CAASR,QAAT,CAAZ;AAAA,CAAf;;kBAEe5B,O","file":"postcss.js","sourcesContent":["import Declaration from './declaration'\nimport Processor from './processor'\nimport stringify from './stringify'\nimport Comment from './comment'\nimport AtRule from './at-rule'\nimport vendor from './vendor'\nimport parse from './parse'\nimport list from './list'\nimport Rule from './rule'\nimport Root from './root'\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n *        See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS.\n *\n * @example\n * import postcss from 'postcss'\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css)\n * })\n *\n * @namespace postcss\n */\nfunction postcss (...plugins) {\n  if (plugins.length === 1 && Array.isArray(plugins[0])) {\n    plugins = plugins[0]\n  }\n  return new Processor(plugins)\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n * const processor = postcss([replace])\n * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n * processor.plugins[0].postcssVersion //=> '6.0.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root()\n *   }\n * })\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, processOpts, pluginOpts)\n * // This is equivalent to:\n * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base)\n *         resolve()\n *       })\n *     })\n *   }\n * })\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     root.walkDecls(decl => {\n *       if (!caniuse.support(decl.prop)) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop)\n *       }\n *     })\n *   }\n * })\n * ```\n *\n * @param {string} name          PostCSS plugin name. Same as in `name`\n *                               property in `package.json`. It will be saved\n *                               in `plugin.postcssPlugin` property.\n * @param {function} initializer Will receive plugin options\n *                               and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin.\n */\npostcss.plugin = function plugin (name, initializer) {\n  function creator (...args) {\n    let transformer = initializer(...args)\n    transformer.postcssPlugin = name\n    transformer.postcssVersion = (new Processor()).version\n    return transformer\n  }\n\n  let cache\n  Object.defineProperty(creator, 'postcss', {\n    get () {\n      if (!cache) cache = creator()\n      return cache\n    }\n  })\n\n  creator.process = function (css, processOpts, pluginOpts) {\n    return postcss([creator(pluginOpts)]).process(css, processOpts)\n  }\n\n  return creator\n}\n\n/**\n * Default function to convert a node tree into a CSS string.\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 * @function\n */\npostcss.stringify = stringify\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\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 * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 })\n * const root2 = postcss.parse(css2, { from: file2 })\n * root1.append(root2).toResult().css\n *\n * @function\n */\npostcss.parse = parse\n\n/**\n * Contains the {@link vendor} module.\n *\n * @type {vendor}\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = vendor\n\n/**\n * Contains the {@link list} module.\n *\n * @member {list}\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = list\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Comment} New comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = defaults => new Comment(defaults)\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {AtRule} new at-rule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = defaults => new AtRule(defaults)\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Declaration} new declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = defaults => new Declaration(defaults)\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Rule} new rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = defaults => new Rule(defaults)\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Root} new root node.\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = defaults => new Root(defaults)\n\nexport default postcss\n"]}

package/lib/previous-map.js

@@ -21,15 +21,11 @@ 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 fromBase64(str) {
-    if (Buffer) {
-        if (Buffer.from && Buffer.from !== Uint8Array.from) {
-            return Buffer.from(str, 'base64').toString();
-        } else {
-            return new Buffer(str, 'base64').toString();
-        }
-    } else {
-        return window.atob(str);
-    }
+  if (Buffer) {
+    return Buffer.from(str, 'base64').toString();
+  } else {
+    return window.atob(str);
+  }
 }
 
 /**
@@ -40,131 +36,130 @@ function fromBase64(str) {
  * near input file (according `from` option).
  *
  * @example
- * const root = postcss.parse(css, { from: 'a.sass.css' });
+ * const root = postcss.parse(css, { from: 'a.sass.css' })
  * root.input.map //=> PreviousMap
  */
 
 var PreviousMap = function () {
-
-    /**
-     * @param {string}         css    - input CSS source
-     * @param {processOptions} [opts] - {@link Processor#process} options
-     */
-    function PreviousMap(css, opts) {
-        _classCallCheck(this, PreviousMap);
-
-        this.loadAnnotation(css);
-        /**
-         * @member {boolean} - Was source map inlined by data-uri to input CSS.
-         */
-        this.inline = this.startWith(this.annotation, 'data:');
-
-        var prev = opts.map ? opts.map.prev : undefined;
-        var text = this.loadMap(opts.from, prev);
-        if (text) this.text = text;
-    }
-
-    /**
-     * Create a instance of `SourceMapGenerator` class
-     * from the `source-map` library to work with source map information.
-     *
-     * It is lazy method, so it will create object only on first call
-     * and then it will use cache.
-     *
-     * @return {SourceMapGenerator} object with source map information
-     */
-
-
-    PreviousMap.prototype.consumer = function consumer() {
-        if (!this.consumerCache) {
-            this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);
-        }
-        return this.consumerCache;
-    };
-
+  /**
+   * @param {string}         css    Input CSS source.
+   * @param {processOptions} [opts] {@link Processor#process} options.
+   */
+  function PreviousMap(css, opts) {
+    _classCallCheck(this, PreviousMap);
+
+    this.loadAnnotation(css);
     /**
-     * Does source map contains `sourcesContent` with input source text.
+     * Was source map inlined by data-uri to input CSS.
      *
-     * @return {boolean} Is `sourcesContent` present
+     * @type {boolean}
      */
-
-
-    PreviousMap.prototype.withContent = function withContent() {
-        return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
-    };
-
-    PreviousMap.prototype.startWith = function startWith(string, start) {
-        if (!string) return false;
-        return string.substr(0, start.length) === start;
-    };
-
-    PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
-        var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
-        if (match) this.annotation = match[1].trim();
-    };
-
-    PreviousMap.prototype.decodeInline = function decodeInline(text) {
-        // data:application/json;charset=utf-8;base64,
-        // data:application/json;charset=utf8;base64,
-        // data:application/json;base64,
-        var baseUri = /^data:application\/json;(?:charset=utf-?8;)?base64,/;
-        var uri = 'data:application/json,';
-
-        if (this.startWith(text, uri)) {
-            return decodeURIComponent(text.substr(uri.length));
-        } else if (baseUri.test(text)) {
-            return fromBase64(text.substr(RegExp.lastMatch.length));
+    this.inline = this.startWith(this.annotation, 'data:');
+
+    var prev = opts.map ? opts.map.prev : undefined;
+    var text = this.loadMap(opts.from, prev);
+    if (text) this.text = text;
+  }
+
+  /**
+   * Create a instance of `SourceMapGenerator` class
+   * from the `source-map` library to work with source map information.
+   *
+   * It is lazy method, so it will create object only on first call
+   * and then it will use cache.
+   *
+   * @return {SourceMapGenerator} Object with source map information.
+   */
+
+
+  PreviousMap.prototype.consumer = function consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new _sourceMap2.default.SourceMapConsumer(this.text);
+    }
+    return this.consumerCache;
+  };
+
+  /**
+   * Does source map contains `sourcesContent` with input source text.
+   *
+   * @return {boolean} Is `sourcesContent` present.
+   */
+
+
+  PreviousMap.prototype.withContent = function withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  };
+
+  PreviousMap.prototype.startWith = function startWith(string, start) {
+    if (!string) return false;
+    return string.substr(0, start.length) === start;
+  };
+
+  PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
+    var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
+    if (match) this.annotation = match[1].trim();
+  };
+
+  PreviousMap.prototype.decodeInline = function decodeInline(text) {
+    var baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+    var baseUri = /^data:application\/json;base64,/;
+    var uri = 'data:application/json,';
+
+    if (this.startWith(text, uri)) {
+      return decodeURIComponent(text.substr(uri.length));
+    } else if (baseCharsetUri.test(text) || baseUri.test(text)) {
+      return fromBase64(text.substr(RegExp.lastMatch.length));
+    } else {
+      var encoding = text.match(/data:application\/json;([^,]+),/)[1];
+      throw new Error('Unsupported source map encoding ' + encoding);
+    }
+  };
+
+  PreviousMap.prototype.loadMap = function loadMap(file, prev) {
+    if (prev === false) return false;
+
+    if (prev) {
+      if (typeof prev === 'string') {
+        return prev;
+      } else if (typeof prev === 'function') {
+        var prevPath = prev(file);
+        if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {
+          return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();
         } else {
-            var encoding = text.match(/data:application\/json;([^,]+),/)[1];
-            throw new Error('Unsupported source map encoding ' + encoding);
-        }
-    };
-
-    PreviousMap.prototype.loadMap = function loadMap(file, prev) {
-        if (prev === false) return false;
-
-        if (prev) {
-            if (typeof prev === 'string') {
-                return prev;
-            } else if (typeof prev === 'function') {
-                var prevPath = prev(file);
-                if (prevPath && _fs2.default.existsSync && _fs2.default.existsSync(prevPath)) {
-                    return _fs2.default.readFileSync(prevPath, 'utf-8').toString().trim();
-                } else {
-                    throw new Error('Unable to load previous source map: ' + prevPath.toString());
-                }
-            } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {
-                return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();
-            } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {
-                return prev.toString();
-            } else if (this.isMap(prev)) {
-                return JSON.stringify(prev);
-            } else {
-                throw new Error('Unsupported previous source map format: ' + prev.toString());
-            }
-        } else if (this.inline) {
-            return this.decodeInline(this.annotation);
-        } else if (this.annotation) {
-            var map = this.annotation;
-            if (file) map = _path2.default.join(_path2.default.dirname(file), map);
-
-            this.root = _path2.default.dirname(map);
-            if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {
-                return _fs2.default.readFileSync(map, 'utf-8').toString().trim();
-            } else {
-                return false;
-            }
+          throw new Error('Unable to load previous source map: ' + prevPath.toString());
         }
-    };
+      } else if (prev instanceof _sourceMap2.default.SourceMapConsumer) {
+        return _sourceMap2.default.SourceMapGenerator.fromSourceMap(prev).toString();
+      } else if (prev instanceof _sourceMap2.default.SourceMapGenerator) {
+        return prev.toString();
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev);
+      } else {
+        throw new Error('Unsupported previous source map format: ' + prev.toString());
+      }
+    } else if (this.inline) {
+      return this.decodeInline(this.annotation);
+    } else if (this.annotation) {
+      var map = this.annotation;
+      if (file) map = _path2.default.join(_path2.default.dirname(file), map);
+
+      this.root = _path2.default.dirname(map);
+      if (_fs2.default.existsSync && _fs2.default.existsSync(map)) {
+        return _fs2.default.readFileSync(map, 'utf-8').toString().trim();
+      } else {
+        return false;
+      }
+    }
+  };
 
-    PreviousMap.prototype.isMap = function isMap(map) {
-        if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;
-        return typeof map.mappings === 'string' || typeof map._mappings === 'string';
-    };
+  PreviousMap.prototype.isMap = function isMap(map) {
+    if ((typeof map === 'undefined' ? 'undefined' : _typeof(map)) !== 'object') return false;
+    return typeof map.mappings === 'string' || typeof map._mappings === 'string';
+  };
 
-    return PreviousMap;
+  return PreviousMap;
 }();
 
 exports.default = PreviousMap;
 module.exports = exports['default'];
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["fromBase64","str","Buffer","from","Uint8Array","toString","window","atob","PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","consumer","consumerCache","mozilla","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","match","trim","decodeInline","baseUri","uri","decodeURIComponent","test","RegExp","lastMatch","encoding","Error","file","prevPath","fs","existsSync","readFileSync","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","path","join","dirname","root","mappings","_mappings"],"mappings":"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","file":"previous-map.js","sourcesContent":["import mozilla  from 'source-map';\nimport path     from 'path';\nimport fs       from 'fs';\n\nfunction fromBase64(str) {\n    if ( Buffer ) {\n        if ( Buffer.from && Buffer.from !== Uint8Array.from ) {\n            return Buffer.from(str, 'base64').toString();\n        } else {\n            return new Buffer(str, 'base64').toString();\n        }\n    } else {\n        return window.atob(str);\n    }\n}\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' });\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n\n    /**\n     * @param {string}         css    - input CSS source\n     * @param {processOptions} [opts] - {@link Processor#process} options\n     */\n    constructor(css, opts) {\n        this.loadAnnotation(css);\n        /**\n         * @member {boolean} - Was source map inlined by data-uri to input CSS.\n         */\n        this.inline = this.startWith(this.annotation, 'data:');\n\n        let prev = opts.map ? opts.map.prev : undefined;\n        let text = this.loadMap(opts.from, prev);\n        if ( text ) this.text = text;\n    }\n\n    /**\n     * Create a instance of `SourceMapGenerator` class\n     * from the `source-map` library to work with source map information.\n     *\n     * It is lazy method, so it will create object only on first call\n     * and then it will use cache.\n     *\n     * @return {SourceMapGenerator} object with source map information\n     */\n    consumer() {\n        if ( !this.consumerCache ) {\n            this.consumerCache = new mozilla.SourceMapConsumer(this.text);\n        }\n        return this.consumerCache;\n    }\n\n    /**\n     * Does source map contains `sourcesContent` with input source text.\n     *\n     * @return {boolean} Is `sourcesContent` present\n     */\n    withContent() {\n        return !!(this.consumer().sourcesContent &&\n                  this.consumer().sourcesContent.length > 0);\n    }\n\n    startWith(string, start) {\n        if ( !string ) return false;\n        return string.substr(0, start.length) === start;\n    }\n\n    loadAnnotation(css) {\n        let match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//);\n        if ( match ) this.annotation = match[1].trim();\n    }\n\n    decodeInline(text) {\n        // data:application/json;charset=utf-8;base64,\n        // data:application/json;charset=utf8;base64,\n        // data:application/json;base64,\n        let baseUri = /^data:application\\/json;(?:charset=utf-?8;)?base64,/;\n        let uri     = 'data:application/json,';\n\n        if ( this.startWith(text, uri) ) {\n            return decodeURIComponent( text.substr(uri.length) );\n\n        } else if ( baseUri.test(text) ) {\n            return fromBase64(text.substr(RegExp.lastMatch.length));\n\n        } else {\n            let encoding = text.match(/data:application\\/json;([^,]+),/)[1];\n            throw new Error('Unsupported source map encoding ' + encoding);\n        }\n    }\n\n    loadMap(file, prev) {\n        if ( prev === false ) return false;\n\n        if ( prev ) {\n            if ( typeof prev === 'string' ) {\n                return prev;\n            } else if ( typeof prev === 'function' ) {\n                let prevPath = prev(file);\n                if ( prevPath && fs.existsSync && fs.existsSync(prevPath) ) {\n                    return fs.readFileSync(prevPath, 'utf-8').toString().trim();\n                } else {\n                    throw new Error('Unable to load previous source map: ' +\n                    prevPath.toString());\n                }\n            } else if ( prev instanceof mozilla.SourceMapConsumer ) {\n                return mozilla.SourceMapGenerator\n                    .fromSourceMap(prev).toString();\n            } else if ( prev instanceof mozilla.SourceMapGenerator ) {\n                return prev.toString();\n            } else if ( this.isMap(prev) ) {\n                return JSON.stringify(prev);\n            } else {\n                throw new Error('Unsupported previous source map format: ' +\n                    prev.toString());\n            }\n\n        } else if ( this.inline ) {\n            return this.decodeInline(this.annotation);\n\n        } else if ( this.annotation ) {\n            let map = this.annotation;\n            if ( file ) map = path.join(path.dirname(file), map);\n\n            this.root = path.dirname(map);\n            if ( fs.existsSync && fs.existsSync(map) ) {\n                return fs.readFileSync(map, 'utf-8').toString().trim();\n            } else {\n                return false;\n            }\n        }\n    }\n\n    isMap(map) {\n        if ( typeof map !== 'object' ) return false;\n        return typeof map.mappings === 'string' ||\n               typeof map._mappings === 'string';\n    }\n}\n\nexport default PreviousMap;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["fromBase64","str","Buffer","from","toString","window","atob","PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","consumer","consumerCache","mozilla","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","match","trim","decodeInline","baseCharsetUri","baseUri","uri","decodeURIComponent","test","RegExp","lastMatch","encoding","Error","file","prevPath","fs","existsSync","readFileSync","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","path","join","dirname","root","mappings","_mappings"],"mappings":"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","file":"previous-map.js","sourcesContent":["import mozilla from 'source-map'\nimport path from 'path'\nimport fs from 'fs'\n\nfunction fromBase64 (str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    return window.atob(str)\n  }\n}\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' })\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n  /**\n   * @param {string}         css    Input CSS source.\n   * @param {processOptions} [opts] {@link Processor#process} options.\n   */\n  constructor (css, opts) {\n    this.loadAnnotation(css)\n    /**\n     * Was source map inlined by data-uri to input CSS.\n     *\n     * @type {boolean}\n     */\n    this.inline = this.startWith(this.annotation, 'data:')\n\n    let prev = opts.map ? opts.map.prev : undefined\n    let text = this.loadMap(opts.from, prev)\n    if (text) this.text = text\n  }\n\n  /**\n   * Create a instance of `SourceMapGenerator` class\n   * from the `source-map` library to work with source map information.\n   *\n   * It is lazy method, so it will create object only on first call\n   * and then it will use cache.\n   *\n   * @return {SourceMapGenerator} Object with source map information.\n   */\n  consumer () {\n    if (!this.consumerCache) {\n      this.consumerCache = new mozilla.SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  /**\n   * Does source map contains `sourcesContent` with input source text.\n   *\n   * @return {boolean} Is `sourcesContent` present.\n   */\n  withContent () {\n    return !!(this.consumer().sourcesContent &&\n              this.consumer().sourcesContent.length > 0)\n  }\n\n  startWith (string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  loadAnnotation (css) {\n    let match = css.match(/\\/\\*\\s*# sourceMappingURL=(.*)\\s*\\*\\//)\n    if (match) this.annotation = match[1].trim()\n  }\n\n  decodeInline (text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let uri = 'data:application/json,'\n\n    if (this.startWith(text, uri)) {\n      return decodeURIComponent(text.substr(uri.length))\n    } else if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length))\n    } else {\n      let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n      throw new Error('Unsupported source map encoding ' + encoding)\n    }\n  }\n\n  loadMap (file, prev) {\n    if (prev === false) return false\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev\n      } else if (typeof prev === 'function') {\n        let prevPath = prev(file)\n        if (prevPath && fs.existsSync && fs.existsSync(prevPath)) {\n          return fs.readFileSync(prevPath, 'utf-8').toString().trim()\n        } else {\n          throw new Error(\n            'Unable to load previous source map: ' + prevPath.toString())\n        }\n      } else if (prev instanceof mozilla.SourceMapConsumer) {\n        return mozilla.SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof mozilla.SourceMapGenerator) {\n        return prev.toString()\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev)\n      } else {\n        throw new Error(\n          'Unsupported previous source map format: ' + prev.toString())\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation)\n    } else if (this.annotation) {\n      let map = this.annotation\n      if (file) map = path.join(path.dirname(file), map)\n\n      this.root = path.dirname(map)\n      if (fs.existsSync && fs.existsSync(map)) {\n        return fs.readFileSync(map, 'utf-8').toString().trim()\n      } else {\n        return false\n      }\n    }\n  }\n\n  isMap (map) {\n    if (typeof map !== 'object') return false\n    return typeof map.mappings === 'string' || typeof map._mappings === 'string'\n  }\n}\n\nexport default PreviousMap\n"]}