vite 3.0.8 → 3.1.0-beta.1

package/dist/node/chunks/{dep-399ffe4b.js → dep-6cde6b83.js}

@@ -1,5 +1,5 @@
 import require$$0$1 from 'postcss';
-import { z as commonjsGlobal } from './dep-74663fff.js';
+import { z as commonjsGlobal } from './dep-3ffe6dd0.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);
     }
+
   };
 };
 

package/dist/node/cli.js

@@ -1,6 +1,6 @@
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { y as picocolors, u as createLogger, e as resolveConfig } from './chunks/dep-74663fff.js';
+import { y as picocolors, u as createLogger, e as resolveConfig } from './chunks/dep-3ffe6dd0.js';
 import { VERSION } from './constants.js';
 import 'node:fs';
 import 'node:path';
@@ -25,13 +25,14 @@ import 'node:dns';
 import 'resolve';
 import 'crypto';
 import 'buffer';
+import 'node:buffer';
 import 'module';
+import 'worker_threads';
 import 'zlib';
 import 'https';
 import 'tls';
 import 'node:http';
 import 'node:https';
-import 'worker_threads';
 import 'querystring';
 import 'node:readline';
 import 'node:child_process';
@@ -694,7 +695,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-74663fff.js').then(function (n) { return n.E; });
+    const { createServer } = await import('./chunks/dep-3ffe6dd0.js').then(function (n) { return n.C; });
     try {
         const server = await createServer({
             root,
@@ -741,7 +742,7 @@ cli
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
-    const { build } = await import('./chunks/dep-74663fff.js').then(function (n) { return n.D; });
+    const { build } = await import('./chunks/dep-3ffe6dd0.js').then(function (n) { return n.B; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -765,7 +766,7 @@ cli
     .command('optimize [root]', 'pre-bundle dependencies')
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
-    const { optimizeDeps } = await import('./chunks/dep-74663fff.js').then(function (n) { return n.C; });
+    const { optimizeDeps } = await import('./chunks/dep-3ffe6dd0.js').then(function (n) { return n.A; });
     try {
         const config = await resolveConfig({
             root,
@@ -788,7 +789,7 @@ cli
     .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .action(async (root, options) => {
-    const { preview } = await import('./chunks/dep-74663fff.js').then(function (n) { return n.F; });
+    const { preview } = await import('./chunks/dep-3ffe6dd0.js').then(function (n) { return n.D; });
     try {
         const server = await preview({
             root,

package/dist/node/constants.js

@@ -1,7 +1,7 @@
 import path, { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-var version = "3.0.8";
+var version = "3.1.0-beta.1";
 
 const VERSION = version;
 const DEFAULT_MAIN_FIELDS = [