vite 2.9.0-beta.0 → 2.9.0-beta.1

package/dist/node/chunks/{dep-5f1b3f27.js → dep-1cf708c4.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-429629d5.js');
+var index = require('./dep-62435a6f.js');
 var require$$1 = require('crypto');
 require('fs');
 require('path');

package/dist/node/chunks/{dep-026034b4.js → dep-28bf75e1.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-429629d5.js');
+var index = require('./dep-62435a6f.js');
 
 function _mergeNamespaces(n, m) {
     for (var i = 0; i < m.length; i++) {

package/dist/node/chunks/{dep-229a03bb.js → dep-47674adb.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('postcss');
-var index$1 = require('./dep-429629d5.js');
+var index$1 = require('./dep-62435a6f.js');
 var path$2 = require('path');
 var require$$1 = require('crypto');
 var fs = require('fs');

package/dist/node/chunks/{dep-429629d5.js → dep-62435a6f.js}

@@ -4464,7 +4464,7 @@ function checkPublicFile(url, { publicDir }) {
         return;
     }
 }
-function fileToUrl(id, config, ctx) {
+async function fileToUrl(id, config, ctx) {
     if (config.command === 'serve') {
         return fileToDevUrl(id, config);
     }
@@ -18935,7 +18935,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-229a03bb.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-47674adb.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21393,7 +21393,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-026034b4.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-28bf75e1.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -35692,6 +35692,7 @@ ssr) {
     // a hint for Node.js
     // all files in the cache directory should be recognized as ES modules
     writeFile(path__default.resolve(processingCacheDir, 'package.json'), JSON.stringify({ type: 'module' }));
+    let newBrowserHash;
     let deps;
     if (!newDeps) {
         // Initial optimizeDeps at server start. Perform a fast scan using esbuild to
@@ -35713,7 +35714,7 @@ ssr) {
             throw e;
         }
         // update browser hash
-        metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
+        newBrowserHash = metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
         // We generate the mapping of dependency ids to their cache file location
         // before processing the dependencies with esbuild. This allow us to continue
         // processing files in the importAnalysis and resolve plugins
@@ -35722,7 +35723,7 @@ ssr) {
             metadata.optimized[id] = {
                 file: getOptimizedDepPath(id, config),
                 src: entry,
-                browserHash: metadata.browserHash,
+                browserHash: newBrowserHash,
                 processing: processing.promise
             };
         }
@@ -35731,13 +35732,11 @@ ssr) {
         // Missing dependencies were found at run-time, optimizeDeps called while the
         // server is running
         deps = depsFromOptimizedDepInfo(newDeps);
-        // Clone optimized info objects, fileHash, browserHash may be changed for them
-        for (const o of Object.keys(newDeps)) {
-            metadata.optimized[o] = { ...newDeps[o] };
-        }
-        // update global browser hash, but keep newDeps individual hashs until we know
+        metadata.optimized = newDeps;
+        // For reruns keep current global browser hash and newDeps individual hashes until we know
         // if files are stable so we can avoid a full page reload
-        metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
+        metadata.browserHash = currentData.browserHash;
+        newBrowserHash = getOptimizedBrowserHash(metadata.hash, deps);
     }
     return { metadata, run: prebundleDeps };
     async function prebundleDeps() {
@@ -35893,8 +35892,9 @@ ssr) {
             // New deps that ended up with a different hash replaced while doing analysis import are going to
             // return a not found so the browser doesn't cache them. And will properly get loaded after the reload
             for (const id in deps) {
-                metadata.optimized[id].browserHash = metadata.browserHash;
+                metadata.optimized[id].browserHash = newBrowserHash;
             }
+            metadata.browserHash = newBrowserHash;
         }
         // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
         commitProcessingDepsCacheSync();
@@ -35906,7 +35906,7 @@ ssr) {
         var _a;
         // Rewire the file paths from the temporal processing dir to the final deps cache dir
         const dataPath = path__default.join(processingCacheDir, '_metadata.json');
-        writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata));
+        writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata, depsCacheDir));
         // Processing is done, we can now replace the depsCacheDir with processingCacheDir
         if (fs__default.existsSync(depsCacheDir)) {
             const rmSync = (_a = fs__default.rmSync) !== null && _a !== void 0 ? _a : fs__default.rmdirSync; // TODO: Remove after support for Node 12 is dropped
@@ -35991,16 +35991,27 @@ function createIsOptimizedDepUrl(config) {
     };
 }
 function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir, processing) {
-    const metadata = JSON.parse(jsonMetadata);
+    const metadata = JSON.parse(jsonMetadata, (key, value) => {
+        // Paths can be absolute or relative to the deps cache dir where
+        // the _metadata.json is located
+        if (key === 'file' || key === 'src') {
+            return normalizePath$4(path__default.resolve(depsCacheDir, value));
+        }
+        return value;
+    });
     for (const o of Object.keys(metadata.optimized)) {
         metadata.optimized[o].processing = processing;
     }
     return { ...metadata, discovered: {}, processing };
 }
-function stringifyOptimizedDepsMetadata(metadata) {
+function stringifyOptimizedDepsMetadata(metadata, depsCacheDir) {
     return JSON.stringify(metadata, (key, value) => {
-        if (key === 'processing' || key === 'discovered')
+        if (key === 'processing' || key === 'discovered') {
             return;
+        }
+        if (key === 'file' || key === 'src') {
+            return normalizePath$4(path__default.relative(depsCacheDir, value));
+        }
         return value;
     }, 2);
 }
@@ -36068,6 +36079,26 @@ function getDepHash(root, config) {
     });
     return require$$1$1.createHash('sha256').update(content).digest('hex').substring(0, 8);
 }
+function optimizeDepInfoFromFile(metadata, file) {
+    return (findFileInfo(metadata.optimized, file) ||
+        findFileInfo(metadata.discovered, file));
+}
+function findFileInfo(dependenciesInfo, file) {
+    for (const o of Object.keys(dependenciesInfo)) {
+        const info = dependenciesInfo[o];
+        if (info.file === file) {
+            return info;
+        }
+    }
+}
+async function optimizedDepNeedsInterop(metadata, file) {
+    const depInfo = optimizeDepInfoFromFile(metadata, file);
+    if (!depInfo)
+        return undefined;
+    // Wait until the dependency has been pre-bundled
+    await depInfo.processing;
+    return depInfo === null || depInfo === void 0 ? void 0 : depInfo.needsInterop;
+}
 
 var index$1 = {
 	__proto__: null,
@@ -36081,7 +36112,9 @@ var index$1 = {
 	getDepsCacheDir: getDepsCacheDir,
 	getProcessingDepsCacheDir: getProcessingDepsCacheDir,
 	isOptimizedDepFile: isOptimizedDepFile,
-	createIsOptimizedDepUrl: createIsOptimizedDepUrl
+	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
+	optimizeDepInfoFromFile: optimizeDepInfoFromFile,
+	optimizedDepNeedsInterop: optimizedDepNeedsInterop
 };
 
 /**
@@ -36679,7 +36712,7 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
             // can cache it without re-validation, but only do so for known js types.
             // otherwise we may introduce duplicated modules for externalized files
             // from pre-bundled deps.
-            const versionHash = (_b = server._optimizeDepsMetadata) === null || _b === void 0 ? void 0 : _b.hash;
+            const versionHash = (_b = server._optimizeDepsMetadata) === null || _b === void 0 ? void 0 : _b.browserHash;
             if (versionHash && isJsType) {
                 resolved = injectQuery(resolved, `v=${versionHash}`);
             }
@@ -37207,7 +37240,12 @@ function assetImportMetaUrlPlugin(config) {
                     }
                     const url = rawUrl.slice(1, -1);
                     const file = path__default.resolve(path__default.dirname(id), url);
-                    const builtUrl = await fileToUrl(file, config, this);
+                    // Get final asset URL. Catch error if the file does not exist,
+                    // in which we can resort to the initial URL and let it resolve in runtime
+                    const builtUrl = await fileToUrl(file, config, this).catch(() => {
+                        config.logger.warnOnce(`\n${exp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
+                        return url;
+                    });
                     s.overwrite(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
                 }
                 if (s) {
@@ -43425,7 +43463,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-5f1b3f27.js'); })).createCertificate();
+        const content = (await Promise.resolve().then(function () { return require('./dep-1cf708c4.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -47657,7 +47695,8 @@ function createWebSocketServer(server, config, httpsOptions) {
     let wss;
     let httpsServer = undefined;
     const hmr = isObject$3(config.server.hmr) && config.server.hmr;
-    const wsServer = (hmr && hmr.server) || server;
+    const wsServer = (hmr && hmr.server) ||
+        ((!(hmr && hmr.port) || hmr.port !== config.server.port) && server);
     if (wsServer) {
         wss = new websocketServer({ noServer: true });
         wsServer.on('upgrade', (req, socket, head) => {
@@ -51294,16 +51333,66 @@ const debugCache$1 = createDebugger('vite:cache');
 const isDebug$3 = !!process.env.DEBUG;
 function transformRequest(url, server, options = {}) {
     const cacheKey = (options.ssr ? 'ssr:' : options.html ? 'html:' : '') + url;
-    let request = server._pendingRequests.get(cacheKey);
-    if (!request) {
-        request = doTransform(url, server, options);
-        server._pendingRequests.set(cacheKey, request);
-        const done = () => server._pendingRequests.delete(cacheKey);
-        request.then(done, done);
+    // This module may get invalidated while we are processing it. For example
+    // when a full page reload is needed after the re-processing of pre-bundled
+    // dependencies when a missing dep is discovered. We save the current time
+    // to compare it to the last invalidation performed to know if we should
+    // cache the result of the transformation or we should discard it as stale.
+    //
+    // A module can be invalidated due to:
+    // 1. A full reload because of pre-bundling newly discovered deps
+    // 2. A full reload after a config change
+    // 3. The file that generated the module changed
+    // 4. Invalidation for a virtual module
+    //
+    // For 1 and 2, a new request for this module will be issued after
+    // the invalidation as part of the browser reloading the page. For 3 and 4
+    // there may not be a new request right away because of HMR handling.
+    // In all cases, the next time this module is requested, it should be
+    // re-processed.
+    //
+    // We save the timestap when we start processing and compare it with the
+    // last time this module is invalidated
+    const timestamp = Date.now();
+    const pending = server._pendingRequests.get(cacheKey);
+    if (pending) {
+        return server.moduleGraph
+            .getModuleByUrl(removeTimestampQuery(url), options.ssr)
+            .then((module) => {
+            if (!module || pending.timestamp > module.lastInvalidationTimestamp) {
+                // The pending request is still valid, we can safely reuse its result
+                return pending.request;
+            }
+            else {
+                // Request 1 for module A     (pending.timestamp)
+                // Invalidate module A        (module.lastInvalidationTimestamp)
+                // Request 2 for module A     (timestamp)
+                // First request has been invalidated, abort it to clear the cache,
+                // then perform a new doTransform.
+                pending.abort();
+                return transformRequest(url, server, options);
+            }
+        });
     }
+    const request = doTransform(url, server, options, timestamp);
+    // Avoid clearing the cache of future requests if aborted
+    let cleared = false;
+    const clearCache = () => {
+        if (!cleared) {
+            server._pendingRequests.delete(cacheKey);
+            cleared = true;
+        }
+    };
+    // Cache the request and clear it once processing is done
+    server._pendingRequests.set(cacheKey, {
+        request,
+        timestamp,
+        abort: clearCache
+    });
+    request.then(clearCache, clearCache);
     return request;
 }
-async function doTransform(url, server, options) {
+async function doTransform(url, server, options, timestamp) {
     var _a, _b;
     url = removeTimestampQuery(url);
     const { config, pluginContainer, moduleGraph, watcher } = server;
@@ -51411,16 +51500,22 @@ async function doTransform(url, server, options) {
             await injectSourcesContent(map, mod.file, logger);
         }
     }
-    if (ssr) {
-        return (mod.ssrTransformResult = await ssrTransform(code, map, url));
-    }
-    else {
-        return (mod.transformResult = {
+    const result = ssr
+        ? await ssrTransform(code, map, url)
+        : {
             code,
             map,
             etag: etag_1(code, { weak: true })
-        });
+        };
+    // Only cache the result if the module wasn't invalidated while it was
+    // being processed, so it is re-processed next time if it is stale
+    if (timestamp > mod.lastInvalidationTimestamp) {
+        if (ssr)
+            mod.ssrTransformResult = result;
+        else
+            mod.transformResult = result;
     }
+    return result;
 }
 
 const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = 'ERR_OPTIMIZE_DEPS_PROCESSING_ERROR';
@@ -51443,6 +51538,7 @@ function optimizedDepsPlugin() {
                     const browserHash = versionMatch
                         ? versionMatch[1].split('=')[1]
                         : undefined;
+                    // Search in both the currently optimized and newly discovered deps
                     const info = optimizeDepInfoFromFile(metadata, file);
                     if (info) {
                         if (browserHash && info.browserHash !== browserHash) {
@@ -51499,18 +51595,6 @@ function throwOutdatedRequest(id) {
     // send a 504 status code request timeout
     throw err;
 }
-function optimizeDepInfoFromFile(metadata, file) {
-    return (findFileInfo(metadata.optimized, file) ||
-        findFileInfo(metadata.discovered, file));
-}
-function findFileInfo(dependenciesInfo, file) {
-    for (const o of Object.keys(dependenciesInfo)) {
-        const info = dependenciesInfo[o];
-        if (info.file === file) {
-            return info;
-        }
-    }
-}
 
 const debugCache = createDebugger('vite:cache');
 const isDebug$1 = !!process.env.DEBUG;
@@ -51633,8 +51717,8 @@ function transformMiddleware(server) {
         }
         catch (e) {
             if ((e === null || e === void 0 ? void 0 : e.code) === ERR_OPTIMIZE_DEPS_PROCESSING_ERROR) {
+                // Skip if response has already been sent
                 if (!res.writableEnded) {
-                    // Don't do anything if response has already been sent
                     res.statusCode = 504; // status code request timeout
                     res.end();
                 }
@@ -51643,8 +51727,8 @@ function transformMiddleware(server) {
                 return;
             }
             if ((e === null || e === void 0 ? void 0 : e.code) === ERR_OUTDATED_OPTIMIZED_DEP) {
+                // Skip if response has already been sent
                 if (!res.writableEnded) {
-                    // Don't do anything if response has already been sent
                     res.statusCode = 504; // status code request timeout
                     res.end();
                 }
@@ -51710,8 +51794,25 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
     const { config, moduleGraph } = server;
     const base = config.base || '/';
     const s = new MagicString(html);
-    let scriptModuleIndex = -1;
+    let inlineModuleIndex = -1;
     const filePath = cleanUrl(htmlPath);
+    const addInlineModule = (node, ext) => {
+        inlineModuleIndex++;
+        const url = filePath.replace(normalizePath$4(config.root), '');
+        const contents = node.children
+            .map((child) => child.content || '')
+            .join('');
+        // add HTML Proxy to Map
+        addToHTMLProxyCache(config, url, inlineModuleIndex, contents);
+        // inline js module. convert to src="proxy"
+        const modulePath = `${config.base + htmlPath.slice(1)}?html-proxy&index=${inlineModuleIndex}.${ext}`;
+        // invalidate the module so the newly cached contents will be served
+        const module = server === null || server === void 0 ? void 0 : server.moduleGraph.getModuleById(modulePath);
+        if (module) {
+            server === null || server === void 0 ? void 0 : server.moduleGraph.invalidateModule(module);
+        }
+        s.overwrite(node.loc.start.offset, node.loc.end.offset, `<script type="module" src="${modulePath}"></script>`);
+    };
     await traverseHtml(html, htmlPath, (node) => {
         if (node.type !== 1 /* ELEMENT */) {
             return;
@@ -51719,29 +51820,16 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
         // script tags
         if (node.tag === 'script') {
             const { src, isModule } = getScriptInfo(node);
-            if (isModule) {
-                scriptModuleIndex++;
-            }
             if (src) {
                 processNodeUrl(src, s, config, htmlPath, originalUrl, moduleGraph);
             }
             else if (isModule) {
-                const url = filePath.replace(normalizePath$4(config.root), '');
-                const contents = node.children
-                    .map((child) => child.content || '')
-                    .join('');
-                // add HTML Proxy to Map
-                addToHTMLProxyCache(config, url, scriptModuleIndex, contents);
-                // inline js module. convert to src="proxy"
-                const modulePath = `${config.base + htmlPath.slice(1)}?html-proxy&index=${scriptModuleIndex}.js`;
-                // invalidate the module so the newly cached contents will be served
-                const module = server === null || server === void 0 ? void 0 : server.moduleGraph.getModuleById(modulePath);
-                if (module) {
-                    server === null || server === void 0 ? void 0 : server.moduleGraph.invalidateModule(module);
-                }
-                s.overwrite(node.loc.start.offset, node.loc.end.offset, `<script type="module" src="${modulePath}"></script>`);
+                addInlineModule(node, 'js');
             }
         }
+        if (node.tag === 'style' && node.children.length) {
+            addInlineModule(node, 'css');
+        }
         // elements with [href/src] attrs
         const assetAttrs = assetAttrsConfig[node.tag];
         if (assetAttrs) {
@@ -51826,6 +51914,7 @@ class ModuleNode {
         this.ssrTransformResult = null;
         this.ssrModule = null;
         this.lastHMRTimestamp = 0;
+        this.lastInvalidationTimestamp = 0;
         this.url = url;
         this.type = isDirectCSSRequest(url) ? 'css' : 'js';
     }
@@ -51866,16 +51955,21 @@ class ModuleGraph {
             });
         }
     }
-    invalidateModule(mod, seen = new Set()) {
-        mod.info = undefined;
+    invalidateModule(mod, seen = new Set(), timestamp = Date.now()) {
+        // Save the timestamp for this invalidation, so we can avoid caching the result of possible already started
+        // processing being done for this module
+        mod.lastInvalidationTimestamp = timestamp;
+        // Don't invalidate mod.info and mod.meta, as they are part of the processing pipeline
+        // Invalidating the transform result is enough to ensure this module is re-processed next time it is requested
         mod.transformResult = null;
         mod.ssrTransformResult = null;
         invalidateSSRModule(mod, seen);
     }
     invalidateAll() {
+        const timestamp = Date.now();
         const seen = new Set();
         this.idToModuleMap.forEach((mod) => {
-            this.invalidateModule(mod, seen);
+            this.invalidateModule(mod, seen, timestamp);
         });
     }
     /**
@@ -54381,7 +54475,12 @@ function createMissingImporterRegisterFn(server) {
         });
         // All deps, previous known and newly discovered are rebundled,
         // respect insertion order to keep the metadata file stable
-        const newDeps = { ...metadata.optimized, ...metadata.discovered };
+        // Clone optimized info objects, fileHash, browserHash may be changed for them
+        const clonedOptimizedDeps = {};
+        for (const o of Object.keys(metadata.optimized)) {
+            clonedOptimizedDeps[o] = { ...metadata.optimized[o] };
+        }
+        const newDeps = { ...clonedOptimizedDeps, ...metadata.discovered };
         const thisDepOptimizationProcessing = depOptimizationProcessing;
         // Other rerun will await until this run is finished
         lastDepOptimizationPromise = thisDepOptimizationProcessing.promise;
@@ -54403,9 +54502,8 @@ function createMissingImporterRegisterFn(server) {
             // While optimizeDeps is running, new missing deps may be discovered,
             // in which case they will keep being added to metadata.discovered
             for (const o of Object.keys(metadata.discovered)) {
-                if (!newData.optimized[o] && !newData.discovered[o]) {
+                if (!newData.optimized[o]) {
                     newData.discovered[o] = metadata.discovered[o];
-                    delete metadata.discovered[o];
                 }
             }
             newData.processing = thisDepOptimizationProcessing.promise;
@@ -54614,6 +54712,9 @@ async function createServer(inlineConfig = {}) {
                 rebindErrorStacktrace(e, stacktrace);
             }
         },
+        ssrRewriteStacktrace(stack) {
+            return ssrRewriteStacktrace(stack, moduleGraph);
+        },
         listen(port, isRestart) {
             return startServer(server, port, isRestart);
         },
@@ -55556,19 +55657,19 @@ function importAnalysisPlugin(config) {
                     // rewrite
                     if (url !== specifier) {
                         let rewriteDone = false;
-                        if (isOptimizedDepFile(resolvedId, config)) {
-                            // for optimized cjs deps, support named imports by rewriting named
-                            // imports to const assignments.
-                            const optimizeDepsMetadata = server._optimizeDepsMetadata;
-                            const { optimized } = optimizeDepsMetadata;
+                        if (isOptimizedDepFile(resolvedId, config) &&
+                            !resolvedId.match(optimizedDepChunkRE)) {
+                            // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
+                            // internal optimized chunks don't need es interop and are excluded
                             // The browserHash in resolvedId could be stale in which case there will be a full
                             // page reload. We could return a 404 in that case but it is safe to return the request
                             const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                            const dep = Object.keys(optimized).find((k) => optimized[k].file === file);
-                            // Wait until the dependency has been pre-bundled
-                            dep && (await optimized[dep].processing);
-                            if (dep && optimized[dep].needsInterop) {
-                                debug$1(`${dep} needs interop`);
+                            const needsInterop = await optimizedDepNeedsInterop(server._optimizeDepsMetadata, file);
+                            if (needsInterop === undefined) {
+                                config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
+                            }
+                            else if (needsInterop) {
+                                debug$1(`${url} needs interop`);
                                 if (isDynamicImport) {
                                     // rewrite `import('package')` to expose the default directly
                                     str().overwrite(dynamicIndex, end + 1, `import('${url}').then(m => m.default && m.default.__esModule ? m.default : ({ ...m.default, default: m.default }))`);
@@ -56050,6 +56151,8 @@ function preAliasPlugin() {
     };
 }
 
+const nonJsRe = /\.(json)($|\?)/;
+const isNonJsRequest = (request) => nonJsRe.test(request);
 function definePlugin(config) {
     const isBuild = config.command === 'build';
     const processNodeEnv = {
@@ -56125,6 +56228,7 @@ function definePlugin(config) {
             // exclude html, css and static assets for performance
             isHTMLRequest(id) ||
                 isCSSRequest(id) ||
+                isNonJsRequest(id) ||
                 config.assetsInclude(id)) {
                 return;
             }

package/dist/node/cli.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('events');
-var index = require('./chunks/dep-429629d5.js');
+var index = require('./chunks/dep-62435a6f.js');
 var perf_hooks = require('perf_hooks');
 require('fs');
 require('path');
@@ -683,7 +683,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-429629d5.js'); }).then(function (n) { return n.index$1; });
+    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.index$1; });
     try {
         const server = await createServer({
             root,
@@ -732,7 +732,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 Promise.resolve().then(function () { return require('./chunks/dep-429629d5.js'); }).then(function (n) { return n.build$1; });
+    const { build } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.build$1; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -755,7 +755,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 Promise.resolve().then(function () { return require('./chunks/dep-429629d5.js'); }).then(function (n) { return n.index; });
+    const { optimizeDeps } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.index; });
     try {
         const config = await index.resolveConfig({
             root,
@@ -778,7 +778,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 Promise.resolve().then(function () { return require('./chunks/dep-429629d5.js'); }).then(function (n) { return n.preview$1; });
+    const { preview } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.preview$1; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -1130,7 +1130,7 @@ export declare class ModuleGraph {
     getModuleById(id: string): ModuleNode | undefined;
     getModulesByFile(file: string): Set<ModuleNode> | undefined;
     onFileChange(file: string): void;
-    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>): void;
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number): void;
     invalidateAll(): void;
     /**
      * Update the module graph based on a module's updated imports information
@@ -1164,6 +1164,7 @@ export declare class ModuleNode {
     ssrTransformResult: TransformResult | null;
     ssrModule: Record<string, any> | null;
     lastHMRTimestamp: number;
+    lastInvalidationTimestamp: number;
     constructor(url: string);
 }
 
@@ -2160,7 +2161,11 @@ export declare interface ViteDevServer {
         fixStacktrace?: boolean;
     }): Promise<Record<string, any>>;
     /**
-     * Fix ssr error stacktrace
+     * Returns a fixed version of the given stack
+     */
+    ssrRewriteStacktrace(stack: string): string;
+    /**
+     * Mutates the given SSR error by rewriting the stacktrace
      */
     ssrFixStacktrace(e: Error): void;
     /**

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./chunks/dep-429629d5.js');
+var index = require('./chunks/dep-62435a6f.js');
 require('fs');
 require('path');
 require('tty');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "2.9.0-beta.0",
+  "version": "2.9.0-beta.1",
   "license": "MIT",
   "author": "Evan You",
   "description": "Native-ESM powered web dev build tool",