vite 2.7.0-beta.2 → 2.7.0-beta.6

package/dist/node/chunks/{dep-caa1572d.js → dep-0183a921.js}

@@ -10,7 +10,7 @@ var require$$0$a = require('events');
 var require$$0$7 = require('url');
 var require$$1$2 = require('http');
 var require$$0$9 = require('stream');
-var resolve$4 = require('resolve');
+var resolve$3 = require('resolve');
 var require$$0$6 = require('module');
 var perf_hooks = require('perf_hooks');
 var require$$1$3 = require('https');
@@ -50,7 +50,7 @@ var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$a);
 var require$$0__default$6 = /*#__PURE__*/_interopDefaultLegacy(require$$0$7);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
 var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$9);
-var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve$4);
+var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve$3);
 var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
 var require$$1__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$1$3);
 var require$$0__default$7 = /*#__PURE__*/_interopDefaultLegacy(require$$0$8);
@@ -3387,7 +3387,7 @@ function normalizePath$5(input) {
 /**
  * Attempts to resolve `input` URL relative to `base`.
  */
-function resolve$3(input, base) {
+function resolve$2(input, base) {
     if (!base)
         base = '';
     // Absolute URLs are very easy to resolve right.
@@ -3455,7 +3455,7 @@ function resolve$1$1(input, base) {
     // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
     if (base && !base.endsWith('/'))
         base += '/';
-    return resolve$3(input, base);
+    return resolve$2(input, base);
 }
 
 /**
@@ -3958,6 +3958,7 @@ 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 knownJsSrcRE = /\.((j|t)sx?|mjs|vue|marko|svelte|astro)($|\?)/;
 const isJSRequest = (url) => {
     url = cleanUrl(url);
@@ -3973,7 +3974,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,
@@ -4276,9 +4277,6 @@ function combineSourcemaps(filename, sourcemapList) {
     }
     return map;
 }
-function unique(arr) {
-    return Array.from(new Set(arr));
-}
 function resolveHostname(optionsHost) {
     let host;
     if (optionsHost === undefined ||
@@ -4349,9 +4347,8 @@ function createLogger(level = 'info', options = {}) {
     const loggedErrors = new WeakSet();
     const { prefix = '[vite]', allowClearScreen = true } = options;
     const thresh = LogLevels[level];
-    const clear = allowClearScreen && process.stdout.isTTY && !process.env.CI
-        ? clearScreen
-        : () => { };
+    const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+    const clear = canClearScreen ? clearScreen : () => { };
     function output(type, msg, options = {}) {
         if (thresh >= LogLevels[type]) {
             const method = type === 'info' ? 'log' : type;
@@ -4371,18 +4368,23 @@ function createLogger(level = 'info', options = {}) {
             if (options.error) {
                 loggedErrors.add(options.error);
             }
-            if (type === lastType && msg === lastMsg) {
-                sameCount++;
-                clear();
-                console[method](format(), source.yellow(`(x${sameCount + 1})`));
-            }
-            else {
-                sameCount = 0;
-                lastMsg = msg;
-                lastType = type;
-                if (options.clear) {
+            if (canClearScreen) {
+                if (type === lastType && msg === lastMsg) {
+                    sameCount++;
                     clear();
+                    console[method](format(), source.yellow(`(x${sameCount + 1})`));
+                }
+                else {
+                    sameCount = 0;
+                    lastMsg = msg;
+                    lastType = type;
+                    if (options.clear) {
+                        clear();
+                    }
+                    console[method](format());
                 }
+            }
+            else {
                 console[method](format());
             }
         }
@@ -19605,7 +19607,7 @@ const plugins = (config, file) => {
 
 var plugins_1 = plugins;
 
-const resolve$2 = path__default.resolve;
+const resolve$1 = path__default.resolve;
 
 const config$1 = dist$2;
 const yaml = yaml$1;
@@ -19744,7 +19746,7 @@ const rc = withTypeScriptLoader((ctx, path, options) => {
   /**
    * @type {String} `process.cwd()`
    */
-  path = path ? resolve$2(path) : process.cwd();
+  path = path ? resolve$1(path) : process.cwd();
 
   return config$1.lilconfig('postcss', options)
     .search(path)
@@ -19766,7 +19768,7 @@ rc.sync = withTypeScriptLoader((ctx, path, options) => {
   /**
    * @type {String} `process.cwd()`
    */
-  path = path ? resolve$2(path) : process.cwd();
+  path = path ? resolve$1(path) : process.cwd();
 
   const result = config$1.lilconfigSync('postcss', options).search(path);
 
@@ -20383,7 +20385,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-e85c9ca9.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-48461e78.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21348,7 +21350,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-b89007db.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-1b2328e8.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -27628,7 +27630,7 @@ function getRequireStringArg(node) {
 function hasDynamicModuleForPath(source, id, dynamicRequireModuleSet) {
   if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
     try {
-      const resolvedPath = normalizePathSlashes(resolve$4.sync(source, { basedir: path$t.dirname(id) }));
+      const resolvedPath = normalizePathSlashes(resolve$3.sync(source, { basedir: path$t.dirname(id) }));
       if (dynamicRequireModuleSet.has(resolvedPath)) {
         return true;
       }
@@ -29883,7 +29885,7 @@ function toName(name, entry) {
  * @param {string[]} [options.conditions]
  * @param {boolean} [options.unsafe]
  */
-function resolve$1(pkg, entry='.', options={}) {
+function resolve(pkg, entry='.', options={}) {
 	let { name, exports } = pkg;
 
 	if (exports) {
@@ -29972,12 +29974,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
@@ -29987,7 +29988,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;
                 }
@@ -30009,10 +30010,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) {
@@ -30026,8 +30027,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;
             }
@@ -30052,7 +30052,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))) {
@@ -30101,7 +30101,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('?');
@@ -30115,36 +30115,36 @@ 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) {
@@ -30152,11 +30152,11 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSym
                 if (fs__default.existsSync(pkgPath)) {
                     // path points to a node package
                     const pkg = loadPackageData(pkgPath);
-                    const resolved = resolvePackageEntry(file, pkg, options, targetWeb, preserveSymlinks);
+                    const resolved = resolvePackageEntry(file, pkg, targetWeb, options);
                     return resolved;
                 }
             }
-            const index = tryFsResolve(file + '/index', options, preserveSymlinks);
+            const index = tryFsResolve(file + '/index', options);
             if (index)
                 return index + postfix;
         }
@@ -30164,11 +30164,11 @@ 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();
@@ -30181,11 +30181,28 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     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 &&
@@ -30196,18 +30213,41 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     else {
         basedir = root;
     }
-    const preserveSymlinks = !!(server === null || server === void 0 ? void 0 : server.config.resolve.preserveSymlinks);
     // nested node module, step-by-step resolve to the basedir of the nestedPath
     if (nestedRoot) {
-        basedir = nestedResolveFrom(nestedRoot, basedir, preserveSymlinks);
+        basedir = nestedResolveFrom(nestedRoot, basedir, options.preserveSymlinks);
     }
-    const pkg = resolvePackageData(pkgId, basedir, preserveSymlinks);
+    let pkg;
+    const pkgId = possiblePkgIds.reverse().find((pkgId) => {
+        pkg = resolvePackageData(pkgId, basedir, options.preserveSymlinks);
+        return pkg;
+    });
     if (!pkg) {
         return;
     }
-    let resolved = deepMatch
-        ? resolveDeepImport('.' + id.slice(pkgId.length), pkg, options, targetWeb, preserveSymlinks)
-        : resolvePackageEntry(id, pkg, options, targetWeb, 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;
     }
@@ -30234,7 +30274,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
@@ -30351,7 +30391,7 @@ function loadPackageData(pkgPath, cacheKey = pkgPath) {
     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) {
@@ -30383,7 +30423,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) &&
@@ -30420,7 +30460,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)}`);
@@ -30448,13 +30488,13 @@ function resolveExports(pkg, key, options, targetWeb) {
     if (options.conditions) {
         conditions.push(...options.conditions);
     }
-    return resolve$1(pkg, key, {
+    return resolve(pkg, key, {
         browser: targetWeb,
         require: options.isRequire,
         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;
@@ -30485,7 +30525,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 &&
@@ -30495,7 +30535,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)) {
@@ -30503,7 +30543,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);
@@ -30553,97 +30593,117 @@ const debug$c = createDebugger('vite:ssr-external');
  * Heuristics for determining whether a dependency should be externalized for
  * server-side rendering.
  */
-function resolveSSRExternal(config, knownImports, ssrExternals = new Set(), seen = new Set()) {
-    var _a, _b, _c, _d;
-    if (((_a = config.ssr) === null || _a === void 0 ? void 0 : _a.noExternal) === true) {
+function resolveSSRExternal(config, knownImports) {
+    var _a;
+    const ssrConfig = config.ssr;
+    if ((ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.noExternal) === true) {
         return [];
     }
-    const { root } = config;
+    const ssrExternals = new Set();
+    const seen = new Set();
+    (_a = ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.external) === null || _a === void 0 ? void 0 : _a.forEach((id) => {
+        ssrExternals.add(id);
+        seen.add(id);
+    });
+    collectExternals(config.root, config.resolve.preserveSymlinks, ssrExternals, seen);
+    const importedDeps = knownImports.map(getNpmPackageName).filter(isDefined);
+    for (const dep of importedDeps) {
+        // Assume external if not yet seen
+        // At this point, the project root and any linked packages have had their dependencies checked,
+        // so we can safely mark any knownImports not yet seen as external. They are guaranteed to be
+        // dependencies of packages in node_modules.
+        if (!seen.has(dep)) {
+            ssrExternals.add(dep);
+        }
+    }
+    // ensure `vite/dynamic-import-polyfill` is bundled (issue #1865)
+    ssrExternals.delete('vite');
+    let externals = [...ssrExternals];
+    if (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.noExternal) {
+        externals = externals.filter(createFilter$1(undefined, ssrConfig.noExternal, { resolve: false }));
+    }
+    return externals;
+}
+// do we need to do this ahead of time or could we do it lazily?
+function collectExternals(root, preserveSymlinks, ssrExternals, seen) {
+    var _a;
     const pkgContent = lookupFile(root, ['package.json']);
     if (!pkgContent) {
-        return [];
+        return;
     }
     const pkg = JSON.parse(pkgContent);
-    const importedDeps = knownImports.map(getNpmPackageName).filter(isDefined);
-    const deps = unique([
-        ...importedDeps,
-        ...Object.keys(pkg.devDependencies || {}),
-        ...Object.keys(pkg.dependencies || {})
-    ]);
+    const deps = {
+        ...pkg.devDependencies,
+        ...pkg.dependencies
+    };
     const resolveOptions = {
         root,
+        preserveSymlinks,
         isProduction: false,
         isBuild: true
     };
     const depsToTrace = new Set();
-    for (const id of deps) {
-        if (seen.has(id)) {
+    for (const id in deps) {
+        if (seen.has(id))
             continue;
-        }
         seen.add(id);
-        let entry;
+        let esmEntry;
         let requireEntry;
         try {
-            entry = (_b = tryNodeResolve(id, undefined, resolveOptions, true, undefined, true)) === null || _b === void 0 ? void 0 : _b.id;
+            esmEntry = (_a = tryNodeResolve(id, undefined, resolveOptions, true, // we set `targetWeb` to `true` to get the ESM entry
+            undefined, true)) === null || _a === void 0 ? void 0 : _a.id;
             // normalizePath required for windows. tryNodeResolve uses normalizePath
             // which returns with '/', require.resolve returns with '\\'
             requireEntry = normalizePath$4(require.resolve(id, { paths: [root] }));
         }
         catch (e) {
+            try {
+                // no main entry, but deep imports may be allowed
+                const pkgPath = resolveFrom$3(`${id}/package.json`, root);
+                if (pkgPath.includes('node_modules')) {
+                    ssrExternals.add(id);
+                }
+                else {
+                    depsToTrace.add(path__default.dirname(pkgPath));
+                }
+                continue;
+            }
+            catch { }
             // resolve failed, assume include
             debug$c(`Failed to resolve entries for package "${id}"\n`, e);
             continue;
         }
-        if (!entry) {
-            // no esm entry but has require entry (is this even possible?)
+        // no esm entry but has require entry
+        if (!esmEntry) {
             ssrExternals.add(id);
-            continue;
         }
-        if (!entry.includes('node_modules')) {
-            // entry is not a node dep, possibly linked - don't externalize
-            // instead, trace its dependencies.
-            depsToTrace.add(id);
-            continue;
+        // trace the dependencies of linked packages
+        else if (!esmEntry.includes('node_modules')) {
+            const pkgPath = resolveFrom$3(`${id}/package.json`, root);
+            depsToTrace.add(path__default.dirname(pkgPath));
         }
-        if (entry !== requireEntry) {
-            // has separate esm/require entry, assume require entry is cjs
+        // has separate esm/require entry, assume require entry is cjs
+        else if (esmEntry !== requireEntry) {
             ssrExternals.add(id);
         }
-        else {
-            // node resolve and esm resolve resolves to the same file.
-            if (!/\.m?js$/.test(entry)) {
-                // entry is not js, cannot externalize
-                continue;
-            }
-            if (pkg.type === 'module' || entry.endsWith('.mjs')) {
+        // if we're externalizing ESM and CJS should basically just always do it?
+        // or are there others like SystemJS / AMD that we'd need to handle?
+        // for now, we'll just leave this as is
+        else if (/\.m?js$/.test(esmEntry)) {
+            if (pkg.type === 'module' || esmEntry.endsWith('.mjs')) {
                 ssrExternals.add(id);
                 continue;
             }
             // check if the entry is cjs
-            const content = fs__default.readFileSync(entry, 'utf-8');
+            const content = fs__default.readFileSync(esmEntry, 'utf-8');
             if (/\bmodule\.exports\b|\bexports[.\[]|\brequire\s*\(/.test(content)) {
                 ssrExternals.add(id);
             }
         }
     }
-    for (const id of depsToTrace) {
-        const depRoot = path__default.dirname(resolveFrom$3(`${id}/package.json`, root, !!config.resolve.preserveSymlinks));
-        resolveSSRExternal({
-            ...config,
-            root: depRoot
-        }, knownImports, ssrExternals, seen);
+    for (const depRoot of depsToTrace) {
+        collectExternals(depRoot, preserveSymlinks, ssrExternals, seen);
     }
-    if ((_c = config.ssr) === null || _c === void 0 ? void 0 : _c.external) {
-        config.ssr.external.forEach((id) => ssrExternals.add(id));
-    }
-    let externals = [...ssrExternals];
-    if ((_d = config.ssr) === null || _d === void 0 ? void 0 : _d.noExternal) {
-        const filter = createFilter$1(undefined, config.ssr.noExternal, {
-            resolve: false
-        });
-        externals = externals.filter((id) => filter(id));
-    }
-    return externals.filter((id) => id !== 'vite');
 }
 function shouldExternalizeForSSR(id, externals) {
     const should = externals.some((e) => {
@@ -42246,7 +42306,7 @@ function errorMiddleware(server, allowNext = false) {
  * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
  */
 let parser = Parser.extend(acornClassFields, acornStaticClassFeatures);
-async function createPluginContainer({ plugins, logger, root, build: { rollupOptions } }, watcher) {
+async function createPluginContainer({ plugins, logger, root, build: { rollupOptions } }, moduleGraph, watcher) {
     const isDebug = process.env.DEBUG;
     const seenResolves = {};
     const debugResolve = createDebugger('vite:resolve');
@@ -42257,7 +42317,6 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
         onlyWhenFocused: 'vite:plugin'
     });
     // ---------------------------------------------------------------------------
-    const MODULES = new Map();
     const watchFiles = new Set();
     // get rollup version
     const rollupPkgPath = path$t.resolve(require.resolve('rollup'), '../../package.json');
@@ -42272,6 +42331,36 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
         logger.warn(source.cyan(`[plugin:${plugin}] `) +
             source.yellow(`context method ${source.bold(`${method}()`)} is not supported in serve mode. This plugin is likely not vite-compatible.`));
     }
+    // throw when an unsupported ModuleInfo property is accessed,
+    // so that incompatible plugins fail in a non-cryptic way.
+    const ModuleInfoProxy = {
+        get(info, key) {
+            if (key in info) {
+                return info[key];
+            }
+            throw Error(`[vite] The "${key}" property of ModuleInfo is not supported.`);
+        }
+    };
+    // same default value of "moduleInfo.meta" as in Rollup
+    const EMPTY_OBJECT = Object.freeze({});
+    function getModuleInfo(id) {
+        const module = moduleGraph === null || moduleGraph === void 0 ? void 0 : moduleGraph.getModuleById(id);
+        if (!module) {
+            return null;
+        }
+        if (!module.info) {
+            module.info = new Proxy({ id, meta: module.meta || EMPTY_OBJECT }, ModuleInfoProxy);
+        }
+        return module.info;
+    }
+    function updateModuleInfo(id, { meta }) {
+        if (meta) {
+            const moduleInfo = getModuleInfo(id);
+            if (moduleInfo) {
+                moduleInfo.meta = { ...moduleInfo.meta, ...meta };
+            }
+        }
+    }
     // we should create a new context for each async hook pipeline so that the
     // active plugin in that pipeline can be tracked in a concurrency-safe manner.
     // using a class to make creating new contexts more efficient
@@ -42304,19 +42393,12 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
             return out;
         }
         getModuleInfo(id) {
-            let mod = MODULES.get(id);
-            if (mod)
-                return mod.info;
-            mod = {
-                /** @type {import('rollup').ModuleInfo} */
-                // @ts-ignore-next
-                info: {}
-            };
-            MODULES.set(id, mod);
-            return mod.info;
+            return getModuleInfo(id);
         }
         getModuleIds() {
-            return MODULES.keys();
+            return moduleGraph
+                ? moduleGraph.idToModuleMap.keys()
+                : Array.prototype[Symbol.iterator]();
         }
         addWatchFile(id) {
             watchFiles.add(id);
@@ -42482,6 +42564,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                 ...options
             };
         })(),
+        getModuleInfo,
         async buildStart() {
             await Promise.all(plugins.map((plugin) => {
                 if (plugin.buildStart) {
@@ -42546,6 +42629,9 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                 ctx._activePlugin = plugin;
                 const result = await plugin.load.call(ctx, id, { ssr });
                 if (result != null) {
+                    if (isObject$3(result)) {
+                        updateModuleInfo(id, result);
+                    }
                     return result;
                 }
             }
@@ -42575,9 +42661,13 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                 isDebug &&
                     debugPluginTransform(timeFrom(start), plugin.name, prettifyUrl(id, root));
                 if (isObject$3(result)) {
-                    code = result.code || '';
-                    if (result.map)
-                        ctx.sourcemapChain.push(result.map);
+                    if (result.code !== undefined) {
+                        code = result.code;
+                        if (result.map) {
+                            ctx.sourcemapChain.push(result.map);
+                        }
+                    }
+                    updateModuleInfo(id, result);
                 }
                 else {
                     code = result;
@@ -42602,6 +42692,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
 
 const debug$b = createDebugger('vite:deps');
 const htmlTypesRE = /\.(html|vue|svelte|astro)$/;
+const setupRE = /<script\s+setup/;
 // A simple regex to detect import sources. This is only used on
 // <script lang="ts"> blocks in vue (setup only) or svelte files, since
 // seemingly unused imports are dropped by esbuild when transpiling TS which
@@ -42691,6 +42782,7 @@ const commentRE = /<!--(.|[\r\n])*?-->/;
 const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
+const contextRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 function esbuildScanPlugin(config, container, depImports, missing, entries) {
     var _a, _b;
     const seen = new Map();
@@ -42717,6 +42809,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
     return {
         name: 'vite:dep-scan',
         setup(build) {
+            const moduleScripts = {};
             // external urls
             build.onResolve({ filter: externalRE }, ({ path }) => ({
                 path,
@@ -42727,6 +42820,12 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 path,
                 external: true
             }));
+            build.onResolve({ filter: virtualModuleRE }, async ({ path, importer }) => {
+                return {
+                    path: await resolve(path.substring('virtual-module:'.length), importer),
+                    namespace: 'html'
+                };
+            });
             // html types: extract script contents -----------------------------------
             build.onResolve({ filter: htmlTypesRE }, async ({ path, importer }) => {
                 return {
@@ -42734,6 +42833,9 @@ 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');
@@ -42747,10 +42849,9 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 let match;
                 while ((match = regex.exec(raw))) {
                     const [, openTag, content] = match;
-                    const srcMatch = openTag.match(srcRE);
                     const typeMatch = openTag.match(typeRE);
-                    const langMatch = openTag.match(langRE);
                     const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
+                    const langMatch = openTag.match(langRE);
                     const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3]);
                     // skip type="application/ld+json" and other non-JS types
                     if (type &&
@@ -42762,12 +42863,30 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
                         loader = lang;
                     }
+                    const srcMatch = openTag.match(srcRE);
                     if (srcMatch) {
                         const src = srcMatch[1] || srcMatch[2] || srcMatch[3];
                         js += `import ${JSON.stringify(src)}\n`;
                     }
                     else if (content.trim()) {
-                        js += content + '\n';
+                        // There can be module scripts (`<script context="module">` in Svelte and `<script>` in Vue)
+                        // or local scripts (`<script>` in Svelte and `<script setup>` in Vue)
+                        // We need to handle these separately in case variable names are reused between them
+                        const contextMatch = openTag.match(contextRE);
+                        const context = contextMatch &&
+                            (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] = {
+                                loader,
+                                contents: content
+                            };
+                            js += `import '${id}';\n`;
+                        }
+                        else {
+                            js += content + '\n';
+                        }
                     }
                 }
                 // empty singleline & multiline comments to avoid matching comments
@@ -42776,7 +42895,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     .replace(singlelineCommentsRE, '');
                 if (loader.startsWith('ts') &&
                     (path.endsWith('.svelte') ||
-                        (path.endsWith('.vue') && /<script\s+setup/.test(raw)))) {
+                        (path.endsWith('.vue') && setupRE.test(raw)))) {
                     // when using TS + (Vue + <script setup>) or Svelte, imports may seem
                     // unused to esbuild and dropped in the build output, which prevents
                     // esbuild from crawling further.
@@ -43042,7 +43161,8 @@ function loadFallbackPlugin() {
     };
 }
 
-function resolveBuildOptions(raw) {
+function resolveBuildOptions(root, raw) {
+    var _a;
     const resolved = {
         target: 'modules',
         polyfillModulePreload: true,
@@ -43077,6 +43197,28 @@ function resolveBuildOptions(raw) {
             ...raw === null || raw === void 0 ? void 0 : raw.dynamicImportVarsOptions
         }
     };
+    const resolve = (p) => p.startsWith('\0') ? p : path__default.resolve(root, p);
+    resolved.outDir = resolve(resolved.outDir);
+    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))
+            : typeof raw.rollupOptions.input === 'object'
+                ? Object.fromEntries(Object.entries(raw.rollupOptions.input).map(([key, value]) => [key, resolve(value)]))
+                : resolve(raw.rollupOptions.input);
+    }
+    else {
+        input = resolve((raw === null || raw === void 0 ? void 0 : raw.lib)
+            ? raw.lib.entry
+            : typeof (raw === null || raw === void 0 ? void 0 : raw.ssr) === 'string'
+                ? raw.ssr
+                : 'index.html');
+    }
+    if (!!(raw === null || raw === void 0 ? void 0 : raw.ssr) && typeof input === 'string' && input.endsWith('.html')) {
+        throw new Error(`rollupOptions.input should not be an html file when building for SSR. ` +
+            `Please specify a dedicated SSR entry.`);
+    }
+    resolved.rollupOptions.input = input;
     // handle special build targets
     if (resolved.target === 'modules') {
         // Support browserslist
@@ -43155,27 +43297,18 @@ async function build(inlineConfig = {}) {
     }
 }
 async function doBuild(inlineConfig = {}) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const config = await resolveConfig(inlineConfig, 'build', 'production');
     const options = config.build;
+    const input = options.rollupOptions.input;
+    const outDir = options.outDir;
     const ssr = !!options.ssr;
     const libOptions = options.lib;
     config.logger.info(source.cyan(`vite v${require('vite/package.json').version} ${source.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
-    const resolve = (p) => path__default.resolve(config.root, p);
-    const input = libOptions
-        ? resolve(libOptions.entry)
-        : typeof options.ssr === 'string'
-            ? resolve(options.ssr)
-            : ((_a = options.rollupOptions) === null || _a === void 0 ? void 0 : _a.input) || resolve('index.html');
-    if (ssr && typeof input === 'string' && input.endsWith('.html')) {
-        throw new Error(`rollupOptions.input should not be an html file when building for SSR. ` +
-            `Please specify a dedicated SSR entry.`);
-    }
-    const outDir = resolve(options.outDir);
     // inject ssr arg to plugin load/transform hooks
     const plugins = (ssr ? config.plugins.map((p) => injectSsrFlagToHooks(p)) : config.plugins);
     // inject ssrExternal if present
-    const userExternal = (_b = options.rollupOptions) === null || _b === void 0 ? void 0 : _b.external;
+    const userExternal = (_a = options.rollupOptions) === null || _a === void 0 ? void 0 : _a.external;
     let external = userExternal;
     if (ssr) {
         // see if we have cached deps data available
@@ -43196,7 +43329,6 @@ async function doBuild(inlineConfig = {}) {
     }
     const rollup = require('rollup');
     const rollupOptions = {
-        input,
         context: 'globalThis',
         preserveEntrySignatures: ssr
             ? 'allow-extension'
@@ -43253,7 +43385,7 @@ async function doBuild(inlineConfig = {}) {
             };
         };
         // resolve lib mode outputs
-        const outputs = resolveBuildOutputs((_c = options.rollupOptions) === null || _c === void 0 ? void 0 : _c.output, libOptions, config.logger);
+        const outputs = resolveBuildOutputs((_b = options.rollupOptions) === null || _b === void 0 ? void 0 : _b.output, libOptions, config.logger);
         // watch file changes with rollup
         if (config.build.watch) {
             config.logger.info(source.cyanBright(`\nwatching for file changes...`));
@@ -43276,7 +43408,7 @@ async function doBuild(inlineConfig = {}) {
                         ignored: [
                             '**/node_modules/**',
                             '**/.git/**',
-                            ...(((_d = watcherOptions === null || watcherOptions === void 0 ? void 0 : watcherOptions.chokidar) === null || _d === void 0 ? void 0 : _d.ignored) || [])
+                            ...(((_c = watcherOptions === null || watcherOptions === void 0 ? void 0 : watcherOptions.chokidar) === null || _c === void 0 ? void 0 : _c.ignored) || [])
                         ],
                         ignoreInitial: true,
                         ignorePermissionErrors: true,
@@ -49230,7 +49362,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-39172335.js'); }).then(function (n) { return n.index; });
+    const { generate } = await Promise.resolve().then(function () { return require('./dep-146e2d5f.js'); }).then(function (n) { return n.index; });
     const pems = generate(null, {
         algorithm: 'sha256',
         days: 30,
@@ -56541,6 +56673,10 @@ const isDebug$3 = !!process.env.DEBUG;
 const debug$4 = createDebugger('vite:sourcemap', {
     onlyWhenFocused: true
 });
+// Virtual modules should be prefixed with a null byte to avoid a
+// false positive "missing source" warning. We also check for certain
+// prefixes used for special handling in esbuildDepPlugin.
+const virtualSourceRE = /^(\0|dep:|browser-external:)/;
 async function injectSourcesContent(map, file, logger) {
     let sourceRoot;
     try {
@@ -56550,7 +56686,7 @@ async function injectSourcesContent(map, file, logger) {
     catch { }
     const missingSources = [];
     map.sourcesContent = await Promise.all(map.sources.map((sourcePath) => {
-        if (sourcePath) {
+        if (sourcePath && !virtualSourceRE.test(sourcePath)) {
             sourcePath = decodeURI(sourcePath);
             if (sourceRoot) {
                 sourcePath = path__default.resolve(sourceRoot, sourcePath);
@@ -57010,7 +57146,7 @@ function isFileServingAllowed(url, server) {
         return true;
     const cleanedUrl = cleanUrl(url);
     const file = ensureLeadingSlash(normalizePath$4(cleanedUrl));
-    if (server.config.server.fs.deny.some((i) => minimatch_1(file, i, _matchOptions)))
+    if (server.config.server.fs.deny.some((i) => micromatch_1.isMatch(file, i, _matchOptions)))
         return false;
     if (server.moduleGraph.safeModulesPath.has(file))
         return true;
@@ -57481,13 +57617,13 @@ function invalidateSSRModule(mod, seen) {
     mod.importers.forEach((importer) => invalidateSSRModule(importer, seen));
 }
 class ModuleGraph {
-    constructor(container) {
+    constructor(resolveId) {
+        this.resolveId = resolveId;
         this.urlToModuleMap = new Map();
         this.idToModuleMap = new Map();
         // a single file may corresponds to multiple modules with different queries
         this.fileToModulesMap = new Map();
         this.safeModulesPath = new Set();
-        this.container = container;
     }
     async getModuleByUrl(rawUrl) {
         const [url] = await this.resolveUrl(rawUrl);
@@ -57509,6 +57645,7 @@ class ModuleGraph {
         }
     }
     invalidateModule(mod, seen = new Set()) {
+        mod.info = undefined;
         mod.transformResult = null;
         mod.ssrTransformResult = null;
         invalidateSSRModule(mod, seen);
@@ -57557,10 +57694,12 @@ class ModuleGraph {
         return noLongerImported;
     }
     async ensureEntryFromUrl(rawUrl) {
-        const [url, resolvedId] = await this.resolveUrl(rawUrl);
+        const [url, resolvedId, meta] = await this.resolveUrl(rawUrl);
         let mod = this.urlToModuleMap.get(url);
         if (!mod) {
             mod = new ModuleNode(url);
+            if (meta)
+                mod.meta = meta;
             this.urlToModuleMap.set(url, mod);
             mod.id = resolvedId;
             this.idToModuleMap.set(resolvedId, mod);
@@ -57601,15 +57740,15 @@ class ModuleGraph {
     // 2. resolve its extension so that urls with or without extension all map to
     // the same module
     async resolveUrl(url) {
-        var _a;
         url = removeImportQuery(removeTimestampQuery(url));
-        const resolvedId = ((_a = (await this.container.resolveId(url))) === null || _a === void 0 ? void 0 : _a.id) || url;
+        const resolved = await this.resolveId(url);
+        const resolvedId = (resolved === null || resolved === void 0 ? void 0 : resolved.id) || url;
         const ext = path$t.extname(cleanUrl(resolvedId));
         const { pathname, search, hash } = require$$0$7.parse(url);
         if (ext && !pathname.endsWith(ext)) {
             url = pathname + ext + (search || '') + (hash || '');
         }
-        return [url, resolvedId];
+        return [url, resolvedId, resolved === null || resolved === void 0 ? void 0 : resolved.meta];
     }
 }
 
@@ -57623,7 +57762,8 @@ async function handleHMRUpdate(file, server) {
     const shortFile = getShortName(file, config.root);
     const isConfig = file === config.configFile;
     const isConfigDependency = config.configFileDependencies.some((name) => file === path__default.resolve(name));
-    const isEnv = config.inlineConfig.envFile !== false && file.endsWith('.env');
+    const isEnv = config.inlineConfig.envFile !== false &&
+        (file === '.env' || file.startsWith('.env.'));
     if (isConfig || isConfigDependency || isEnv) {
         // auto restart server
         debugHmr(`[config change] ${source.dim(shortFile)}`);
@@ -57731,7 +57871,8 @@ async function handleFileAddUnlink(file, server, isUnlink = false) {
         for (const i in server._globImporters) {
             const { module, importGlobs } = server._globImporters[i];
             for (const { base, pattern } of importGlobs) {
-                if (minimatch_1(file, pattern) || minimatch_1(path__default.relative(base, file), pattern)) {
+                if (micromatch_1.isMatch(file, pattern) ||
+                    micromatch_1.isMatch(path__default.relative(base, file), pattern)) {
                     modules.push(module);
                     // We use `onFileChange` to invalidate `module.file` so that subsequent `ssrLoadModule()`
                     // calls get fresh glob import results with(out) the newly added(/removed) `file`.
@@ -66848,6 +66989,58 @@ function rebindErrorStacktrace(e, stacktrace) {
     }
 }
 
+/**
+ * This plugin hooks into Node's module resolution algorithm at runtime,
+ * so that SSR builds can benefit from `resolve.dedupe` like they do
+ * in development.
+ */
+function ssrRequireHookPlugin(config) {
+    var _a;
+    if (config.command !== 'build' || !((_a = config.resolve.dedupe) === null || _a === void 0 ? void 0 : _a.length)) {
+        return null;
+    }
+    return {
+        name: 'vite:ssr-require-hook',
+        transform(code, id) {
+            const moduleInfo = this.getModuleInfo(id);
+            if (moduleInfo === null || moduleInfo === void 0 ? void 0 : moduleInfo.isEntry) {
+                const s = new MagicString(code);
+                s.prepend(`;(${dedupeRequire.toString()})(${JSON.stringify(config.resolve.dedupe)});\n`);
+                return {
+                    code: s.toString(),
+                    map: s.generateMap({
+                        source: id
+                    })
+                };
+            }
+        }
+    };
+}
+/** Respect the `resolve.dedupe` option in production SSR. */
+function dedupeRequire(dedupe) {
+    const Module = require('module');
+    const resolveFilename = Module._resolveFilename;
+    Module._resolveFilename = function (request, parent, isMain, options) {
+        if (request[0] !== '.' && request[0] !== '/') {
+            const parts = request.split('/');
+            const pkgName = parts[0][0] === '@' ? parts[0] + '/' + parts[1] : parts[0];
+            if (dedupe.includes(pkgName)) {
+                // Use this module as the parent.
+                parent = module;
+            }
+        }
+        return resolveFilename(request, parent, isMain, options);
+    };
+}
+function hookNodeResolve(getResolver) {
+    const Module = require('module');
+    const prevResolver = Module._resolveFilename;
+    Module._resolveFilename = getResolver(prevResolver);
+    return () => {
+        Module._resolveFilename = prevResolver;
+    };
+}
+
 const pendingModules = new Map();
 const pendingImports = new Map();
 async function ssrLoadModule(url, server, context = { global }, urlStack = []) {
@@ -66896,13 +67089,27 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
+    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 = {
+        dedupe,
+        extensions: ['.js', '.cjs', '.json'],
+        isBuild: true,
+        isProduction,
+        isRequire: true,
+        mainFields: ['main'],
+        preserveSymlinks,
+        root
+    };
     // Since dynamic imports can happen in parallel, we need to
     // account for multiple pending deps and duplicate imports.
     const pendingDeps = [];
     const ssrImport = async (dep) => {
         var _a, _b;
         if (dep[0] !== '.' && dep[0] !== '/') {
-            return nodeImport(dep, mod.file, server.config);
+            return nodeImport(dep, mod.file, resolveOptions);
         }
         dep = unwrapId$1(dep);
         if (!isCircular(dep) && !((_a = pendingImports.get(dep)) === null || _a === void 0 ? void 0 : _a.some(isCircular))) {
@@ -66962,20 +67169,53 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     return Object.freeze(ssrModule);
 }
 // In node@12+ we can use dynamic import to load CJS and ESM
-async function nodeImport(id, importer, config) {
+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, 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';
+            throw err;
+        }
+        return resolved.id;
+    };
+    // When an ESM module imports an ESM dependency, this hook is *not* used.
+    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 = resolve(id, importer, config.root, !!config.resolve.preserveSymlinks);
+        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();
         }
     }
-    const mod = await dynamicImport(url);
-    return proxyESM(id, mod);
+    try {
+        const mod = await dynamicImport(url);
+        return proxyESM(id, mod);
+    }
+    finally {
+        unhookNodeResolve();
+    }
 }
 // rollup-style default import interop for cjs
 function proxyESM(id, mod) {
@@ -66986,26 +67226,13 @@ function proxyESM(id, mod) {
             : mod;
     return new Proxy(mod, {
         get(mod, prop) {
+            var _a;
             if (prop === 'default')
                 return defaultExport;
-            return mod[prop];
+            return (_a = mod[prop]) !== null && _a !== void 0 ? _a : defaultExport === null || defaultExport === void 0 ? void 0 : defaultExport[prop];
         }
     });
 }
-const resolveCache = new Map();
-function resolve(id, importer, root, preserveSymlinks) {
-    const key = id + importer + root;
-    const cached = resolveCache.get(key);
-    if (cached) {
-        return cached;
-    }
-    const resolveDir = importer && fs__default.existsSync(cleanUrl(importer))
-        ? path__default.dirname(importer)
-        : root;
-    const resolved = resolveFrom$3(id, resolveDir, preserveSymlinks, true);
-    resolveCache.set(key, resolved);
-    return resolved;
-}
 
 /**
  * The amount to wait for requests to register newly found dependencies before triggering
@@ -67157,9 +67384,8 @@ async function createServer(inlineConfig = {}) {
         disableGlobbing: true,
         ...watchOptions
     });
-    const plugins = config.plugins;
-    const container = await createPluginContainer(config, watcher);
-    const moduleGraph = new ModuleGraph(container);
+    const moduleGraph = new ModuleGraph((url) => container.resolveId(url));
+    const container = await createPluginContainer(config, moduleGraph, watcher);
     const closeHttpServer = createServerCloseFn(httpServer);
     // eslint-disable-next-line prefer-const
     let exitProcess;
@@ -67181,11 +67407,9 @@ async function createServer(inlineConfig = {}) {
         },
         transformIndexHtml: null,
         ssrLoadModule(url) {
-            if (!server._ssrExternals) {
-                server._ssrExternals = resolveSSRExternal(config, server._optimizeDepsMetadata
-                    ? Object.keys(server._optimizeDepsMetadata.optimized)
-                    : []);
-            }
+            server._ssrExternals || (server._ssrExternals = resolveSSRExternal(config, server._optimizeDepsMetadata
+                ? Object.keys(server._optimizeDepsMetadata.optimized)
+                : []));
             return ssrLoadModule(url, server);
         },
         ssrFixStacktrace(e) {
@@ -67268,7 +67492,7 @@ async function createServer(inlineConfig = {}) {
     }
     // apply server configuration hooks from plugins
     const postHooks = [];
-    for (const plugin of plugins) {
+    for (const plugin of config.plugins) {
         if (plugin.configureServer) {
             postHooks.push(await plugin.configureServer(server));
         }
@@ -81155,6 +81379,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             ssrConfig: config.ssr,
             asSrc: true
         }),
+        config.build.ssr ? ssrRequireHookPlugin(config) : null,
         htmlInlineScriptProxyPlugin(config),
         cssPlugin(config),
         config.esbuild !== false ? esbuildPlugin(config.esbuild) : null,
@@ -81445,7 +81670,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     }
     // resolve public base url
     const BASE_URL = resolveBaseUrl(config.base, command === 'build', logger);
-    const resolvedBuildOptions = resolveBuildOptions(config.build);
+    const resolvedBuildOptions = resolveBuildOptions(resolvedRoot, config.build);
     // resolve cache directory
     const pkgPath = lookupFile(resolvedRoot, [`package.json`], true /* pathOnly */);
     const cacheDir = config.cacheDir
@@ -81994,4 +82219,4 @@ exports.send = send$1;
 exports.sortUserPlugins = sortUserPlugins;
 exports.source = source;
 exports.transformWithEsbuild = transformWithEsbuild;
-//# sourceMappingURL=dep-caa1572d.js.map
+//# sourceMappingURL=dep-0183a921.js.map