vite 5.0.4 → 5.0.6

package/dist/node/chunks/{dep-4RECYSE1.js → dep-YJaePtkC.js}

@@ -27,11 +27,11 @@ import { createHash as createHash$2 } from 'node:crypto';
 import { promises } from 'node:dns';
 import { CLIENT_ENTRY, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, OPTIMIZABLE_ENTRY_RE, FS_PREFIX, wildcardHosts, loopbackHosts, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEP_VERSION_RE, SPECIAL_QUERY_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, KNOWN_ASSET_TYPES, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, CLIENT_DIR, JS_TYPES_RE, VERSION as VERSION$1, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$0$a from 'crypto';
-import { Buffer as Buffer$1 } from 'node:buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
 import assert$1 from 'node:assert';
 import process$1 from 'node:process';
 import v8 from 'node:v8';
+import { Buffer as Buffer$1 } from 'node:buffer';
 import { VERSION } from 'rollup';
 import { parseAstAsync, parseAst } from 'rollup/parseAst';
 import * as qs from 'querystring';
@@ -2769,7 +2769,17 @@ function serialize(obj, indent, baseIndent) {
         return `${obj}n`;
     return stringify$8(obj);
 }
+// isWellFormed exists from Node.js 20
+const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
+function isWellFormedString(input) {
+    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
+    if (hasStringIsWellFormed)
+        return input.isWellFormed();
+    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
+    return !/\p{Surrogate}/u.test(input);
+}
 const dataToEsm = function dataToEsm(data, options = {}) {
+    var _a, _b;
     const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
     const _ = options.compact ? '' : ' ';
     const n = options.compact ? '' : '\n';
@@ -2784,8 +2794,17 @@ const dataToEsm = function dataToEsm(data, options = {}) {
         const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
         return `export default${magic}${code};`;
     }
+    let maxUnderbarPrefixLength = 0;
+    for (const key of Object.keys(data)) {
+        const underbarPrefixLength = (_b = (_a = key.match(/^(_+)/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        if (underbarPrefixLength > maxUnderbarPrefixLength) {
+            maxUnderbarPrefixLength = underbarPrefixLength;
+        }
+    }
+    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
     let namedExportCode = '';
     const defaultExportRows = [];
+    const arbitraryNameExportRows = [];
     for (const [key, value] of Object.entries(data)) {
         if (key === makeLegalIdentifier(key)) {
             if (options.objectShorthand)
@@ -2796,9 +2815,18 @@ const dataToEsm = function dataToEsm(data, options = {}) {
         }
         else {
             defaultExportRows.push(`${stringify$8(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
+            if (options.includeArbitraryNames && isWellFormedString(key)) {
+                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+            }
         }
     }
-    return `${namedExportCode}export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    const arbitraryExportCode = arbitraryNameExportRows.length > 0
+        ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}`
+        : '';
+    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
 };
 
 var path$l = require$$0$4;
@@ -12069,7 +12097,7 @@ function normalizePath$3(id) {
 }
 function fsPathFromId(id) {
     const fsPath = normalizePath$3(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
-    return fsPath[0] === '/' || fsPath.match(VOLUME_RE) ? fsPath : `/${fsPath}`;
+    return fsPath[0] === '/' || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
 }
 function fsPathFromUrl(url) {
     return fsPathFromId(cleanUrl(url));
@@ -12391,6 +12419,27 @@ function copyDir(srcDir, destDir) {
         }
     }
 }
+async function recursiveReaddir(dir) {
+    if (!fs$l.existsSync(dir)) {
+        return [];
+    }
+    let dirents;
+    try {
+        dirents = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === 'EACCES') {
+            // Ignore permission errors
+            return [];
+        }
+        throw e;
+    }
+    const files = await Promise.all(dirents.map((dirent) => {
+        const res = path$o.resolve(dir, dirent.name);
+        return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath$3(res);
+    }));
+    return files.flat(1);
+}
 // `fs.realpathSync.native` resolves differently in Windows network drive,
 // causing file read errors. skip for now.
 // https://github.com/nodejs/node/issues/37737
@@ -14611,7 +14660,7 @@ const buildEsbuildPlugin = (config) => {
                 // the headers don't modify the sourcemap
                 const esbuildCode = res.code;
                 const contentIndex = opts.format === 'iife'
-                    ? esbuildCode.match(IIFE_BEGIN_RE)?.index || 0
+                    ? Math.max(esbuildCode.search(IIFE_BEGIN_RE), 0)
                     : opts.format === 'umd'
                         ? esbuildCode.indexOf(`(function(`) // same for minified or not
                         : 0;
@@ -16373,6 +16422,39 @@ function lookup(extn) {
 	return mimes$1[!~idx ? tmp : tmp.substring(++idx)];
 }
 
+const publicFilesMap = new WeakMap();
+async function initPublicFiles(config) {
+    const fileNames = await recursiveReaddir(config.publicDir);
+    const publicFiles = new Set(fileNames.map((fileName) => fileName.slice(config.publicDir.length)));
+    publicFilesMap.set(config, publicFiles);
+    return publicFiles;
+}
+function getPublicFiles(config) {
+    return publicFilesMap.get(config);
+}
+function checkPublicFile(url, config) {
+    // note if the file is in /public, the resolver would have returned it
+    // as-is so it's not going to be a fully resolved path.
+    const { publicDir } = config;
+    if (!publicDir || url[0] !== '/') {
+        return;
+    }
+    const fileName = cleanUrl(url);
+    // short-circuit if we have an in-memory publicFiles cache
+    const publicFiles = getPublicFiles(config);
+    if (publicFiles) {
+        return publicFiles.has(fileName)
+            ? normalizePath$3(path$o.join(publicDir, fileName))
+            : undefined;
+    }
+    const publicFile = normalizePath$3(path$o.join(publicDir, fileName));
+    if (!publicFile.startsWith(withTrailingSlash(normalizePath$3(publicDir)))) {
+        // can happen if URL starts with '../'
+        return;
+    }
+    return fs$l.existsSync(publicFile) ? publicFile : undefined;
+}
+
 // referenceId is base64url but replaces - with $
 const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g;
 const rawRE = /(?:\?|&)raw(?:&|$)/;
@@ -16522,24 +16604,6 @@ function assetPlugin(config) {
         },
     };
 }
-function checkPublicFile(url, { publicDir }) {
-    // note if the file is in /public, the resolver would have returned it
-    // as-is so it's not going to be a fully resolved path.
-    if (!publicDir || url[0] !== '/') {
-        return;
-    }
-    const publicFile = path$o.join(publicDir, cleanUrl(url));
-    if (!normalizePath$3(publicFile).startsWith(withTrailingSlash(normalizePath$3(publicDir)))) {
-        // can happen if URL starts with '../'
-        return;
-    }
-    if (fs$l.existsSync(publicFile)) {
-        return publicFile;
-    }
-    else {
-        return;
-    }
-}
 async function fileToUrl$1(id, config, ctx) {
     if (config.command === 'serve') {
         return fileToDevUrl(id, config);
@@ -17115,32 +17179,43 @@ const debug$g = createDebugger('vite:sourcemap', {
 // false positive "missing source" warning. We also check for certain
 // prefixes used for special handling in esbuildDepPlugin.
 const virtualSourceRE = /^(?:dep:|browser-external:|virtual:)|\0/;
-async function injectSourcesContent(map, file, logger) {
+async function computeSourceRoute(map, file) {
     let sourceRoot;
     try {
         // The source root is undefined for virtual modules and permission errors.
         sourceRoot = await fsp.realpath(path$o.resolve(path$o.dirname(file), map.sourceRoot || ''));
     }
     catch { }
+    return sourceRoot;
+}
+async function injectSourcesContent(map, file, logger) {
+    let sourceRootPromise;
     const missingSources = [];
     const sourcesContent = map.sourcesContent || [];
-    await Promise.all(map.sources.map(async (sourcePath, index) => {
-        let content = null;
-        if (sourcePath && !virtualSourceRE.test(sourcePath)) {
-            sourcePath = decodeURI(sourcePath);
-            if (sourceRoot) {
-                sourcePath = path$o.resolve(sourceRoot, sourcePath);
-            }
-            // inject content from source file when sourcesContent is null
-            content =
-                sourcesContent[index] ??
-                    (await fsp.readFile(sourcePath, 'utf-8').catch(() => {
-                        missingSources.push(sourcePath);
-                        return null;
-                    }));
+    const sourcesContentPromises = [];
+    for (let index = 0; index < map.sources.length; index++) {
+        const sourcePath = map.sources[index];
+        if (!sourcesContent[index] &&
+            sourcePath &&
+            !virtualSourceRE.test(sourcePath)) {
+            sourcesContentPromises.push((async () => {
+                // inject content from source file when sourcesContent is null
+                sourceRootPromise ??= computeSourceRoute(map, file);
+                const sourceRoot = await sourceRootPromise;
+                let resolvedSourcePath = decodeURI(sourcePath);
+                if (sourceRoot) {
+                    resolvedSourcePath = path$o.resolve(sourceRoot, resolvedSourcePath);
+                }
+                sourcesContent[index] = await fsp
+                    .readFile(resolvedSourcePath, 'utf-8')
+                    .catch(() => {
+                    missingSources.push(resolvedSourcePath);
+                    return null;
+                });
+            })());
         }
-        sourcesContent[index] = content;
-    }));
+    }
+    await Promise.all(sourcesContentPromises);
     map.sourcesContent = sourcesContent;
     // Use this command…
     //    DEBUG="vite:sourcemap" vite build
@@ -28496,7 +28571,7 @@ function resolvePlugin(resolveOptions) {
                     // Optimized files could not yet exist in disk, resolve to the full path
                     // Inject the current browserHash version if the path doesn't have one
                     if (!resolveOptions.isBuild &&
-                        !normalizedFsPath.match(DEP_VERSION_RE)) {
+                        !DEP_VERSION_RE.test(normalizedFsPath)) {
                         const browserHash = optimizedDepInfoFromFile(depsOptimizer.metadata, normalizedFsPath)?.browserHash;
                         if (browserHash) {
                             return injectQuery(normalizedFsPath, `v=${browserHash}`);
@@ -28655,7 +28730,7 @@ function ensureVersionQuery(resolved, id, options, depsOptimizer) {
         // Use the original id to do the check as the resolved id may be the real
         // file path after symlinks resolution
         const isNodeModule = isInNodeModules$1(id) || isInNodeModules$1(resolved);
-        if (isNodeModule && !resolved.match(DEP_VERSION_RE)) {
+        if (isNodeModule && !DEP_VERSION_RE.test(resolved)) {
             const versionHash = depsOptimizer.metadata.browserHash;
             if (versionHash && isOptimizable(resolved, depsOptimizer.options)) {
                 resolved = injectQuery(resolved, `v=${versionHash}`);
@@ -37858,7 +37933,7 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
 }
 function resolveEnvPrefix({ envPrefix = 'VITE_', }) {
     envPrefix = arraify(envPrefix);
-    if (envPrefix.some((prefix) => prefix === '')) {
+    if (envPrefix.includes('')) {
         throw new Error(`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`);
     }
     return envPrefix;
@@ -37937,7 +38012,7 @@ function polyfill() {
 const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(js|css)$/;
 const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
 // Do not allow preceding '.', but do allow preceding '...' for spread operations
-const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*')\)/g;
+const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*')\)/dg;
 const htmlLangRE = /\.(?:html|htm)$/;
 const importMapRE = /[ \t]*<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is;
 const moduleScriptRE = /[ \t]*<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i;
@@ -38559,10 +38634,9 @@ function extractImportExpressionFromClassicScript(scriptTextNode) {
     let match;
     inlineImportRE.lastIndex = 0;
     while ((match = inlineImportRE.exec(cleanCode))) {
-        const { 1: url, index } = match;
-        const startUrl = cleanCode.indexOf(url, index);
-        const start = startUrl + 1;
-        const end = start + url.length - 2;
+        const [, [urlStart, urlEnd]] = match.indices;
+        const start = urlStart + 1;
+        const end = urlEnd - 1;
         scriptUrls.push({
             start: start + startOffset,
             end: end + startOffset,
@@ -38573,11 +38647,11 @@ function extractImportExpressionFromClassicScript(scriptTextNode) {
 }
 function preImportMapHook(config) {
     return (html, ctx) => {
-        const importMapIndex = html.match(importMapRE)?.index;
-        if (importMapIndex === undefined)
+        const importMapIndex = html.search(importMapRE);
+        if (importMapIndex < 0)
             return;
-        const importMapAppendIndex = html.match(importMapAppendRE)?.index;
-        if (importMapAppendIndex === undefined)
+        const importMapAppendIndex = html.search(importMapAppendRE);
+        if (importMapAppendIndex < 0)
             return;
         if (importMapAppendIndex < importMapIndex) {
             const relativeHtml = normalizePath$3(path$o.relative(config.root, ctx.filename));
@@ -39663,8 +39737,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-nbvvoiwS.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-GiiHpyM6.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-I1uDMLJL.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-Sacttr-6.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -39672,12 +39746,12 @@ const importPostcss = createCachedImport(() => import('postcss'));
 async function preprocessCSS(code, filename, config) {
     return await compileCSS(filename, code, config);
 }
-const postcssReturnsVirtualFilesRE = /^<.+>$/;
 async function formatPostcssSourceMap(rawMap, file) {
     const inputFileDir = path$o.dirname(file);
     const sources = rawMap.sources.map((source) => {
         const cleanSource = cleanUrl(decodeURIComponent(source));
-        if (postcssReturnsVirtualFilesRE.test(cleanSource)) {
+        // postcss virtual files
+        if (cleanSource[0] === '<' && cleanSource[cleanSource.length - 1] === '>') {
             return `\0${cleanSource}`;
         }
         return normalizePath$3(path$o.resolve(inputFileDir, cleanSource));
@@ -39729,7 +39803,7 @@ async function resolvePostcssConfig(config) {
     else {
         const searchPath = typeof inlineOptions === 'string' ? inlineOptions : config.root;
         result = postcssrc({}, searchPath).catch((e) => {
-            if (!/No PostCSS Config found/.test(e.message)) {
+            if (!e.message.includes('No PostCSS Config found')) {
                 if (e instanceof Error) {
                     const { name, message, stack } = e;
                     e.name = 'Failed to load PostCSS config';
@@ -39943,6 +40017,8 @@ function resolveMinifyCssEsbuildOptions(options) {
         return { ...base, minify: true };
     }
 }
+const atImportRE = /@import(?:\s*(?:url\([^)]*\)|"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+const atCharsetRE = /@charset(?:\s*(?:"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
 async function hoistAtRules(css) {
     const s = new MagicString(css);
     const cleanCss = emptyCssComments(css);
@@ -39951,7 +40027,7 @@ async function hoistAtRules(css) {
     // CSS @import can only appear at top of the file. We need to hoist all @import
     // to top when multiple files are concatenated.
     // match until semicolon that's not in quotes
-    const atImportRE = /@import(?:\s*(?:url\([^)]*\)|"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+    atImportRE.lastIndex = 0;
     while ((match = atImportRE.exec(cleanCss))) {
         s.remove(match.index, match.index + match[0].length);
         // Use `appendLeft` instead of `prepend` to preserve original @import order
@@ -39959,7 +40035,7 @@ async function hoistAtRules(css) {
     }
     // #6333
     // CSS @charset must be the top-first in the file, hoist the first to top
-    const atCharsetRE = /@charset(?:\s*(?:"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+    atCharsetRE.lastIndex = 0;
     let foundCharset = false;
     while ((match = atCharsetRE.exec(cleanCss))) {
         s.remove(match.index, match.index + match[0].length);
@@ -40470,8 +40546,8 @@ const convertTargets = (esbuildTarget) => {
     for (const entry of entriesWithoutES) {
         if (entry === 'esnext')
             continue;
-        const index = entry.match(versionRE)?.index;
-        if (index) {
+        const index = entry.search(versionRE);
+        if (index >= 0) {
             const browser = map[entry.slice(0, index)];
             if (browser === false)
                 continue; // No mapping available
@@ -40893,16 +40969,24 @@ function jsonPlugin(options = {}, isBuild) {
                 };
             }
             catch (e) {
-                const errorMessageList = /\d+/.exec(e.message);
-                const position = errorMessageList && parseInt(errorMessageList[0], 10);
+                const position = extractJsonErrorPosition(e.message, json.length);
                 const msg = position
-                    ? `, invalid JSON syntax found at line ${position}`
+                    ? `, invalid JSON syntax found at position ${position}`
                     : `.`;
-                this.error(`Failed to parse JSON file` + msg, e.idx);
+                this.error(`Failed to parse JSON file` + msg, position);
             }
         },
     };
 }
+function extractJsonErrorPosition(errorMessage, inputLength) {
+    if (errorMessage.startsWith('Unexpected end of JSON input')) {
+        return inputLength - 1;
+    }
+    const errorMessageList = /at position (\d+)/.exec(errorMessage);
+    return errorMessageList
+        ? Math.max(parseInt(errorMessageList[1], 10) - 1, 0)
+        : undefined;
+}
 
 const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = 'ERR_OPTIMIZE_DEPS_PROCESSING_ERROR';
 const ERR_OUTDATED_OPTIMIZED_DEP = 'ERR_OUTDATED_OPTIMIZED_DEP';
@@ -48590,7 +48674,7 @@ function sirv (dir, opts={}) {
 }
 
 const knownJavascriptExtensionRE = /\.[tj]sx?$/;
-const sirvOptions = ({ getHeaders, shouldServe, }) => {
+const sirvOptions = ({ getHeaders, }) => {
     return {
         dev: true,
         etag: true,
@@ -48611,19 +48695,33 @@ const sirvOptions = ({ getHeaders, shouldServe, }) => {
                 }
             }
         },
-        shouldServe,
     };
 };
-function servePublicMiddleware(server) {
+function servePublicMiddleware(server, publicFiles) {
     const dir = server.config.publicDir;
     const serve = sirv(dir, sirvOptions({
         getHeaders: () => server.config.server.headers,
-        shouldServe: (filePath) => shouldServeFile(filePath, dir),
     }));
+    const toFilePath = (url) => {
+        let filePath = cleanUrl(url);
+        if (filePath.indexOf('%') !== -1) {
+            try {
+                filePath = decodeURI(filePath);
+            }
+            catch (err) {
+                /* malform uri */
+            }
+        }
+        return normalizePath$3(filePath);
+    };
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteServePublicMiddleware(req, res, next) {
-        // skip import request and internal requests `/@fs/ /@vite-client` etc...
-        if (isImportRequest(req.url) || isInternalRequest(req.url)) {
+        // To avoid the performance impact of `existsSync` on every request, we check against an
+        // in-memory set of known public files. This set is updated on restarts.
+        // also skip import request and internal requests `/@fs/ /@vite-client` etc...
+        if (!publicFiles.has(toFilePath(req.url)) ||
+            isImportRequest(req.url) ||
+            isInternalRequest(req.url)) {
             return next();
         }
         serve(req, res, next);
@@ -51373,6 +51471,8 @@ function bindCLIShortcuts(server, opts) {
                 if (loggedKeys.has(shortcut.key))
                     continue;
                 loggedKeys.add(shortcut.key);
+                if (shortcut.action == null)
+                    continue;
                 server.config.logger.info(colors$1.dim('  press ') +
                     colors$1.bold(`${shortcut.key} + enter`) +
                     colors$1.dim(` to ${shortcut.description}`));
@@ -51380,7 +51480,7 @@ function bindCLIShortcuts(server, opts) {
             return;
         }
         const shortcut = shortcuts.find((shortcut) => shortcut.key === input);
-        if (!shortcut)
+        if (!shortcut || shortcut.action == null)
             return;
         actionRunning = true;
         await shortcut.action(server);
@@ -58682,7 +58782,6 @@ const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, s
 const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => {
     const { config, moduleGraph, watcher } = server;
     const base = config.base || '/';
-    htmlPath = decodeURI(htmlPath);
     let proxyModulePath;
     let proxyModuleUrl;
     const trailingSlash = htmlPath.endsWith('/');
@@ -58702,7 +58801,9 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
     }
     const s = new MagicString(html);
     let inlineModuleIndex = -1;
-    const proxyCacheUrl = cleanUrl(proxyModulePath).replace(normalizePath$3(config.root), '');
+    // The key to the proxyHtml cache is decoded, as it will be compared
+    // against decoded URLs by the HTML plugins.
+    const proxyCacheUrl = decodeURI(cleanUrl(proxyModulePath).replace(normalizePath$3(config.root), ''));
     const styleUrl = [];
     const inlineStyles = [];
     const addInlineModule = (node, ext) => {
@@ -58873,7 +58974,13 @@ function preTransformRequest(server, url, base) {
     if (!server.config.server.preTransformRequests)
         return;
     // transform all url as non-ssr as html includes client-side assets only
-    url = unwrapId(stripBase(url, base));
+    try {
+        url = unwrapId(stripBase(decodeURI(url), base));
+    }
+    catch {
+        // ignore
+        return;
+    }
     server.warmupRequest(url);
 }
 
@@ -59487,6 +59594,7 @@ function createServer(inlineConfig = {}) {
 }
 async function _createServer(inlineConfig = {}, options) {
     const config = await resolveConfig(inlineConfig, 'serve');
+    const initPublicFilesPromise = initPublicFiles(config);
     const { root, server: serverConfig } = config;
     const httpsOptions = await resolveHttpsConfig(config.server.https);
     const { middlewareMode } = serverConfig;
@@ -59685,6 +59793,7 @@ async function _createServer(inlineConfig = {}, options) {
             process.stdin.on('end', exitProcess);
         }
     }
+    const publicFiles = await initPublicFilesPromise;
     const onHMRUpdate = async (file, configOnly) => {
         if (serverConfig.hmr !== false) {
             try {
@@ -59701,6 +59810,9 @@ async function _createServer(inlineConfig = {}, options) {
     const onFileAddUnlink = async (file, isUnlink) => {
         file = normalizePath$3(file);
         await container.watchChange(file, { event: isUnlink ? 'delete' : 'create' });
+        if (config.publicDir && file.startsWith(config.publicDir)) {
+            publicFiles[isUnlink ? 'delete' : 'add'](file.slice(config.publicDir.length));
+        }
         await handleFileAddUnlink(file, server, isUnlink);
         await onHMRUpdate(file, true);
     };
@@ -59772,7 +59884,7 @@ async function _createServer(inlineConfig = {}, options) {
     // this applies before the transform middleware so that these files are served
     // as-is without transforms.
     if (config.publicDir) {
-        middlewares.use(servePublicMiddleware(server));
+        middlewares.use(servePublicMiddleware(server, publicFiles));
     }
     // main transform middleware
     middlewares.use(transformMiddleware(server));
@@ -60266,6 +60378,11 @@ function isNodeWithinCircularImports(node, nodeChain, currentChain = [node], tra
         // Node may import itself which is safe
         if (importer === node)
             continue;
+        // a PostCSS plugin like Tailwind JIT may register
+        // any file as a dependency to a CSS file.
+        // But in that case, the actual dependency chain is separate.
+        if (isCSSRequest(importer.url))
+            continue;
         // Check circular imports
         const importerIndex = nodeChain.indexOf(importer);
         if (importerIndex > -1) {
@@ -60930,7 +61047,8 @@ function webWorkerPlugin(config) {
                         : null,
                 });
             };
-            if (code.match(workerAssetUrlRE)) {
+            workerAssetUrlRE.lastIndex = 0;
+            if (workerAssetUrlRE.test(code)) {
                 const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(outputOptions.format, config.isWorker);
                 let match;
                 s = new MagicString(code);
@@ -61088,9 +61206,8 @@ function importAnalysisPlugin(config) {
                 return null;
             }
             const ssr = options?.ssr === true;
-            const prettyImporter = prettifyUrl(importer, root);
             if (canSkipImportAnalysis(importer)) {
-                debug$4?.(colors$1.dim(`[skipped] ${prettyImporter}`));
+                debug$4?.(colors$1.dim(`[skipped] ${prettifyUrl(importer, root)}`));
                 return null;
             }
             const start = performance.now();
@@ -61120,7 +61237,7 @@ function importAnalysisPlugin(config) {
             }
             if (!imports.length && !this._addedImports) {
                 importerModule.isSelfAccepting = false;
-                debug$4?.(`${timeFrom(start)} ${colors$1.dim(`[no imports] ${prettyImporter}`)}`);
+                debug$4?.(`${timeFrom(start)} ${colors$1.dim(`[no imports] ${prettifyUrl(importer, root)}`)}`);
                 return source;
             }
             let hasHMR = false;
@@ -61202,7 +61319,7 @@ function importAnalysisPlugin(config) {
                     // query can break 3rd party plugin's extension checks.
                     if ((isRelative || isSelfImport) &&
                         !hasImportInQueryParamsRE.test(url) &&
-                        !url.match(DEP_VERSION_RE)) {
+                        !DEP_VERSION_RE.test(url)) {
                         const versionMatch = importer.match(DEP_VERSION_RE);
                         if (versionMatch) {
                             url = injectQuery(url, versionMatch[1]);
@@ -61320,7 +61437,7 @@ function importAnalysisPlugin(config) {
                     if (url !== specifier) {
                         let rewriteDone = false;
                         if (depsOptimizer?.isOptimizedDepFile(resolvedId) &&
-                            !resolvedId.match(optimizedDepChunkRE$1)) {
+                            !optimizedDepChunkRE$1.test(resolvedId)) {
                             // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
                             // internal optimized chunks don't need es interop and are excluded
                             // The browserHash in resolvedId could be stale in which case there will be a full
@@ -61331,7 +61448,7 @@ function importAnalysisPlugin(config) {
                                 // Non-entry dynamic imports from dependencies will reach here as there isn't
                                 // optimize info for them, but they don't need es interop. If the request isn't
                                 // a dynamic import, then it is an internal Vite error
-                                if (!file.match(optimizedDepDynamicRE$1)) {
+                                if (!optimizedDepDynamicRE$1.test(file)) {
                                     config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
                                 }
                             }
@@ -61427,7 +61544,7 @@ function importAnalysisPlugin(config) {
                         ? `[accepts-exports]`
                         : acceptedUrls.size
                             ? `[accepts-deps]`
-                            : `[detected api usage]`} ${prettyImporter}`);
+                            : `[detected api usage]`} ${prettifyUrl(importer, root)}`);
                 // inject hot context
                 str().prepend(`import { createHotContext as __vite__createHotContext } from "${clientPublicPath}";` +
                     `import.meta.hot = __vite__createHotContext(${JSON.stringify(normalizeHmrUrl(importerModule.url))});`);
@@ -61477,7 +61594,7 @@ function importAnalysisPlugin(config) {
                     handlePrunedModules(prunedImports, server);
                 }
             }
-            debug$4?.(`${timeFrom(start)} ${colors$1.dim(`[${importedUrls.size} imports rewritten] ${prettyImporter}`)}`);
+            debug$4?.(`${timeFrom(start)} ${colors$1.dim(`[${importedUrls.size} imports rewritten] ${prettifyUrl(importer, root)}`)}`);
             if (s) {
                 return transformStableResult(s, importer, config);
             }
@@ -61997,20 +62114,17 @@ function workerImportMetaUrlPlugin(config) {
                 const query = parseRequest(id);
                 let s;
                 const cleanString = stripLiteral(code);
-                const workerImportMetaUrlRE = /\bnew\s+(?:Worker|SharedWorker)\s*\(\s*(new\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\))/g;
+                const workerImportMetaUrlRE = /\bnew\s+(?:Worker|SharedWorker)\s*\(\s*(new\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\))/dg;
                 let match;
                 while ((match = workerImportMetaUrlRE.exec(cleanString))) {
-                    const { 0: allExp, 1: exp, 2: emptyUrl, index } = match;
-                    const urlIndex = allExp.indexOf(exp) + index;
-                    const urlStart = cleanString.indexOf(emptyUrl, index);
-                    const urlEnd = urlStart + emptyUrl.length;
+                    const [[, endIndex], [expStart, expEnd], [urlStart, urlEnd]] = match.indices;
                     const rawUrl = code.slice(urlStart, urlEnd);
                     // potential dynamic template string
                     if (rawUrl[0] === '`' && rawUrl.includes('${')) {
-                        this.error(`\`new URL(url, import.meta.url)\` is not supported in dynamic template string.`, urlIndex);
+                        this.error(`\`new URL(url, import.meta.url)\` is not supported in dynamic template string.`, expStart);
                     }
                     s ||= new MagicString(code);
-                    const workerType = getWorkerType(code, cleanString, index + allExp.length);
+                    const workerType = getWorkerType(code, cleanString, endIndex);
                     const url = rawUrl.slice(1, -1);
                     let file;
                     if (url[0] === '.') {
@@ -62039,7 +62153,7 @@ function workerImportMetaUrlPlugin(config) {
                         builtUrl = injectQuery(builtUrl, WORKER_FILE_ID);
                         builtUrl = injectQuery(builtUrl, `type=${workerType}`);
                     }
-                    s.update(urlIndex, urlIndex + exp.length, 
+                    s.update(expStart, expEnd, 
                     // add `'' +` to skip vite:asset-import-meta-url plugin
                     `new URL('' + ${JSON.stringify(builtUrl)}, import.meta.url)`);
                 }
@@ -62083,13 +62197,11 @@ function assetImportMetaUrlPlugin(config) {
                 code.includes('new URL') &&
                 code.includes(`import.meta.url`)) {
                 let s;
-                const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/g;
+                const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/dg;
                 const cleanString = stripLiteral(code);
                 let match;
                 while ((match = assetImportMetaUrlRE.exec(cleanString))) {
-                    const { 0: exp, 1: emptyUrl, index } = match;
-                    const urlStart = cleanString.indexOf(emptyUrl, index);
-                    const urlEnd = urlStart + emptyUrl.length;
+                    const [[startIndex, endIndex], [urlStart, urlEnd]] = match.indices;
                     const rawUrl = code.slice(urlStart, urlEnd);
                     if (!s)
                         s = new MagicString(code);
@@ -62118,7 +62230,7 @@ function assetImportMetaUrlPlugin(config) {
                                 // A hack to allow 'as' & 'query' exist at the same time
                                 query: injectQuery(queryString, 'url'),
                             };
-                            s.update(index, index + exp.length, `new URL((import.meta.glob(${JSON.stringify(pattern)}, ${JSON.stringify(globOptions)}))[${pureUrl}], import.meta.url)`);
+                            s.update(startIndex, endIndex, `new URL((import.meta.glob(${JSON.stringify(pattern)}, ${JSON.stringify(globOptions)}))[${pureUrl}], import.meta.url)`);
                             continue;
                         }
                     }
@@ -62159,11 +62271,11 @@ function assetImportMetaUrlPlugin(config) {
                         }
                     }
                     if (!builtUrl) {
-                        const rawExp = code.slice(index, index + exp.length);
+                        const rawExp = code.slice(startIndex, endIndex);
                         config.logger.warnOnce(`\n${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
                         builtUrl = url;
                     }
-                    s.update(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, import.meta.url)`);
+                    s.update(startIndex, endIndex, `new URL(${JSON.stringify(builtUrl)}, import.meta.url)`);
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -63433,9 +63545,10 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
         '@vite/client',
         '@vite/env',
     ];
+    const isUnlessEntry = (path) => !entries.includes(path);
     const externalUnlessEntry = ({ path }) => ({
         path,
-        external: !entries.includes(path),
+        external: isUnlessEntry(path),
     });
     const doTransformGlobImport = async (contents, id, loader) => {
         let transpiledContents;
@@ -63640,19 +63753,32 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             // should be faster than doing it in the catch-all via js
             // they are done after the bare import resolve because a package name
             // may end with these extensions
+            const setupExternalize = (filter, doExternalize) => {
+                build.onResolve({ filter }, ({ path }) => {
+                    return {
+                        path,
+                        external: doExternalize(path),
+                    };
+                });
+                // onResolve is not called for glob imports.
+                // we need to add that here as well until esbuild calls onResolve for glob imports.
+                // https://github.com/evanw/esbuild/issues/3317
+                build.onLoad({ filter, namespace: 'file' }, () => {
+                    const externalOnLoadResult = {
+                        loader: 'js',
+                        contents: 'export default {}',
+                    };
+                    return externalOnLoadResult;
+                });
+            };
             // css
-            build.onResolve({ filter: CSS_LANGS_RE }, externalUnlessEntry);
+            setupExternalize(CSS_LANGS_RE, isUnlessEntry);
             // json & wasm
-            build.onResolve({ filter: /\.(json|json5|wasm)$/ }, externalUnlessEntry);
+            setupExternalize(/\.(json|json5|wasm)$/, isUnlessEntry);
             // known asset types
-            build.onResolve({
-                filter: new RegExp(`\\.(${KNOWN_ASSET_TYPES.join('|')})$`),
-            }, externalUnlessEntry);
+            setupExternalize(new RegExp(`\\.(${KNOWN_ASSET_TYPES.join('|')})$`), isUnlessEntry);
             // known vite query types: ?worker, ?raw
-            build.onResolve({ filter: SPECIAL_QUERY_RE }, ({ path }) => ({
-                path,
-                external: true,
-            }));
+            setupExternalize(SPECIAL_QUERY_RE, () => true);
             // catch all -------------------------------------------------------------
             build.onResolve({
                 filter: /.*/,
@@ -64775,7 +64901,7 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
                 });
             }
             for (const o of Object.keys(meta.outputs)) {
-                if (!o.match(jsMapExtensionRE)) {
+                if (!jsMapExtensionRE.test(o)) {
                     const id = path$o
                         .relative(processingCacheDirOutputPath, o)
                         .replace(jsExtensionRE, '');
@@ -65343,7 +65469,7 @@ const isModernFlag = `__VITE_IS_MODERN__`;
 const preloadMethod = `__vitePreload`;
 const preloadMarker = `__VITE_PRELOAD__`;
 const preloadHelperId = '\0vite/preload-helper.js';
-const preloadMarkerWithQuote = new RegExp(`['"]${preloadMarker}['"]`);
+const preloadMarkerWithQuote = new RegExp(`['"]${preloadMarker}['"]`, 'g');
 const dynamicImportPrefixRE = /import\s*\(/;
 // TODO: abstract
 const optimizedDepChunkRE = /\/chunk-[A-Z\d]{8}\.js/;
@@ -65353,11 +65479,9 @@ function toRelativePath(filename, importer) {
     return relPath[0] === '.' ? relPath : `./${relPath}`;
 }
 function indexOfMatchInSlice(str, reg, pos = 0) {
-    if (pos !== 0) {
-        str = str.slice(pos);
-    }
-    const matcher = str.match(reg);
-    return matcher?.index !== undefined ? matcher.index + pos : -1;
+    reg.lastIndex = pos;
+    const result = reg.exec(str);
+    return result?.index ?? -1;
 }
 /**
  * Helper for preloading CSS and direct imports of async chunks in parallel to
@@ -65370,51 +65494,52 @@ function detectScriptRel() {
         : 'preload';
 }
 function preload(baseModule, deps, importerUrl) {
+    let promise = Promise.resolve();
     // @ts-expect-error __VITE_IS_MODERN__ will be replaced with boolean later
-    if (!__VITE_IS_MODERN__ || !deps || deps.length === 0) {
-        return baseModule();
-    }
-    const links = document.getElementsByTagName('link');
-    return Promise.all(deps.map((dep) => {
-        // @ts-expect-error assetsURL is declared before preload.toString()
-        dep = assetsURL(dep, importerUrl);
-        if (dep in seen)
-            return;
-        seen[dep] = true;
-        const isCss = dep.endsWith('.css');
-        const cssSelector = isCss ? '[rel="stylesheet"]' : '';
-        const isBaseRelative = !!importerUrl;
-        // check if the file is already preloaded by SSR markup
-        if (isBaseRelative) {
-            // When isBaseRelative is true then we have `importerUrl` and `dep` is
-            // already converted to an absolute URL by the `assetsURL` function
-            for (let i = links.length - 1; i >= 0; i--) {
-                const link = links[i];
-                // The `links[i].href` is an absolute URL thanks to browser doing the work
-                // for us. See https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#reflecting-content-attributes-in-idl-attributes:idl-domstring-5
-                if (link.href === dep && (!isCss || link.rel === 'stylesheet')) {
-                    return;
+    if (__VITE_IS_MODERN__ && deps && deps.length > 0) {
+        const links = document.getElementsByTagName('link');
+        promise = Promise.all(deps.map((dep) => {
+            // @ts-expect-error assetsURL is declared before preload.toString()
+            dep = assetsURL(dep, importerUrl);
+            if (dep in seen)
+                return;
+            seen[dep] = true;
+            const isCss = dep.endsWith('.css');
+            const cssSelector = isCss ? '[rel="stylesheet"]' : '';
+            const isBaseRelative = !!importerUrl;
+            // check if the file is already preloaded by SSR markup
+            if (isBaseRelative) {
+                // When isBaseRelative is true then we have `importerUrl` and `dep` is
+                // already converted to an absolute URL by the `assetsURL` function
+                for (let i = links.length - 1; i >= 0; i--) {
+                    const link = links[i];
+                    // The `links[i].href` is an absolute URL thanks to browser doing the work
+                    // for us. See https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#reflecting-content-attributes-in-idl-attributes:idl-domstring-5
+                    if (link.href === dep && (!isCss || link.rel === 'stylesheet')) {
+                        return;
+                    }
                 }
             }
-        }
-        else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
-            return;
-        }
-        const link = document.createElement('link');
-        link.rel = isCss ? 'stylesheet' : scriptRel;
-        if (!isCss) {
-            link.as = 'script';
-            link.crossOrigin = '';
-        }
-        link.href = dep;
-        document.head.appendChild(link);
-        if (isCss) {
-            return new Promise((res, rej) => {
-                link.addEventListener('load', res);
-                link.addEventListener('error', () => rej(new Error(`Unable to preload CSS for ${dep}`)));
-            });
-        }
-    }))
+            else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+                return;
+            }
+            const link = document.createElement('link');
+            link.rel = isCss ? 'stylesheet' : scriptRel;
+            if (!isCss) {
+                link.as = 'script';
+                link.crossOrigin = '';
+            }
+            link.href = dep;
+            document.head.appendChild(link);
+            if (isCss) {
+                return new Promise((res, rej) => {
+                    link.addEventListener('load', res);
+                    link.addEventListener('error', () => rej(new Error(`Unable to preload CSS for ${dep}`)));
+                });
+            }
+        }));
+    }
+    return promise
         .then(() => baseModule())
         .catch((err) => {
         const e = new Event('vite:preloadError', { cancelable: true });
@@ -65565,7 +65690,7 @@ function buildImportAnalysisPlugin(config) {
                     const [url, resolvedId] = await normalizeUrl(specifier, start);
                     if (url !== specifier) {
                         if (depsOptimizer.isOptimizedDepFile(resolvedId) &&
-                            !resolvedId.match(optimizedDepChunkRE)) {
+                            !optimizedDepChunkRE.test(resolvedId)) {
                             const file = cleanUrl(resolvedId); // Remove ?v={hash}
                             const needsInterop = await optimizedDepNeedsInterop(depsOptimizer.metadata, file, config, ssr);
                             let rewriteDone = false;
@@ -65573,7 +65698,7 @@ function buildImportAnalysisPlugin(config) {
                                 // Non-entry dynamic imports from dependencies will reach here as there isn't
                                 // optimize info for them, but they don't need es interop. If the request isn't
                                 // a dynamic import, then it is an internal Vite error
-                                if (!file.match(optimizedDepDynamicRE)) {
+                                if (!optimizedDepDynamicRE.test(file)) {
                                     config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
                                 }
                             }
@@ -66395,7 +66520,7 @@ function onRollupWarning(warning, warn, config) {
                 const id = warning.id;
                 const exporter = warning.exporter;
                 // throw unless it's commonjs external...
-                if (!id || !/\?commonjs-external$/.test(id)) {
+                if (!id || !id.endsWith('?commonjs-external')) {
                     throw new Error(`[vite]: Rollup failed to resolve import "${exporter}" from "${id}".\n` +
                         `This is most likely unintended because it can break your application at runtime.\n` +
                         `If you do want to externalize this module explicitly add it to\n` +