vite 5.0.3 → 5.0.5

package/dist/node/chunks/{dep-vyqc0_aB.js → dep-MF_y65BT.js}

@@ -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));
@@ -12955,6 +12983,15 @@ function getPackageManagerCommand(type = 'install') {
 function isDevServer(server) {
     return 'pluginContainer' in server;
 }
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return { promise, resolve, reject };
+}
 
 /* eslint no-console: 0 */
 const LogLevels = {
@@ -14602,7 +14639,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;
@@ -17106,32 +17143,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
@@ -17141,11 +17189,6 @@ async function injectSourcesContent(map, file, logger) {
         debug$g?.(`Missing sources:\n  ` + missingSources.join(`\n  `));
     }
 }
-async function getOriginalContent(filepath) {
-    if (virtualSourceRE.test(filepath))
-        return undefined;
-    return await fsp.readFile(filepath, 'utf-8').catch(() => undefined);
-}
 function genSourceMapUrl(map) {
     if (typeof map !== 'string') {
         map = JSON.stringify(map);
@@ -28492,7 +28535,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}`);
@@ -28651,7 +28694,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}`);
@@ -28986,49 +29029,18 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
         if (data.exports) {
             entryPoint = resolveExportsOrImports(data, '.', options, targetWeb, 'exports');
         }
-        // handle edge case with browser and module field semantics
-        if (!entryPoint && targetWeb && options.mainFields.includes('browser')) {
-            // check browser field
-            // https://github.com/defunctzombie/package-browser-field-spec
-            const browserEntry = typeof data.browser === 'string'
-                ? data.browser
-                : isObject$1(data.browser) && data.browser['.'];
-            if (browserEntry) {
-                // check if the package also has a "module" field.
-                if (!options.isRequire &&
-                    options.mainFields.includes('module') &&
-                    typeof data.module === 'string' &&
-                    data.module !== browserEntry) {
-                    // if both are present, we may have a problem: some package points both
-                    // to ESM, with "module" targeting Node.js, while some packages points
-                    // "module" to browser ESM and "browser" to UMD/IIFE.
-                    // the heuristics here is to actually read the browser entry when
-                    // possible and check for hints of ESM. If it is not ESM, prefer "module"
-                    // instead; Otherwise, assume it's ESM and use it.
-                    const resolvedBrowserEntry = tryFsResolve(path$o.join(dir, browserEntry), options);
-                    if (resolvedBrowserEntry) {
-                        const content = fs$l.readFileSync(resolvedBrowserEntry, 'utf-8');
-                        if (hasESMSyntax(content)) {
-                            // likely ESM, prefer browser
-                            entryPoint = browserEntry;
-                        }
-                        else {
-                            // non-ESM, UMD or IIFE or CJS(!!! e.g. firebase 7.x), prefer module
-                            entryPoint = data.module;
-                        }
-                    }
-                }
-                else {
-                    entryPoint = browserEntry;
-                }
-            }
-        }
         // fallback to mainFields if still not resolved
         if (!entryPoint) {
             for (const field of options.mainFields) {
-                if (field === 'browser')
-                    continue; // already checked above
-                if (typeof data[field] === 'string') {
+                if (field === 'browser') {
+                    if (targetWeb) {
+                        entryPoint = tryResolveBrowserEntry(dir, data, options);
+                        if (entryPoint) {
+                            break;
+                        }
+                    }
+                }
+                else if (typeof data[field] === 'string') {
                     entryPoint = data[field];
                     break;
                 }
@@ -29187,6 +29199,43 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
         }
     }
 }
+function tryResolveBrowserEntry(dir, data, options) {
+    // handle edge case with browser and module field semantics
+    // check browser field
+    // https://github.com/defunctzombie/package-browser-field-spec
+    const browserEntry = typeof data.browser === 'string'
+        ? data.browser
+        : isObject$1(data.browser) && data.browser['.'];
+    if (browserEntry) {
+        // check if the package also has a "module" field.
+        if (!options.isRequire &&
+            options.mainFields.includes('module') &&
+            typeof data.module === 'string' &&
+            data.module !== browserEntry) {
+            // if both are present, we may have a problem: some package points both
+            // to ESM, with "module" targeting Node.js, while some packages points
+            // "module" to browser ESM and "browser" to UMD/IIFE.
+            // the heuristics here is to actually read the browser entry when
+            // possible and check for hints of ESM. If it is not ESM, prefer "module"
+            // instead; Otherwise, assume it's ESM and use it.
+            const resolvedBrowserEntry = tryFsResolve(path$o.join(dir, browserEntry), options);
+            if (resolvedBrowserEntry) {
+                const content = fs$l.readFileSync(resolvedBrowserEntry, 'utf-8');
+                if (hasESMSyntax(content)) {
+                    // likely ESM, prefer browser
+                    return browserEntry;
+                }
+                else {
+                    // non-ESM, UMD or IIFE or CJS(!!! e.g. firebase 7.x), prefer module
+                    return data.module;
+                }
+            }
+        }
+        else {
+            return browserEntry;
+        }
+    }
+}
 /**
  * given a relative path in pkg dir,
  * return a relative path in pkg dir,
@@ -37848,7 +37897,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;
@@ -37927,7 +37976,9 @@ 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 = 
+// eslint-disable-next-line regexp/no-unused-capturing-group -- https://github.com/ota-meshi/eslint-plugin-regexp/issues/675
+/(?<!(?<!\.\.)\.)\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;
@@ -38549,10 +38600,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,
@@ -38563,11 +38613,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));
@@ -39653,8 +39703,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-_rppyaaB.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-m-h4L35S.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-mpgFWQ-7.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-IrrVD4is.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -39662,12 +39712,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));
@@ -39719,7 +39769,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';
@@ -39933,6 +39983,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);
@@ -39941,7 +39993,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
@@ -39949,7 +40001,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);
@@ -40460,8 +40512,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
@@ -40883,16 +40935,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';
@@ -51363,6 +51423,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}`));
@@ -51370,7 +51432,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);
@@ -58388,9 +58450,7 @@ function send(req, res, content, type, options) {
     }
     // inject fallback sourcemap for js for improved debugging
     // https://github.com/vitejs/vite/pull/13514#issuecomment-1592431496
-    // for { mappings: "" }, we don't inject fallback sourcemap
-    // because it indicates generating a sourcemap is meaningless
-    else if (type === 'js' && map == null) {
+    else if (type === 'js' && (!map || map.mappings !== '')) {
         const code = content.toString();
         // if the code has existing inline sourcemap, assume it's correct and skip
         if (convertSourceMap.mapFileCommentRegex.test(code)) {
@@ -58399,15 +58459,11 @@ function send(req, res, content, type, options) {
         else {
             const urlWithoutTimestamp = removeTimestampQuery(req.url);
             const ms = new MagicString(code);
-            const map = ms.generateMap({
+            content = getCodeWithSourcemap(type, code, ms.generateMap({
                 source: path$o.basename(urlWithoutTimestamp),
                 hires: 'boundary',
-                includeContent: !options.originalContent,
-            });
-            if (options.originalContent != null) {
-                map.sourcesContent = [options.originalContent];
-            }
-            content = getCodeWithSourcemap(type, code, map);
+                includeContent: true,
+            }));
         }
     }
     res.statusCode = 200;
@@ -58543,19 +58599,12 @@ function transformMiddleware(server) {
                     const depsOptimizer = getDepsOptimizer(server.config, false); // non-ssr
                     const type = isDirectCSSRequest(url) ? 'css' : 'js';
                     const isDep = DEP_VERSION_RE.test(url) || depsOptimizer?.isOptimizedDepUrl(url);
-                    let originalContent;
-                    if (type === 'js' && result.map == null) {
-                        const filepath = (await server.moduleGraph.getModuleByUrl(url, false))?.file;
-                        originalContent =
-                            filepath != null ? await getOriginalContent(filepath) : undefined;
-                    }
                     return send(req, res, result.code, type, {
                         etag: result.etag,
                         // allow browser to cache npm deps!
                         cacheControl: isDep ? 'max-age=31536000,immutable' : 'no-cache',
                         headers: server.config.server.headers,
                         map: result.map,
-                        originalContent,
                     });
                 }
             }
@@ -58685,7 +58734,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('/');
@@ -58705,7 +58753,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) => {
@@ -58876,7 +58926,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);
 }
 
@@ -59944,25 +60000,37 @@ async function restartServer(server) {
             },
         });
     }
-    let newServer = null;
-    try {
-        // delay ws server listen
-        newServer = await _createServer(inlineConfig, { ws: false });
-    }
-    catch (err) {
-        server.config.logger.error(err.message, {
-            timestamp: true,
-        });
-        server.config.logger.error('server restart failed', { timestamp: true });
-        return;
+    // Reinit the server by creating a new instance using the same inlineConfig
+    // This will triger a reload of the config file and re-create the plugins and
+    // middlewares. We then assign all properties of the new server to the existing
+    // server instance and set the user instance to be used in the new server.
+    // This allows us to keep the same server instance for the user.
+    {
+        let newServer = null;
+        try {
+            // delay ws server listen
+            newServer = await _createServer(inlineConfig, { ws: false });
+        }
+        catch (err) {
+            server.config.logger.error(err.message, {
+                timestamp: true,
+            });
+            server.config.logger.error('server restart failed', { timestamp: true });
+            return;
+        }
+        await server.close();
+        // Assign new server props to existing server instance
+        const middlewares = server.middlewares;
+        newServer._configServerPort = server._configServerPort;
+        newServer._currentServerPort = server._currentServerPort;
+        Object.assign(server, newServer);
+        // Keep the same connect instance so app.use(vite.middlewares) works
+        // after a restart in middlewareMode (.route is always '/')
+        middlewares.stack = newServer.middlewares.stack;
+        server.middlewares = middlewares;
+        // Rebind internal server variable so functions reference the user server
+        newServer._setInternalServer(server);
     }
-    await server.close();
-    // Assign new server props to existing server instance
-    newServer._configServerPort = server._configServerPort;
-    newServer._currentServerPort = server._currentServerPort;
-    Object.assign(server, newServer);
-    // Rebind internal server variable so functions reference the user server
-    newServer._setInternalServer(server);
     const { logger, server: { port, middlewareMode }, } = server.config;
     if (!middlewareMode) {
         await server.listen(port, true);
@@ -59973,7 +60041,7 @@ async function restartServer(server) {
     logger.info('server restarted.', { timestamp: true });
     if (shortcutsOptions) {
         shortcutsOptions.print = false;
-        bindCLIShortcuts(newServer, shortcutsOptions);
+        bindCLIShortcuts(server, shortcutsOptions);
     }
 }
 /**
@@ -60257,6 +60325,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) {
@@ -60474,15 +60547,12 @@ function definePlugin(config) {
     const isBuildLib = isBuild && config.build.lib;
     // ignore replace process.env in lib build
     const processEnv = {};
-    const processNodeEnv = {};
     if (!isBuildLib) {
         const nodeEnv = process.env.NODE_ENV || config.mode;
         Object.assign(processEnv, {
             'process.env': `{}`,
             'global.process.env': `{}`,
             'globalThis.process.env': `{}`,
-        });
-        Object.assign(processNodeEnv, {
             'process.env.NODE_ENV': JSON.stringify(nodeEnv),
             'global.process.env.NODE_ENV': JSON.stringify(nodeEnv),
             'globalThis.process.env.NODE_ENV': JSON.stringify(nodeEnv),
@@ -60515,11 +60585,10 @@ function definePlugin(config) {
     function generatePattern(ssr) {
         const replaceProcessEnv = !ssr || config.ssr?.target === 'webworker';
         const define = {
-            ...(replaceProcessEnv ? processNodeEnv : {}),
+            ...(replaceProcessEnv ? processEnv : {}),
             ...importMetaKeys,
             ...userDefine,
             ...importMetaFallbackKeys,
-            ...(replaceProcessEnv ? processEnv : {}),
         };
         // Additional define fixes based on `ssr` value
         if ('import.meta.env.SSR' in define) {
@@ -60925,7 +60994,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);
@@ -61083,9 +61153,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();
@@ -61115,7 +61184,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;
@@ -61197,7 +61266,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]);
@@ -61315,7 +61384,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
@@ -61326,7 +61395,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`));
                                 }
                             }
@@ -61422,7 +61491,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))});`);
@@ -61472,7 +61541,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);
             }
@@ -61992,20 +62061,19 @@ 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 = 
+                // eslint-disable-next-line regexp/no-unused-capturing-group -- https://github.com/ota-meshi/eslint-plugin-regexp/issues/675
+                /\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] === '.') {
@@ -62034,7 +62102,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)`);
                 }
@@ -62078,13 +62146,13 @@ 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 = 
+                // eslint-disable-next-line regexp/no-unused-capturing-group -- https://github.com/ota-meshi/eslint-plugin-regexp/issues/675
+                /\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);
@@ -62113,7 +62181,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;
                         }
                     }
@@ -62154,11 +62222,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);
@@ -63428,9 +63496,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;
@@ -63635,19 +63704,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: /.*/,
@@ -63952,7 +64034,7 @@ async function createDepsOptimizer(config, server) {
             newDepsToLog = [];
         }
     };
-    let depOptimizationProcessing = newDepOptimizationProcessing();
+    let depOptimizationProcessing = promiseWithResolvers();
     let depOptimizationProcessingQueue = [];
     const resolveEnqueuedProcessingPromises = () => {
         // Resolve all the processings (including the ones which were delayed)
@@ -64047,7 +64129,7 @@ async function createDepsOptimizer(config, server) {
         depOptimizationProcessingQueue.push(depOptimizationProcessing);
         // Create a new promise for the next rerun, discovered missing
         // dependencies will be assigned this promise from this point
-        depOptimizationProcessing = newDepOptimizationProcessing();
+        depOptimizationProcessing = promiseWithResolvers();
     }
     function prepareKnownDeps() {
         const knownDeps = {};
@@ -64770,7 +64852,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, '');
@@ -64954,13 +65036,6 @@ async function addManuallyIncludedOptimizeDeps(deps, config, ssr, extra = [], fi
         }
     }
 }
-function newDepOptimizationProcessing() {
-    let resolve;
-    const promise = new Promise((_resolve) => {
-        resolve = _resolve;
-    });
-    return { promise, resolve: resolve };
-}
 // Convert to { id: src }
 function depsFromOptimizedDepInfo(depsInfo) {
     const obj = {};
@@ -65327,7 +65402,6 @@ var index = {
 	initDepsOptimizerMetadata: initDepsOptimizerMetadata,
 	initDevSsrDepsOptimizer: initDevSsrDepsOptimizer,
 	loadCachedDepOptimizationMetadata: loadCachedDepOptimizationMetadata,
-	newDepOptimizationProcessing: newDepOptimizationProcessing,
 	optimizeDeps: optimizeDeps,
 	optimizeServerSsrDeps: optimizeServerSsrDeps,
 	optimizedDepInfoFromFile: optimizedDepInfoFromFile,
@@ -65346,7 +65420,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/;
@@ -65356,11 +65430,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
@@ -65373,51 +65445,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 });
@@ -65568,7 +65641,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;
@@ -65576,7 +65649,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`));
                                 }
                             }
@@ -66398,7 +66471,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` +