vite 3.0.9 → 3.1.0-beta.2

package/dist/node/chunks/{dep-94c1417a.js → dep-42c2c4e4.js}

@@ -272,7 +272,7 @@ var processContent$1 = function processContent(
   }
 
   // Syntax support:
-  if (result.opts.syntax && result.opts.syntax.parse) {
+  if (result.opts.syntax?.parse) {
     parserList.push(result.opts.syntax.parse);
   }
 
@@ -491,6 +491,7 @@ function AtImport(options) {
     load: loadContent,
     plugins: [],
     addModulesDirectories: [],
+    nameLayer: null,
     ...options,
   };
 
@@ -509,9 +510,12 @@ function AtImport(options) {
       const state = {
         importedFiles: {},
         hashFiles: {},
+        rootFilename: null,
+        anonymousLayerCounter: 0,
       };
 
-      if (styles.source && styles.source.input && styles.source.input.file) {
+      if (styles.source?.input?.file) {
+        state.rootFilename = styles.source.input.file;
         state.importedFiles[styles.source.input.file] = {};
       }
 
@@ -519,6 +523,10 @@ function AtImport(options) {
         throw new Error("plugins option must be an array")
       }
 
+      if (options.nameLayer && typeof options.nameLayer !== "function") {
+        throw new Error("nameLayer option must be a function")
+      }
+
       return parseStyles(result, styles, options, state, [], []).then(
         bundle => {
           applyRaws(bundle);
@@ -553,7 +561,30 @@ function AtImport(options) {
           if (stmt.type === "import") {
             stmt.node.params = `${stmt.fullUri} ${stmt.media.join(", ")}`;
           } else if (stmt.type === "media") {
-            stmt.node.params = stmt.media.join(", ");
+            if (stmt.layer.length) {
+              const layerNode = atRule({
+                name: "layer",
+                params: stmt.layer.filter(layer => layer !== "").join("."),
+                source: stmt.node.source,
+              });
+
+              if (stmt.parentMedia?.length) {
+                const mediaNode = atRule({
+                  name: "media",
+                  params: stmt.parentMedia.join(", "),
+                  source: stmt.node.source,
+                });
+
+                mediaNode.append(layerNode);
+                layerNode.append(stmt.node);
+                stmt.node = mediaNode;
+              } else {
+                layerNode.append(stmt.node);
+                stmt.node = layerNode;
+              }
+            } else {
+              stmt.node.params = stmt.media.join(", ");
+            }
           } else {
             const { nodes } = stmt;
             const { parent } = nodes[0];
@@ -642,6 +673,7 @@ function AtImport(options) {
             return stmts.reduce((promise, stmt) => {
               return promise.then(() => {
                 stmt.media = joinMedia(media, stmt.media || []);
+                stmt.parentMedia = media;
                 stmt.layer = joinLayer(layer, stmt.layer || []);
 
                 // skip protocol base uri (protocol://url) or protocol-relative
@@ -708,7 +740,7 @@ function AtImport(options) {
       function resolveImportId(result, stmt, options, state) {
         const atRule = stmt.node;
         let sourceFile;
-        if (atRule.source && atRule.source.input && atRule.source.input.file) {
+        if (atRule.source?.input?.file) {
           sourceFile = atRule.source.input.file;
         }
         const base = sourceFile
@@ -755,18 +787,34 @@ function AtImport(options) {
       function loadImportContent(result, stmt, filename, options, state) {
         const atRule = stmt.node;
         const { media, layer } = stmt;
+        layer.forEach((layerPart, i) => {
+          if (layerPart === "") {
+            if (options.nameLayer) {
+              layer[i] = options
+                .nameLayer(state.anonymousLayerCounter++, state.rootFilename)
+                .toString();
+            } else {
+              throw atRule.error(
+                `When using anonymous layers in @import you must also set the "nameLayer" plugin option`
+              )
+            }
+          }
+        });
+
         if (options.skipDuplicates) {
           // skip files already imported at the same scope
-          if (
-            state.importedFiles[filename] &&
-            state.importedFiles[filename][media]
-          ) {
+          if (state.importedFiles[filename]?.[media]?.[layer]) {
             return
           }
 
           // save imported files to skip them next time
-          if (!state.importedFiles[filename]) state.importedFiles[filename] = {};
-          state.importedFiles[filename][media] = true;
+          if (!state.importedFiles[filename]) {
+            state.importedFiles[filename] = {};
+          }
+          if (!state.importedFiles[filename][media]) {
+            state.importedFiles[filename][media] = {};
+          }
+          state.importedFiles[filename][media][layer] = true;
         }
 
         return Promise.resolve(options.load(filename, options)).then(
@@ -777,8 +825,9 @@ function AtImport(options) {
             }
 
             // skip previous imported files not containing @import rules
-            if (state.hashFiles[content] && state.hashFiles[content][media])
+            if (state.hashFiles[content]?.[media]?.[layer]) {
               return
+            }
 
             return processContent(
               result,
@@ -796,8 +845,13 @@ function AtImport(options) {
                 });
                 if (!hasImport) {
                   // save hash files to skip them next time
-                  if (!state.hashFiles[content]) state.hashFiles[content] = {};
-                  state.hashFiles[content][media] = true;
+                  if (!state.hashFiles[content]) {
+                    state.hashFiles[content] = {};
+                  }
+                  if (!state.hashFiles[content][media]) {
+                    state.hashFiles[content][media] = {};
+                  }
+                  state.hashFiles[content][media][layer] = true;
                 }
               }
 

package/dist/node/chunks/{dep-25be4b3b.js → dep-6d69fd4f.js}

@@ -1,5 +1,5 @@
 import require$$0$1 from 'postcss';
-import { z as commonjsGlobal } from './dep-0fc8e132.js';
+import { z as commonjsGlobal } from './dep-d66eb979.js';
 import require$$0 from 'path';
 import require$$5 from 'crypto';
 import require$$0__default from 'fs';
@@ -1388,19 +1388,21 @@ Object.defineProperty(unquote$1, "__esModule", {
 });
 unquote$1.default = unquote;
 // copied from https://github.com/lakenen/node-unquote
-
 var reg = /['"]/;
 
 function unquote(str) {
   if (!str) {
     return "";
   }
+
   if (reg.test(str.charAt(0))) {
     str = str.substr(1);
   }
+
   if (reg.test(str.charAt(str.length - 1))) {
     str = str.substr(0, str.length - 1);
   }
+
   return str;
 }
 
@@ -1438,16 +1440,15 @@ lib.default = function (css, translations) {
 Object.defineProperty(parser$1, "__esModule", {
   value: true
 });
+parser$1.default = void 0;
 
-var _icssReplaceSymbols = lib;
-
-var _icssReplaceSymbols2 = _interopRequireDefault$6(_icssReplaceSymbols);
+var _icssReplaceSymbols = _interopRequireDefault$6(lib);
 
 function _interopRequireDefault$6(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Copied from https://github.com/css-modules/css-modules-loader-core
-
 const importRegexp = /^:import\((.+)\)$/;
+
 class Parser {
   constructor(pathFetcher, trace) {
     this.pathFetcher = pathFetcher;
@@ -1461,9 +1462,11 @@ class Parser {
     const parser = this;
     return {
       postcssPlugin: "css-modules-parser",
+
       OnceExit(css) {
         return Promise.all(parser.fetchAllImports(css)).then(() => parser.linkImportedSymbols(css)).then(() => parser.extractExports(css));
       }
+
     };
   }
 
@@ -1478,7 +1481,7 @@ class Parser {
   }
 
   linkImportedSymbols(css) {
-    (0, _icssReplaceSymbols2.default)(css, this.translations);
+    (0, _icssReplaceSymbols.default)(css, this.translations);
   }
 
   extractExports(css) {
@@ -1511,7 +1514,9 @@ class Parser {
       importNode.remove();
     }, err => console.log(err));
   }
+
 }
+
 parser$1.default = Parser;
 
 var loader = {};
@@ -1519,51 +1524,45 @@ var loader = {};
 Object.defineProperty(loader, "__esModule", {
   value: true
 });
+loader.default = void 0;
 
-var _postcss$1 = require$$0$1;
-
-var _postcss2$1 = _interopRequireDefault$5(_postcss$1);
-
-var _fs$1 = require$$0__default;
-
-var _fs2 = _interopRequireDefault$5(_fs$1);
-
-var _path = require$$0;
+var _postcss$1 = _interopRequireDefault$5(require$$0$1);
 
-var _path2 = _interopRequireDefault$5(_path);
+var _fs$1 = _interopRequireDefault$5(require$$0__default);
 
-var _parser$1 = parser$1;
+var _path = _interopRequireDefault$5(require$$0);
 
-var _parser2$1 = _interopRequireDefault$5(_parser$1);
+var _parser$1 = _interopRequireDefault$5(parser$1);
 
 function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Copied from https://github.com/css-modules/css-modules-loader-core
-
 class Core {
   constructor(plugins) {
     this.plugins = plugins || Core.defaultPlugins;
   }
 
   load(sourceString, sourcePath, trace, pathFetcher) {
-    let parser = new _parser2$1.default(pathFetcher, trace);
-
-    return (0, _postcss2$1.default)(this.plugins.concat([parser.plugin()])).process(sourceString, { from: "/" + sourcePath }).then(result => {
+    let parser = new _parser$1.default(pathFetcher, trace);
+    return (0, _postcss$1.default)(this.plugins.concat([parser.plugin()])).process(sourceString, {
+      from: sourcePath
+    }).then(result => {
       return {
         injectableSource: result.css,
         exportTokens: parser.exportTokens
       };
     });
   }
-}
 
-// Sorts dependencies in the following way:
+} // Sorts dependencies in the following way:
 // AAA comes before AA and A
 // AB comes after AA and before A
 // All Bs come after all As
 // This ensures that the files are always returned in the following order:
 // - In the order they were required, except
 // - After all their dependencies
+
+
 const traceKeySorter = (a, b) => {
   if (a.length < b.length) {
     return a < b.substring(0, a.length) ? -1 : 1;
@@ -1576,6 +1575,16 @@ const traceKeySorter = (a, b) => {
 
 class FileSystemLoader {
   constructor(root, plugins) {
+    if (root === '/' && process.platform === "win32") {
+      const cwdDrive = process.cwd().slice(0, 3);
+
+      if (!/^[A-Z]:\\$/.test(cwdDrive)) {
+        throw new Error(`Failed to obtain root from "${process.cwd()}".`);
+      }
+
+      root = cwdDrive;
+    }
+
     this.root = root;
     this.sources = {};
     this.traces = {};
@@ -1587,28 +1596,32 @@ class FileSystemLoader {
   fetch(_newPath, relativeTo, _trace) {
     let newPath = _newPath.replace(/^["']|["']$/g, ""),
         trace = _trace || String.fromCharCode(this.importNr++);
+
     return new Promise((resolve, reject) => {
-      let relativeDir = _path2.default.dirname(relativeTo),
-          rootRelativePath = _path2.default.resolve(relativeDir, newPath),
-          fileRelativePath = _path2.default.resolve(_path2.default.join(this.root, relativeDir), newPath);
+      let relativeDir = _path.default.dirname(relativeTo),
+          rootRelativePath = _path.default.resolve(relativeDir, newPath),
+          fileRelativePath = _path.default.resolve(_path.default.resolve(this.root, relativeDir), newPath); // if the path is not relative or absolute, try to resolve it in node_modules
+
 
-      // if the path is not relative or absolute, try to resolve it in node_modules
-      if (newPath[0] !== "." && newPath[0] !== "/") {
+      if (newPath[0] !== "." && !_path.default.isAbsolute(newPath)) {
         try {
           fileRelativePath = require.resolve(newPath);
-        } catch (e) {
-          // noop
+        } catch (e) {// noop
         }
       }
 
       const tokens = this.tokensByFile[fileRelativePath];
+
       if (tokens) {
         return resolve(tokens);
       }
 
-      _fs2.default.readFile(fileRelativePath, "utf-8", (err, source) => {
+      _fs$1.default.readFile(fileRelativePath, "utf-8", (err, source) => {
         if (err) reject(err);
-        this.core.load(source, rootRelativePath, trace, this.fetch.bind(this)).then(({ injectableSource, exportTokens }) => {
+        this.core.load(source, rootRelativePath, trace, this.fetch.bind(this)).then(({
+          injectableSource,
+          exportTokens
+        }) => {
           this.sources[fileRelativePath] = injectableSource;
           this.traces[trace] = fileRelativePath;
           this.tokensByFile[fileRelativePath] = exportTokens;
@@ -1622,18 +1635,20 @@ class FileSystemLoader {
     const traces = this.traces;
     const sources = this.sources;
     let written = new Set();
-
     return Object.keys(traces).sort(traceKeySorter).map(key => {
       const filename = traces[key];
+
       if (written.has(filename)) {
         return null;
       }
-      written.add(filename);
 
+      written.add(filename);
       return sources[filename];
     }).join("");
   }
+
 }
+
 loader.default = FileSystemLoader;
 
 var generateScopedName$1 = {};
@@ -1659,17 +1674,14 @@ Object.defineProperty(generateScopedName$1, "__esModule", {
 });
 generateScopedName$1.default = generateScopedName;
 
-var _stringHash = stringHash;
-
-var _stringHash2 = _interopRequireDefault$4(_stringHash);
+var _stringHash = _interopRequireDefault$4(stringHash);
 
 function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function generateScopedName(name, filename, css) {
   const i = css.indexOf(`.${name}`);
   const lineNumber = css.substr(0, i).split(/[\r\n]/).length;
-  const hash = (0, _stringHash2.default)(css).toString(36).substr(0, 5);
-
+  const hash = (0, _stringHash.default)(css).toString(36).substr(0, 5);
   return `_${name}_${hash}_${lineNumber}`;
 }
 
@@ -7309,45 +7321,43 @@ src.exports.postcss = true;
 Object.defineProperty(behaviours$1, "__esModule", {
   value: true
 });
-behaviours$1.behaviours = undefined;
+behaviours$1.behaviours = void 0;
 behaviours$1.getDefaultPlugins = getDefaultPlugins;
 behaviours$1.isValidBehaviour = isValidBehaviour;
 
-var _postcssModulesLocalByDefault = src$4.exports;
-
-var _postcssModulesLocalByDefault2 = _interopRequireDefault$1(_postcssModulesLocalByDefault);
-
-var _postcssModulesExtractImports = src$2.exports;
-
-var _postcssModulesExtractImports2 = _interopRequireDefault$1(_postcssModulesExtractImports);
-
-var _postcssModulesScope = src$1;
+var _postcssModulesLocalByDefault = _interopRequireDefault$1(src$4.exports);
 
-var _postcssModulesScope2 = _interopRequireDefault$1(_postcssModulesScope);
+var _postcssModulesExtractImports = _interopRequireDefault$1(src$2.exports);
 
-var _postcssModulesValues = src.exports;
+var _postcssModulesScope = _interopRequireDefault$1(src$1);
 
-var _postcssModulesValues2 = _interopRequireDefault$1(_postcssModulesValues);
+var _postcssModulesValues = _interopRequireDefault$1(src.exports);
 
 function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const behaviours = behaviours$1.behaviours = {
+const behaviours = {
   LOCAL: "local",
   GLOBAL: "global"
 };
+behaviours$1.behaviours = behaviours;
 
 function getDefaultPlugins({
   behaviour,
   generateScopedName,
   exportGlobals
 }) {
-  const scope = (0, _postcssModulesScope2.default)({ generateScopedName, exportGlobals });
-
+  const scope = (0, _postcssModulesScope.default)({
+    generateScopedName,
+    exportGlobals
+  });
   const plugins = {
-    [behaviours.LOCAL]: [_postcssModulesValues2.default, (0, _postcssModulesLocalByDefault2.default)({ mode: 'local' }), _postcssModulesExtractImports2.default, scope],
-    [behaviours.GLOBAL]: [_postcssModulesValues2.default, (0, _postcssModulesLocalByDefault2.default)({ mode: 'global' }), _postcssModulesExtractImports2.default, scope]
+    [behaviours.LOCAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({
+      mode: 'local'
+    }), _postcssModulesExtractImports.default, scope],
+    [behaviours.GLOBAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({
+      mode: 'global'
+    }), _postcssModulesExtractImports.default, scope]
   };
-
   return plugins[behaviour];
 }
 
@@ -7355,44 +7365,26 @@ function isValidBehaviour(behaviour) {
   return Object.keys(behaviours).map(key => behaviours[key]).indexOf(behaviour) > -1;
 }
 
-var _postcss = require$$0$1;
-
-var _postcss2 = _interopRequireDefault(_postcss);
-
-var _lodash = lodash_camelcase;
-
-var _lodash2 = _interopRequireDefault(_lodash);
-
-var _genericNames = genericNames;
-
-var _genericNames2 = _interopRequireDefault(_genericNames);
+var _postcss = _interopRequireDefault(require$$0$1);
 
-var _unquote = unquote$1;
+var _lodash = _interopRequireDefault(lodash_camelcase);
 
-var _unquote2 = _interopRequireDefault(_unquote);
+var _genericNames = _interopRequireDefault(genericNames);
 
-var _parser = parser$1;
+var _unquote = _interopRequireDefault(unquote$1);
 
-var _parser2 = _interopRequireDefault(_parser);
+var _parser = _interopRequireDefault(parser$1);
 
-var _loader = loader;
+var _loader = _interopRequireDefault(loader);
 
-var _loader2 = _interopRequireDefault(_loader);
+var _generateScopedName = _interopRequireDefault(generateScopedName$1);
 
-var _generateScopedName = generateScopedName$1;
-
-var _generateScopedName2 = _interopRequireDefault(_generateScopedName);
-
-var _saveJSON = saveJSON$1;
-
-var _saveJSON2 = _interopRequireDefault(_saveJSON);
+var _saveJSON = _interopRequireDefault(saveJSON$1);
 
 var _behaviours = behaviours$1;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
-
 const PLUGIN_NAME = "postcss-modules";
 
 function getDefaultScopeBehaviour(opts) {
@@ -7404,10 +7396,9 @@ function getDefaultScopeBehaviour(opts) {
 }
 
 function getScopedNameGenerator(opts) {
-  const scopedNameGenerator = opts.generateScopedName || _generateScopedName2.default;
-
+  const scopedNameGenerator = opts.generateScopedName || _generateScopedName.default;
   if (typeof scopedNameGenerator === "function") return scopedNameGenerator;
-  return (0, _genericNames2.default)(scopedNameGenerator, {
+  return (0, _genericNames.default)(scopedNameGenerator, {
     context: process.cwd(),
     hashPrefix: opts.hashPrefix
   });
@@ -7415,7 +7406,7 @@ function getScopedNameGenerator(opts) {
 
 function getLoader(opts, plugins) {
   const root = typeof opts.root === "undefined" ? "/" : opts.root;
-  return typeof opts.Loader === "function" ? new opts.Loader(root, plugins) : new _loader2.default(root, plugins);
+  return typeof opts.Loader === "function" ? new opts.Loader(root, plugins) : new _loader.default(root, plugins);
 }
 
 function isGlobalModule(globalModules, inputFile) {
@@ -7454,83 +7445,80 @@ function dashesCamelCase(string) {
 build.exports = (opts = {}) => {
   return {
     postcssPlugin: PLUGIN_NAME,
-    OnceExit(css, { result }) {
-      return _asyncToGenerator(function* () {
-        const getJSON = opts.getJSON || _saveJSON2.default;
-        const inputFile = css.source.input.file;
-        const pluginList = getDefaultPluginsList(opts, inputFile);
-        const resultPluginIndex = result.processor.plugins.findIndex(function (plugin) {
-          return isOurPlugin(plugin);
-        });
-        if (resultPluginIndex === -1) {
-          throw new Error('Plugin missing from options.');
-        }
-        const earlierPlugins = result.processor.plugins.slice(0, resultPluginIndex);
-        const loaderPlugins = [...earlierPlugins, ...pluginList];
-        const loader = getLoader(opts, loaderPlugins);
-        const fetcher = function fetcher(file, relativeTo, depTrace) {
-          const unquoteFile = (0, _unquote2.default)(file);
-          const resolvedResult = typeof opts.resolve === 'function' && opts.resolve(unquoteFile);
-          const resolvedFile = resolvedResult instanceof Promise ? resolvedResult : Promise.resolve(resolvedResult);
-
-          return resolvedFile.then(function (f) {
-            return loader.fetch.call(loader, `"${f || unquoteFile}"`, relativeTo, depTrace);
-          });
-        };
-        const parser = new _parser2.default(fetcher);
-
-        yield (0, _postcss2.default)([...pluginList, parser.plugin()]).process(css, {
-          from: inputFile
-        });
 
-        const out = loader.finalSource;
-        if (out) css.prepend(out);
+    async OnceExit(css, {
+      result
+    }) {
+      const getJSON = opts.getJSON || _saveJSON.default;
+      const inputFile = css.source.input.file;
+      const pluginList = getDefaultPluginsList(opts, inputFile);
+      const resultPluginIndex = result.processor.plugins.findIndex(plugin => isOurPlugin(plugin));
 
-        if (opts.localsConvention) {
-          const isFunc = typeof opts.localsConvention === "function";
+      if (resultPluginIndex === -1) {
+        throw new Error('Plugin missing from options.');
+      }
 
-          parser.exportTokens = Object.entries(parser.exportTokens).reduce(function (tokens, [className, value]) {
-            if (isFunc) {
-              tokens[opts.localsConvention(className, value, inputFile)] = value;
+      const earlierPlugins = result.processor.plugins.slice(0, resultPluginIndex);
+      const loaderPlugins = [...earlierPlugins, ...pluginList];
+      const loader = getLoader(opts, loaderPlugins);
 
-              return tokens;
-            }
+      const fetcher = (file, relativeTo, depTrace) => {
+        const unquoteFile = (0, _unquote.default)(file);
+        const resolvedResult = typeof opts.resolve === 'function' && opts.resolve(unquoteFile);
+        const resolvedFile = resolvedResult instanceof Promise ? resolvedResult : Promise.resolve(resolvedResult);
+        return resolvedFile.then(f => {
+          return loader.fetch.call(loader, `"${f || unquoteFile}"`, relativeTo, depTrace);
+        });
+      };
 
-            switch (opts.localsConvention) {
-              case "camelCase":
-                tokens[className] = value;
-                tokens[(0, _lodash2.default)(className)] = value;
+      const parser = new _parser.default(fetcher);
+      await (0, _postcss.default)([...pluginList, parser.plugin()]).process(css, {
+        from: inputFile
+      });
+      const out = loader.finalSource;
+      if (out) css.prepend(out);
+
+      if (opts.localsConvention) {
+        const isFunc = typeof opts.localsConvention === "function";
+        parser.exportTokens = Object.entries(parser.exportTokens).reduce((tokens, [className, value]) => {
+          if (isFunc) {
+            tokens[opts.localsConvention(className, value, inputFile)] = value;
+            return tokens;
+          }
 
-                break;
-              case "camelCaseOnly":
-                tokens[(0, _lodash2.default)(className)] = value;
+          switch (opts.localsConvention) {
+            case "camelCase":
+              tokens[className] = value;
+              tokens[(0, _lodash.default)(className)] = value;
+              break;
 
-                break;
-              case "dashes":
-                tokens[className] = value;
-                tokens[dashesCamelCase(className)] = value;
+            case "camelCaseOnly":
+              tokens[(0, _lodash.default)(className)] = value;
+              break;
 
-                break;
-              case "dashesOnly":
-                tokens[dashesCamelCase(className)] = value;
+            case "dashes":
+              tokens[className] = value;
+              tokens[dashesCamelCase(className)] = value;
+              break;
 
-                break;
-            }
+            case "dashesOnly":
+              tokens[dashesCamelCase(className)] = value;
+              break;
+          }
 
-            return tokens;
-          }, {});
-        }
+          return tokens;
+        }, {});
+      }
 
-        result.messages.push({
-          type: "export",
-          plugin: "postcss-modules",
-          exportTokens: parser.exportTokens
-        });
+      result.messages.push({
+        type: "export",
+        plugin: "postcss-modules",
+        exportTokens: parser.exportTokens
+      }); // getJSON may return a promise
 
-        // getJSON may return a promise
-        return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
-      })();
+      return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
     }
+
   };
 };