vite 2.7.0-beta.4 → 2.7.0-beta.8

package/dist/node/chunks/{dep-6cab8e8a.js → dep-d87be5e9.js}

@@ -2961,7 +2961,7 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
 	src$2.exports = node$1.exports;
 }
 
-var debug$f = src$2.exports;
+var debug$g = src$2.exports;
 
 const DEFAULT_MAIN_FIELDS = [
     'module',
@@ -2988,9 +2988,15 @@ const FS_PREFIX = `/@fs/`;
  */
 const VALID_ID_PREFIX = `/@id/`;
 /**
- * Some Rollup plugins use ids that starts with the null byte \0 to avoid
- * collisions, but it is not permitted in import URLs so we have to replace
- * them.
+ * Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+ * module ID with `\0`, a convention from the rollup ecosystem.
+ * This prevents other plugins from trying to process the id (like node resolution),
+ * and core features like sourcemaps can use this info to differentiate between
+ * virtual modules and regular files.
+ * `\0` is not a permitted char in import URLs so we have to replace them during
+ * import analysis. The id will be decoded back before entering the plugins pipeline.
+ * These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+ * modules in the browser end up encoded as `/@id/__x00__{id}`
  */
 const NULL_BYTE_PLACEHOLDER = `__x00__`;
 const CLIENT_PUBLIC_PATH = `/@vite/client`;
@@ -3924,7 +3930,7 @@ function nestedResolveFrom(id, basedir, preserveSymlinks = false) {
 const filter$1 = process.env.VITE_DEBUG_FILTER;
 const DEBUG$1 = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-    const log = debug$f(namespace);
+    const log = debug$g(namespace);
     const { onlyWhenFocused } = options;
     const focus = typeof onlyWhenFocused === 'string' ? onlyWhenFocused : namespace;
     return (msg, ...args) => {
@@ -3958,7 +3964,8 @@ const externalRE = /^(https?:)?\/\//;
 const isExternalUrl = (url) => externalRE.test(url);
 const dataUrlRE = /^\s*data:/i;
 const isDataUrl = (url) => dataUrlRE.test(url);
-const virtualModuleRE = /virtual-module:.*/;
+const virtualModuleRE = /^virtual-module:.*/;
+const virtualModulePrefix = 'virtual-module:';
 const knownJsSrcRE = /\.((j|t)sx?|mjs|vue|marko|svelte|astro)($|\?)/;
 const isJSRequest = (url) => {
     url = cleanUrl(url);
@@ -3974,7 +3981,7 @@ const knownTsRE = /\.(ts|mts|cts|tsx)$/;
 const knownTsOutputRE = /\.(js|mjs|cjs|jsx)$/;
 const isTsRequest = (url) => knownTsRE.test(cleanUrl(url));
 const isPossibleTsOutput = (url) => knownTsOutputRE.test(cleanUrl(url));
-const getTsSrcPath = (filename) => filename.replace(/\.([cm])?(js)(x?)$/, '.$1ts$3');
+const getTsSrcPath = (filename) => filename.replace(/\.([cm])?(js)(x?)(\?|$)/, '.$1ts$3');
 const importQueryRE = /(\?|&)import=?(?:&|$)/;
 const internalPrefixes = [
     FS_PREFIX,
@@ -20385,7 +20392,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-9583e954.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-b192ffe4.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21090,7 +21097,7 @@ function buildImportAnalysisPlugin(config) {
                 }
                 // Differentiate CSS imports that use the default export from those that
                 // do not by injecting a ?used query - this allows us to avoid including
-                // the CSS string when unnecessary (esbuild has trouble treeshaking
+                // the CSS string when unnecessary (esbuild has trouble tree-shaking
                 // them)
                 if (specifier &&
                     isCSSRequest(specifier) &&
@@ -21350,7 +21357,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-ef63fa34.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-8fdf8f48.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -22299,7 +22306,7 @@ var TSConfckParseError = class extends Error {
   }
 };
 
-const debug$e = createDebugger('vite:esbuild');
+const debug$f = createDebugger('vite:esbuild');
 let server;
 async function transformWithEsbuild(code, filename, options, inMap) {
     var _a, _b, _c;
@@ -22389,7 +22396,7 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         };
     }
     catch (e) {
-        debug$e(`esbuild error with options used: `, resolvedOptions);
+        debug$f(`esbuild error with options used: `, resolvedOptions);
         // patch error information
         if (e.errors) {
             e.frame = '';
@@ -22434,7 +22441,15 @@ function esbuildPlugin(options = {}) {
 const rollupToEsbuildFormatMap = {
     es: 'esm',
     cjs: 'cjs',
-    iife: 'iife'
+    // passing `var Lib = (() => {})()` to esbuild with format = "iife"
+    // will turn it to `(() => { var Lib = (() => {})() })()`,
+    // so we remove the format config to tell esbuild not doing this
+    //
+    // although esbuild doesn't change format, there is still possibility
+    // that `{ treeShaking: true }` removes a top-level no-side-effect variable
+    // like: `var Lib = 1`, which becomes `` after esbuild transforming,
+    // but thankfully rollup does not do this optimization now
+    iife: undefined
 };
 const buildEsbuildPlugin = (config) => {
     return {
@@ -29940,6 +29955,126 @@ function resolve(pkg, entry='.', options={}) {
 	}
 }
 
+const isDebug$6 = process.env.DEBUG;
+const debug$e = createDebugger('vite:resolve-details', {
+    onlyWhenFocused: true
+});
+function invalidatePackageData(packageCache, pkgPath) {
+    packageCache.delete(pkgPath);
+    const pkgDir = path__default.dirname(pkgPath);
+    packageCache.forEach((pkg, cacheKey) => {
+        if (pkg.dir === pkgDir) {
+            packageCache.delete(cacheKey);
+        }
+    });
+}
+function resolvePackageData(id, basedir, preserveSymlinks = false, packageCache) {
+    let pkg;
+    let cacheKey;
+    if (packageCache) {
+        cacheKey = `${id}&${basedir}&${preserveSymlinks}`;
+        if ((pkg = packageCache.get(cacheKey))) {
+            return pkg;
+        }
+    }
+    let pkgPath;
+    try {
+        pkgPath = resolveFrom$3(`${id}/package.json`, basedir, preserveSymlinks);
+        pkg = loadPackageData(pkgPath, true, packageCache);
+        if (packageCache) {
+            packageCache.set(cacheKey, pkg);
+        }
+        return pkg;
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            isDebug$6 && debug$e(`Parsing failed: ${pkgPath}`);
+        }
+        // Ignore error for missing package.json
+        else if (e.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+    return null;
+}
+function loadPackageData(pkgPath, preserveSymlinks, packageCache) {
+    if (!preserveSymlinks) {
+        pkgPath = fs__default.realpathSync.native(pkgPath);
+    }
+    let cached;
+    if ((cached = packageCache === null || packageCache === void 0 ? void 0 : packageCache.get(pkgPath))) {
+        return cached;
+    }
+    const data = JSON.parse(fs__default.readFileSync(pkgPath, 'utf-8'));
+    const pkgDir = path__default.dirname(pkgPath);
+    const { sideEffects } = data;
+    let hasSideEffects;
+    if (typeof sideEffects === 'boolean') {
+        hasSideEffects = () => sideEffects;
+    }
+    else if (Array.isArray(sideEffects)) {
+        hasSideEffects = createFilter$1(sideEffects, null, { resolve: pkgDir });
+    }
+    else {
+        hasSideEffects = () => true;
+    }
+    const pkg = {
+        dir: pkgDir,
+        data,
+        hasSideEffects,
+        webResolvedImports: {},
+        nodeResolvedImports: {},
+        setResolvedCache(key, entry, targetWeb) {
+            if (targetWeb) {
+                pkg.webResolvedImports[key] = entry;
+            }
+            else {
+                pkg.nodeResolvedImports[key] = entry;
+            }
+        },
+        getResolvedCache(key, targetWeb) {
+            if (targetWeb) {
+                return pkg.webResolvedImports[key];
+            }
+            else {
+                return pkg.nodeResolvedImports[key];
+            }
+        }
+    };
+    packageCache === null || packageCache === void 0 ? void 0 : packageCache.set(pkgPath, pkg);
+    return pkg;
+}
+function watchPackageDataPlugin(config) {
+    const watchQueue = new Set();
+    let watchFile = (id) => {
+        watchQueue.add(id);
+    };
+    const { packageCache } = config;
+    const setPackageData = packageCache.set.bind(packageCache);
+    packageCache.set = (id, pkg) => {
+        if (id.endsWith('.json')) {
+            watchFile(id);
+        }
+        return setPackageData(id, pkg);
+    };
+    return {
+        name: 'vite:watch-package-data',
+        buildStart() {
+            watchFile = this.addWatchFile;
+            watchQueue.forEach(watchFile);
+            watchQueue.clear();
+        },
+        buildEnd() {
+            watchFile = (id) => watchQueue.add(id);
+        },
+        watchChange(id) {
+            if (id.endsWith('/package.json')) {
+                invalidatePackageData(packageCache, id);
+            }
+        }
+    };
+}
+
 // special id for paths marked with browser: false
 // https://github.com/defunctzombie/package-browser-field-spec#ignore-a-module
 const browserExternalId = '__vite-browser-external';
@@ -29974,12 +30109,11 @@ function resolvePlugin(baseOptions) {
                 isRequire,
                 isFromTsImporter: isTsRequest(importer !== null && importer !== void 0 ? importer : '')
             };
-            const preserveSymlinks = !!(server === null || server === void 0 ? void 0 : server.config.resolve.preserveSymlinks);
             let res;
             // explicit fs paths that starts with /@fs/*
             if (asSrc && id.startsWith(FS_PREFIX)) {
                 const fsPath = fsPathFromId(id);
-                res = tryFsResolve(fsPath, options, preserveSymlinks);
+                res = tryFsResolve(fsPath, options);
                 isDebug$5 && debug$d(`[@fs] ${source.cyan(id)} -> ${source.dim(res)}`);
                 // always return here even if res doesn't exist since /@fs/ is explicit
                 // if the file doesn't exist it should be a 404
@@ -29989,7 +30123,7 @@ function resolvePlugin(baseOptions) {
             // /foo -> /fs-root/foo
             if (asSrc && id.startsWith('/')) {
                 const fsPath = path__default.resolve(root, id.slice(1));
-                if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+                if ((res = tryFsResolve(fsPath, options))) {
                     isDebug$5 && debug$d(`[url] ${source.cyan(id)} -> ${source.dim(res)}`);
                     return res;
                 }
@@ -30011,10 +30145,10 @@ function resolvePlugin(baseOptions) {
                     }
                 }
                 if (targetWeb &&
-                    (res = tryResolveBrowserMapping(fsPath, importer, options, true, preserveSymlinks))) {
+                    (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
                     return res;
                 }
-                if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+                if ((res = tryFsResolve(fsPath, options))) {
                     isDebug$5 && debug$d(`[relative] ${source.cyan(id)} -> ${source.dim(res)}`);
                     const pkg = importer != null && idToPkgMap.get(importer);
                     if (pkg) {
@@ -30028,8 +30162,7 @@ function resolvePlugin(baseOptions) {
                 }
             }
             // absolute fs paths
-            if (path__default.isAbsolute(id) &&
-                (res = tryFsResolve(id, options, preserveSymlinks))) {
+            if (path__default.isAbsolute(id) && (res = tryFsResolve(id, options))) {
                 isDebug$5 && debug$d(`[fs] ${source.cyan(id)} -> ${source.dim(res)}`);
                 return res;
             }
@@ -30054,7 +30187,7 @@ function resolvePlugin(baseOptions) {
                     return res;
                 }
                 if (targetWeb &&
-                    (res = tryResolveBrowserMapping(id, importer, options, false, preserveSymlinks))) {
+                    (res = tryResolveBrowserMapping(id, importer, options, false))) {
                     return res;
                 }
                 if ((res = tryNodeResolve(id, importer, options, targetWeb, server, ssr))) {
@@ -30103,7 +30236,7 @@ function resolvePlugin(baseOptions) {
         }
     };
 }
-function tryFsResolve(fsPath, options, preserveSymlinks, tryIndex = true, targetWeb = true) {
+function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true) {
     let file = fsPath;
     let postfix = '';
     let postfixIndex = fsPath.indexOf('?');
@@ -30117,48 +30250,53 @@ function tryFsResolve(fsPath, options, preserveSymlinks, tryIndex = true, target
     let res;
     // if we fould postfix exist, we should first try resolving file with postfix. details see #4703.
     if (postfix &&
-        (res = tryResolveFile(fsPath, '', options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        (res = tryResolveFile(fsPath, '', options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
-    if ((res = tryResolveFile(file, postfix, options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+    if ((res = tryResolveFile(file, postfix, options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
     for (const ext of options.extensions || DEFAULT_EXTENSIONS$1) {
         if (postfix &&
-            (res = tryResolveFile(fsPath + ext, '', options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+            (res = tryResolveFile(fsPath + ext, '', options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
             return res;
         }
-        if ((res = tryResolveFile(file + ext, postfix, options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        if ((res = tryResolveFile(file + ext, postfix, options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
             return res;
         }
     }
     if (postfix &&
-        (res = tryResolveFile(fsPath, '', options, tryIndex, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        (res = tryResolveFile(fsPath, '', options, tryIndex, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
-    if ((res = tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+    if ((res = tryResolveFile(file, postfix, options, tryIndex, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
 }
-function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSymlinks, tryPrefix, skipPackageJson) {
+function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix, skipPackageJson) {
     // #2051 if we don't have read permission on a directory, existsSync() still
     // works and will result in massively slow subsequent checks (which are
     // unnecessary in the first place)
     if (isFileReadable(file)) {
         if (!fs__default.statSync(file).isDirectory()) {
-            return getRealPath(file, preserveSymlinks) + postfix;
+            return getRealPath(file, options.preserveSymlinks) + postfix;
         }
         else if (tryIndex) {
             if (!skipPackageJson) {
                 const pkgPath = file + '/package.json';
-                if (fs__default.existsSync(pkgPath)) {
+                try {
                     // path points to a node package
-                    const pkg = loadPackageData(pkgPath);
-                    const resolved = resolvePackageEntry(file, pkg, options, targetWeb, preserveSymlinks);
+                    const pkg = loadPackageData(pkgPath, options.preserveSymlinks);
+                    const resolved = resolvePackageEntry(file, pkg, targetWeb, options);
                     return resolved;
                 }
+                catch (e) {
+                    if (e.code !== 'ENOENT') {
+                        throw e;
+                    }
+                }
             }
-            const index = tryFsResolve(file + '/index', options, preserveSymlinks);
+            const index = tryFsResolve(file + '/index', options);
             if (index)
                 return index + postfix;
         }
@@ -30166,28 +30304,45 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSym
     const tryTsExtension = options.isFromTsImporter && isPossibleTsOutput(file);
     if (tryTsExtension) {
         const tsSrcPath = getTsSrcPath(file);
-        return tryResolveFile(tsSrcPath, postfix, options, tryIndex, targetWeb, preserveSymlinks, tryPrefix, skipPackageJson);
+        return tryResolveFile(tsSrcPath, postfix, options, tryIndex, targetWeb, tryPrefix, skipPackageJson);
     }
     if (tryPrefix) {
         const prefixed = `${path__default.dirname(file)}/${tryPrefix}${path__default.basename(file)}`;
-        return tryResolveFile(prefixed, postfix, options, tryIndex, targetWeb, preserveSymlinks);
+        return tryResolveFile(prefixed, postfix, options, tryIndex, targetWeb);
     }
 }
 const idToPkgMap = new Map();
 function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     var _a, _b, _c;
-    const { root, dedupe, isBuild } = options;
+    const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // split id by last '>' for nested selected packages, for example:
     // 'foo > bar > baz' => 'foo > bar' & 'baz'
     // 'foo'             => ''          & 'foo'
     const lastArrowIndex = id.lastIndexOf('>');
     const nestedRoot = id.substring(0, lastArrowIndex).trim();
     const nestedPath = id.substring(lastArrowIndex + 1).trim();
-    // check for deep import, e.g. "my-lib/foo"
-    const deepMatch = nestedPath.match(deepImportRE);
-    const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : nestedPath;
+    const possiblePkgIds = [];
+    for (let prevSlashIndex = -1;;) {
+        let slashIndex = nestedPath.indexOf('/', prevSlashIndex + 1);
+        if (slashIndex < 0) {
+            slashIndex = nestedPath.length;
+        }
+        const part = nestedPath.slice(prevSlashIndex + 1, (prevSlashIndex = slashIndex));
+        if (!part) {
+            break;
+        }
+        // Assume path parts with an extension are not package roots, except for the
+        // first path part (since periods are sadly allowed in package names).
+        // At the same time, skip the first path part if it begins with "@"
+        // (since "@foo/bar" should be treated as the top-level path).
+        if (possiblePkgIds.length ? path__default.extname(part) : part[0] === '@') {
+            continue;
+        }
+        const possiblePkgId = nestedPath.slice(0, slashIndex);
+        possiblePkgIds.push(possiblePkgId);
+    }
     let basedir;
-    if (dedupe && dedupe.includes(pkgId)) {
+    if (dedupe === null || dedupe === void 0 ? void 0 : dedupe.some((id) => possiblePkgIds.includes(id))) {
         basedir = root;
     }
     else if (importer &&
@@ -30200,15 +30355,39 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     }
     // nested node module, step-by-step resolve to the basedir of the nestedPath
     if (nestedRoot) {
-        basedir = nestedResolveFrom(nestedRoot, basedir, options.preserveSymlinks);
+        basedir = nestedResolveFrom(nestedRoot, basedir, preserveSymlinks);
     }
-    const pkg = resolvePackageData(pkgId, basedir, options.preserveSymlinks);
+    let pkg;
+    const pkgId = possiblePkgIds.reverse().find((pkgId) => {
+        pkg = resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
+        return pkg;
+    });
     if (!pkg) {
         return;
     }
-    let resolved = deepMatch
-        ? resolveDeepImport('.' + id.slice(pkgId.length), pkg, options, targetWeb, options.preserveSymlinks)
-        : resolvePackageEntry(id, pkg, options, targetWeb, options.preserveSymlinks);
+    let resolveId = resolvePackageEntry;
+    let unresolvedId = pkgId;
+    if (unresolvedId !== nestedPath) {
+        resolveId = resolveDeepImport;
+        unresolvedId = '.' + nestedPath.slice(pkgId.length);
+    }
+    let resolved;
+    try {
+        resolved = resolveId(unresolvedId, pkg, targetWeb, options);
+    }
+    catch (err) {
+        if (!options.tryEsmOnly) {
+            throw err;
+        }
+    }
+    if (!resolved && options.tryEsmOnly) {
+        resolved = resolveId(unresolvedId, pkg, targetWeb, {
+            ...options,
+            isRequire: false,
+            mainFields: DEFAULT_MAIN_FIELDS,
+            extensions: DEFAULT_EXTENSIONS$1
+        });
+    }
     if (!resolved) {
         return;
     }
@@ -30235,7 +30414,7 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
         if (!isJsType ||
             (importer === null || importer === void 0 ? void 0 : importer.includes('node_modules')) ||
             (exclude === null || exclude === void 0 ? void 0 : exclude.includes(pkgId)) ||
-            (exclude === null || exclude === void 0 ? void 0 : exclude.includes(id)) ||
+            (exclude === null || exclude === void 0 ? void 0 : exclude.includes(nestedPath)) ||
             SPECIAL_QUERY_RE.test(resolved) ||
             ssr) {
             // excluded from optimization
@@ -30298,61 +30477,7 @@ function tryOptimizedResolve(id, server, importer) {
         }
     }
 }
-const packageCache = new Map();
-function resolvePackageData(id, basedir, preserveSymlinks = false) {
-    const cacheKey = id + basedir;
-    if (packageCache.has(cacheKey)) {
-        return packageCache.get(cacheKey);
-    }
-    try {
-        const pkgPath = resolveFrom$3(`${id}/package.json`, basedir, preserveSymlinks);
-        return loadPackageData(pkgPath, cacheKey);
-    }
-    catch (e) {
-        isDebug$5 && debug$d(`${source.red(`[failed loading package.json]`)} ${id}`);
-    }
-}
-function loadPackageData(pkgPath, cacheKey = pkgPath) {
-    const data = JSON.parse(fs__default.readFileSync(pkgPath, 'utf-8'));
-    const pkgDir = path__default.dirname(pkgPath);
-    const { sideEffects } = data;
-    let hasSideEffects;
-    if (typeof sideEffects === 'boolean') {
-        hasSideEffects = () => sideEffects;
-    }
-    else if (Array.isArray(sideEffects)) {
-        hasSideEffects = createFilter$1(sideEffects, null, { resolve: pkgDir });
-    }
-    else {
-        hasSideEffects = () => true;
-    }
-    const pkg = {
-        dir: pkgDir,
-        data,
-        hasSideEffects,
-        webResolvedImports: {},
-        nodeResolvedImports: {},
-        setResolvedCache(key, entry, targetWeb) {
-            if (targetWeb) {
-                pkg.webResolvedImports[key] = entry;
-            }
-            else {
-                pkg.nodeResolvedImports[key] = entry;
-            }
-        },
-        getResolvedCache(key, targetWeb) {
-            if (targetWeb) {
-                return pkg.webResolvedImports[key];
-            }
-            else {
-                return pkg.nodeResolvedImports[key];
-            }
-        }
-    };
-    packageCache.set(cacheKey, pkg);
-    return pkg;
-}
-function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, options, targetWeb, preserveSymlinks = false) {
+function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, targetWeb, options) {
     var _a, _b;
     const cached = getResolvedCache('.', targetWeb);
     if (cached) {
@@ -30384,7 +30509,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
                     // the heuristics here is to actually read the browser entry when
                     // possible and check for hints of UMD. If it is UMD, prefer "module"
                     // instead; Otherwise, assume it's ESM and use it.
-                    const resolvedBrowserEntry = tryFsResolve(path__default.join(dir, browserEntry), options, preserveSymlinks);
+                    const resolvedBrowserEntry = tryFsResolve(path__default.join(dir, browserEntry), options);
                     if (resolvedBrowserEntry) {
                         const content = fs__default.readFileSync(resolvedBrowserEntry, 'utf-8');
                         if ((/typeof exports\s*==/.test(content) &&
@@ -30421,7 +30546,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             entryPoint = mapWithBrowserField(entryPoint, browserField) || entryPoint;
         }
         entryPoint = path__default.join(dir, entryPoint);
-        const resolvedEntryPoint = tryFsResolve(entryPoint, options, preserveSymlinks);
+        const resolvedEntryPoint = tryFsResolve(entryPoint, options);
         if (resolvedEntryPoint) {
             isDebug$5 &&
                 debug$d(`[package entry] ${source.cyan(id)} -> ${source.dim(resolvedEntryPoint)}`);
@@ -30455,7 +30580,7 @@ function resolveExports(pkg, key, options, targetWeb) {
         conditions
     });
 }
-function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolvedCache, dir, data }, options, targetWeb, preserveSymlinks) {
+function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolvedCache, dir, data }, targetWeb, options) {
     const cache = getResolvedCache(id, targetWeb);
     if (cache) {
         return cache;
@@ -30486,7 +30611,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
     if (relativeId) {
-        const resolved = tryFsResolve(path__default.join(dir, relativeId), options, preserveSymlinks, !exportsField, // try index only if no exports field
+        const resolved = tryFsResolve(path__default.join(dir, relativeId), options, !exportsField, // try index only if no exports field
         targetWeb);
         if (resolved) {
             isDebug$5 &&
@@ -30496,7 +30621,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
 }
-function tryResolveBrowserMapping(id, importer, options, isFilePath, preserveSymlinks) {
+function tryResolveBrowserMapping(id, importer, options, isFilePath) {
     let res;
     const pkg = importer && idToPkgMap.get(importer);
     if (pkg && isObject$3(pkg.data.browser)) {
@@ -30504,7 +30629,7 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, preserveSym
         const browserMappedPath = mapWithBrowserField(mapId, pkg.data.browser);
         if (browserMappedPath) {
             const fsPath = path__default.join(pkg.dir, browserMappedPath);
-            if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+            if ((res = tryFsResolve(fsPath, options))) {
                 isDebug$5 &&
                     debug$d(`[browser mapped] ${source.cyan(id)} -> ${source.dim(res)}`);
                 idToPkgMap.set(res, pkg);
@@ -42770,7 +42895,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
     return {
         name: 'vite:dep-scan',
         setup(build) {
-            const moduleScripts = {};
+            const localScripts = {};
             // external urls
             build.onResolve({ filter: externalRE }, ({ path }) => ({
                 path,
@@ -42781,12 +42906,17 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 path,
                 external: true
             }));
-            build.onResolve({ filter: virtualModuleRE }, async ({ path, importer }) => {
+            // local scripts (`<script>` in Svelte and `<script setup>` in Vue)
+            build.onResolve({ filter: virtualModuleRE }, ({ path }) => {
                 return {
-                    path,
-                    namespace: 'html'
+                    // strip prefix to get valid filesystem path so esbuild can resolve imports in the file
+                    path: path.replace(virtualModulePrefix, ''),
+                    namespace: 'local-script'
                 };
             });
+            build.onLoad({ filter: /.*/, namespace: 'local-script' }, ({ path }) => {
+                return localScripts[path];
+            });
             // html types: extract script contents -----------------------------------
             build.onResolve({ filter: htmlTypesRE }, async ({ path, importer }) => {
                 return {
@@ -42794,9 +42924,6 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     namespace: 'html'
                 };
             });
-            build.onLoad({ filter: virtualModuleRE, namespace: 'html' }, async ({ path }) => {
-                return moduleScripts[path];
-            });
             // extract scripts inside HTML-like files and treat it as a js module
             build.onLoad({ filter: htmlTypesRE, namespace: 'html' }, async ({ path }) => {
                 let raw = fs__default.readFileSync(path, 'utf-8');
@@ -42838,12 +42965,11 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                             (contextMatch[1] || contextMatch[2] || contextMatch[3]);
                         if ((path.endsWith('.vue') && setupRE.test(raw)) ||
                             (path.endsWith('.svelte') && context !== 'module')) {
-                            const id = `virtual-module:${path}`;
-                            moduleScripts[id] = {
+                            localScripts[path] = {
                                 loader,
                                 contents: content
                             };
-                            js += `import '${id}';\n`;
+                            js += `import '${virtualModulePrefix}${path}';\n`;
                         }
                         else {
                             js += content + '\n';
@@ -43163,11 +43289,12 @@ function resolveBuildOptions(root, raw) {
     let input;
     if ((_a = raw === null || raw === void 0 ? void 0 : raw.rollupOptions) === null || _a === void 0 ? void 0 : _a.input) {
         input = Array.isArray(raw.rollupOptions.input)
-            ? raw.rollupOptions.input.map(input => resolve(input))
+            ? raw.rollupOptions.input.map((input) => resolve(input))
             : typeof raw.rollupOptions.input === 'object'
-                ? Object.assign(
-                // @ts-ignore
-                ...Object.keys(raw.rollupOptions.input).map(key => ({ [key]: resolve(raw.rollupOptions.input[key]) })))
+                ? Object.fromEntries(Object.entries(raw.rollupOptions.input).map(([key, value]) => [
+                    key,
+                    resolve(value)
+                ]))
                 : resolve(raw.rollupOptions.input);
     }
     else {
@@ -43214,6 +43341,7 @@ function resolveBuildPlugins(config) {
     const options = config.build;
     return {
         pre: [
+            watchPackageDataPlugin(config),
             buildHtmlPlugin(config),
             commonjs(options.commonjsOptions),
             dataURIPlugin(),
@@ -49325,7 +49453,7 @@ function readFileIfExists(value) {
  * https://github.com/webpack/webpack-dev-server/blob/master/LICENSE
  */
 async function createCertificate() {
-    const { generate } = await Promise.resolve().then(function () { return require('./dep-90234190.js'); }).then(function (n) { return n.index; });
+    const { generate } = await Promise.resolve().then(function () { return require('./dep-03d6dbab.js'); }).then(function (n) { return n.index; });
     const pems = generate(null, {
         algorithm: 'sha256',
         days: 30,
@@ -56506,16 +56634,20 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                 // so that we don't prefix them
                 node.params.forEach((p) => walk$1(p.type === 'AssignmentPattern' ? p.left : p, {
                     enter(child, parent) {
-                        if (child.type === 'Identifier' &&
-                            // do not record as scope variable if is a destructuring key
-                            !isStaticPropertyKey(child, parent) &&
-                            // do not record if this is a default value
-                            // assignment of a destructuring variable
-                            !(parent &&
-                                parent.type === 'AssignmentPattern' &&
-                                parent.right === child)) {
-                            setScope(node, child.name);
+                        if (child.type !== 'Identifier')
+                            return;
+                        // do not record as scope variable if is a destructuring keyword
+                        if (isStaticPropertyKey(child, parent))
+                            return;
+                        // do not record if this is a default value
+                        // assignment of a destructuring variable
+                        if (((parent === null || parent === void 0 ? void 0 : parent.type) === 'AssignmentPattern' &&
+                            (parent === null || parent === void 0 ? void 0 : parent.right) === child) ||
+                            ((parent === null || parent === void 0 ? void 0 : parent.type) === 'TemplateLiteral' &&
+                                (parent === null || parent === void 0 ? void 0 : parent.expressions.includes(child)))) {
+                            return;
                         }
+                        setScope(node, child.name);
                     }
                 }));
             }
@@ -56535,6 +56667,11 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                             }
                         });
                     }
+                    else if (node.id.type === 'ArrayPattern') {
+                        node.id.elements.forEach((element) => {
+                            setScope(parentFunction, element.name);
+                        });
+                    }
                     else {
                         setScope(parentFunction, node.id.name);
                     }
@@ -57731,7 +57868,7 @@ async function handleHMRUpdate(file, server) {
         // auto restart server
         debugHmr(`[config change] ${source.dim(shortFile)}`);
         config.logger.info(source.green(`${path__default.relative(process.cwd(), file)} changed, restarting server...`), { clear: true, timestamp: true });
-        await restartServer(server);
+        await server.restart();
         return;
     }
     debugHmr(`[file change] ${source.dim(shortFile)}`);
@@ -58074,34 +58211,6 @@ async function readModifiedFile(file) {
         return content;
     }
 }
-async function restartServer(server) {
-    // @ts-ignore
-    global.__vite_start_time = perf_hooks.performance.now();
-    const { port } = server.config.server;
-    await server.close();
-    let newServer = null;
-    try {
-        newServer = await createServer(server.config.inlineConfig);
-    }
-    catch (err) {
-        server.config.logger.error(err.message, {
-            timestamp: true
-        });
-        return;
-    }
-    for (const key in newServer) {
-        if (key !== 'app') {
-            // @ts-ignore
-            server[key] = newServer[key];
-        }
-    }
-    if (!server.config.server.middlewareMode) {
-        await server.listen(port, true);
-    }
-    else {
-        server.config.logger.info('server restarted.', { timestamp: true });
-    }
-}
 
 var isWsl$2 = {exports: {}};
 
@@ -66959,7 +67068,9 @@ function rebindErrorStacktrace(e, stacktrace) {
  */
 function ssrRequireHookPlugin(config) {
     var _a;
-    if (config.command !== 'build' || !((_a = config.resolve.dedupe) === null || _a === void 0 ? void 0 : _a.length)) {
+    if (config.command !== 'build' ||
+        !((_a = config.resolve.dedupe) === null || _a === void 0 ? void 0 : _a.length) ||
+        isBuildOutputEsm(config)) {
         return null;
     }
     return {
@@ -67003,6 +67114,11 @@ function hookNodeResolve(getResolver) {
         Module._resolveFilename = prevResolver;
     };
 }
+function isBuildOutputEsm(config) {
+    var _a;
+    const outputs = arraify((_a = config.build.rollupOptions) === null || _a === void 0 ? void 0 : _a.output);
+    return outputs.some((output) => (output === null || output === void 0 ? void 0 : output.format) === 'es' || (output === null || output === void 0 ? void 0 : output.format) === 'esm');
+}
 
 const pendingModules = new Map();
 const pendingImports = new Map();
@@ -67052,17 +67168,18 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
-    const { isProduction, resolve: { dedupe }, root } = server.config;
+    const { isProduction, resolve: { dedupe, preserveSymlinks }, root } = server.config;
+    // The `extensions` and `mainFields` options are used to ensure that
+    // CommonJS modules are preferred. We want to avoid ESM->ESM imports
+    // whenever possible, because `hookNodeResolve` can't intercept them.
     const resolveOptions = {
-        conditions: ['node'],
         dedupe,
-        // Prefer CommonJS modules.
-        extensions: ['.js', '.mjs', '.ts', '.jsx', '.tsx', '.json'],
+        extensions: ['.js', '.cjs', '.json'],
         isBuild: true,
         isProduction,
-        // Disable "module" condition.
         isRequire: true,
         mainFields: ['main'],
+        preserveSymlinks,
         root
     };
     // Since dynamic imports can happen in parallel, we need to
@@ -67134,8 +67251,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
 async function nodeImport(id, importer, resolveOptions) {
     // Node's module resolution is hi-jacked so Vite can ensure the
     // configured `resolve.dedupe` and `mode` options are respected.
-    const viteResolve = (id, importer) => {
-        const resolved = tryNodeResolve(id, importer, resolveOptions, false);
+    const viteResolve = (id, importer, options = resolveOptions) => {
+        const resolved = tryNodeResolve(id, importer, options, false);
         if (!resolved) {
             const err = new Error(`Cannot find module '${id}' imported from '${importer}'`);
             err.code = 'ERR_MODULE_NOT_FOUND';
@@ -67144,16 +67261,29 @@ async function nodeImport(id, importer, resolveOptions) {
         return resolved.id;
     };
     // When an ESM module imports an ESM dependency, this hook is *not* used.
-    const unhookNodeResolve = hookNodeResolve((nodeResolve) => (id, parent, isMain, options) => id[0] === '.' || isBuiltin(id)
-        ? nodeResolve(id, parent, isMain, options)
-        : viteResolve(id, parent.id));
+    const unhookNodeResolve = hookNodeResolve((nodeResolve) => (id, parent, isMain, options) => {
+        if (id[0] === '.' || isBuiltin(id)) {
+            return nodeResolve(id, parent, isMain, options);
+        }
+        if (parent) {
+            return viteResolve(id, parent.id);
+        }
+        // Importing a CJS module from an ESM module. In this case, the import
+        // specifier is already an absolute path, so this is a no-op.
+        // Options like `resolve.dedupe` and `mode` are not respected.
+        return id;
+    });
     let url;
-    // `resolve` doesn't handle `node:` builtins, so handle them directly
     if (id.startsWith('node:') || isBuiltin(id)) {
         url = id;
     }
     else {
-        url = viteResolve(id, importer);
+        url = viteResolve(id, importer, 
+        // Non-external modules can import ESM-only modules, but only outside
+        // of test runs, because we use Node `require` in Jest to avoid segfault.
+        typeof jest === 'undefined'
+            ? { ...resolveOptions, tryEsmOnly: true }
+            : resolveOptions);
         if (usingDynamicImport) {
             url = require$$0$7.pathToFileURL(url).toString();
         }
@@ -67390,9 +67520,21 @@ async function createServer(inlineConfig = {}) {
                 throw new Error('cannot print server URLs in middleware mode.');
             }
         },
+        async restart(forceOptimize) {
+            if (!server._restartPromise) {
+                server._forceOptimizeOnRestart = !!forceOptimize;
+                server._restartPromise = restartServer(server).finally(() => {
+                    server._restartPromise = null;
+                    server._forceOptimizeOnRestart = false;
+                });
+            }
+            return server._restartPromise;
+        },
         _optimizeDepsMetadata: null,
         _ssrExternals: null,
         _globImporters: Object.create(null),
+        _restartPromise: null,
+        _forceOptimizeOnRestart: false,
         _isRunningOptimizer: false,
         _registerMissingImport: null,
         _pendingReload: null,
@@ -67411,8 +67553,19 @@ async function createServer(inlineConfig = {}) {
     if (!middlewareMode && process.env.CI !== 'true') {
         process.stdin.on('end', exitProcess);
     }
+    const { packageCache } = config;
+    const setPackageData = packageCache.set.bind(packageCache);
+    packageCache.set = (id, pkg) => {
+        if (id.endsWith('.json')) {
+            watcher.add(id);
+        }
+        return setPackageData(id, pkg);
+    };
     watcher.on('change', async (file) => {
         file = normalizePath$4(file);
+        if (file.endsWith('/package.json')) {
+            return invalidatePackageData(packageCache, file);
+        }
         // invalidate module graph cache on file change
         moduleGraph.onFileChange(file);
         if (serverConfig.hmr !== false) {
@@ -67507,7 +67660,7 @@ async function createServer(inlineConfig = {}) {
         if (config.cacheDir) {
             server._isRunningOptimizer = true;
             try {
-                server._optimizeDepsMetadata = await optimizeDeps(config);
+                server._optimizeDepsMetadata = await optimizeDeps(config, config.server.force || server._forceOptimizeOnRestart);
             }
             finally {
                 server._isRunningOptimizer = false;
@@ -67636,6 +67789,34 @@ function resolveServerOptions(root, raw) {
     };
     return server;
 }
+async function restartServer(server) {
+    // @ts-ignore
+    global.__vite_start_time = perf_hooks.performance.now();
+    const { port } = server.config.server;
+    await server.close();
+    let newServer = null;
+    try {
+        newServer = await createServer(server.config.inlineConfig);
+    }
+    catch (err) {
+        server.config.logger.error(err.message, {
+            timestamp: true
+        });
+        return;
+    }
+    for (const key in newServer) {
+        if (key !== 'app') {
+            // @ts-ignore
+            server[key] = newServer[key];
+        }
+    }
+    if (!server.config.server.middlewareMode) {
+        await server.listen(port, true);
+    }
+    else {
+        server.config.logger.info('server restarted.', { timestamp: true });
+    }
+}
 
 var index = {
 	__proto__: null,
@@ -80871,6 +81052,12 @@ function importAnalysisPlugin(config) {
                 if (pluginImports) {
                     (await Promise.all([...pluginImports].map((id) => normalizeUrl(id, 0)))).forEach(([url]) => importedUrls.add(url));
                 }
+                // HMR transforms are no-ops in SSR, so an `accept` call will
+                // never be injected. Avoid updating the `isSelfAccepting`
+                // property for our module node in that case.
+                if (ssr && importerModule.isSelfAccepting) {
+                    isSelfAccepting = true;
+                }
                 const prunedImports = await moduleGraph.updateModuleInfo(importerModule, importedUrls, normalizedAcceptedUrls, isSelfAccepting);
                 if (hasHMR && prunedImports) {
                     handlePrunedModules(prunedImports, server);
@@ -80931,11 +81118,14 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
         ecmaVersion: 'latest',
         sourceType: 'module'
     }).body[0];
-    if (node.type === 'ImportDeclaration') {
+    if (node.type === 'ImportDeclaration' ||
+        node.type === 'ExportNamedDeclaration') {
         if (!node.specifiers.length) {
             return `import "${url}"`;
         }
         const importNames = [];
+        const exportNames = [];
+        let defaultExports = '';
         for (const spec of node.specifiers) {
             if (spec.type === 'ImportSpecifier' &&
                 spec.imported.type === 'Identifier') {
@@ -80952,6 +81142,21 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
             else if (spec.type === 'ImportNamespaceSpecifier') {
                 importNames.push({ importedName: '*', localName: spec.local.name });
             }
+            else if (spec.type === 'ExportSpecifier' &&
+                spec.exported.type === 'Identifier') {
+                // for ExportSpecifier, local name is same as imported name
+                const importedName = spec.local.name;
+                // we want to specify exported name as variable and re-export it
+                const exportedName = spec.exported.name;
+                if (exportedName === 'default') {
+                    defaultExports = makeLegalIdentifier$1(`__vite__cjsExportDefault_${importIndex}`);
+                    importNames.push({ importedName, localName: defaultExports });
+                }
+                else {
+                    importNames.push({ importedName, localName: exportedName });
+                    exportNames.push(exportedName);
+                }
+            }
         }
         // If there is multiple import for same id in one file,
         // importIndex will prevent the cjsModuleName to be duplicate
@@ -80968,6 +81173,12 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
                 lines.push(`const ${localName} = ${cjsModuleName}["${importedName}"]`);
             }
         });
+        if (defaultExports) {
+            lines.push(`export default ${defaultExports}`);
+        }
+        if (exportNames.length) {
+            lines.push(`export { ${exportNames.join(', ')} }`);
+        }
         return lines.join('; ');
     }
 }
@@ -81325,6 +81536,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             root: config.root,
             isProduction: config.isProduction,
             isBuild,
+            packageCache: config.packageCache,
             ssrConfig: config.ssr,
             asSrc: true
         }),
@@ -81701,6 +81913,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             return DEFAULT_ASSETS_RE.test(file) || assetsFilter(file);
         },
         logger,
+        packageCache: new Map(),
         createResolver,
         optimizeDeps: {
             ...config.optimizeDeps,
@@ -81996,8 +82209,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         if (!userConfig) {
             // 2. if we reach here, the file is ts or using es import syntax, or
             // the user has type: "module" in their package.json (#917)
-            // transpile es import syntax to require syntax using rollup.
-            // lazy require rollup (it's actually in dependencies)
+            // transpile es import syntax to require syntax using esbuild.
             const bundled = await bundleConfigFile(resolvedPath);
             dependencies = bundled.dependencies;
             userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code);
@@ -82168,4 +82380,4 @@ exports.send = send$1;
 exports.sortUserPlugins = sortUserPlugins;
 exports.source = source;
 exports.transformWithEsbuild = transformWithEsbuild;
-//# sourceMappingURL=dep-6cab8e8a.js.map
+//# sourceMappingURL=dep-d87be5e9.js.map