vite 5.1.5 → 5.1.6

package/dist/node/chunks/{dep-G-px366b.js → dep-jvB8WLp9.js}

@@ -250,7 +250,6 @@ const NULL_BYTE_PLACEHOLDER = `__x00__`;
 let SOURCEMAPPING_URL = 'sourceMa';
 SOURCEMAPPING_URL += 'ppingURL';
 const VITE_RUNTIME_SOURCEMAPPING_SOURCE = '//# sourceMappingSource=vite-runtime';
-const VITE_RUNTIME_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
 
 const isWindows$5 = typeof process !== 'undefined' && process.platform === 'win32';
 /**
@@ -285,6 +284,15 @@ function withTrailingSlash(path) {
     }
     return path;
 }
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const AsyncFunction = async function () { }.constructor;
+// https://github.com/nodejs/node/issues/43047#issuecomment-1564068099
+const asyncFunctionDeclarationPaddingLineCount = 
+/** #__PURE__ */ (() => {
+    const body = '/*code*/';
+    const source = new AsyncFunction('a', 'b', body).toString();
+    return source.slice(0, source.indexOf(body)).split('\n').length - 1;
+})();
 
 // @ts-check
 /** @typedef { import('estree').BaseNode} BaseNode */
@@ -6702,9 +6710,12 @@ class Mappings {
 
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
 			let contentLineEnd = content.indexOf('\n', 0);
 			let previousContentLineEnd = -1;
-			while (contentLineEnd >= 0) {
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
 				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
 				if (nameIndex >= 0) {
 					segment.push(nameIndex);
@@ -10319,6 +10330,7 @@ class TraceMap {
         this.sourceRoot = sourceRoot;
         this.sources = sources;
         this.sourcesContent = sourcesContent;
+        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
         const from = resolve$1(sourceRoot || '', stripFilename(mapUrl));
         this.resolvedSources = sources.map((s) => resolve$1(s || '', from));
         const { mappings } = parsed;
@@ -10339,7 +10351,7 @@ class TraceMap {
  * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
  * with public access modifiers.
  */
-function cast(map) {
+function cast$2(map) {
     return map;
 }
 /**
@@ -10347,7 +10359,7 @@ function cast(map) {
  */
 function decodedMappings(map) {
     var _a;
-    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
+    return ((_a = cast$2(map))._decoded || (_a._decoded = decode(cast$2(map)._encoded)));
 }
 /**
  * A low-level API to find the segment associated with a generated line/column (think, from a
@@ -10360,7 +10372,7 @@ function traceSegment(map, line, column) {
     if (line >= decoded.length)
         return null;
     const segments = decoded[line];
-    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+    const index = traceSegmentInternal(segments, cast$2(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
     return index === -1 ? null : segments[index];
 }
 /**
@@ -10381,7 +10393,7 @@ function originalPositionFor$1(map, needle) {
     if (line >= decoded.length)
         return OMapping(null, null, null, null);
     const segments = decoded[line];
-    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    const index = traceSegmentInternal(segments, cast$2(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
     if (index === -1)
         return OMapping(null, null, null, null);
     const segment = segments[index];
@@ -10405,15 +10417,6 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     return index;
 }
 
-/**
- * Gets the index associated with `key` in the backing array, if it is already present.
- */
-let get;
-/**
- * Puts `key` into the backing array, if it is not already present. Returns
- * the index of the `key` in the backing array.
- */
-let put;
 /**
  * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
  * index of the `key` in the backing array.
@@ -10428,17 +10431,48 @@ class SetArray {
         this.array = [];
     }
 }
-(() => {
-    get = (strarr, key) => strarr._indexes[key];
-    put = (strarr, key) => {
-        // The key may or may not be present. If it is present, it's a number.
-        const index = get(strarr, key);
-        if (index !== undefined)
-            return index;
-        const { array, _indexes: indexes } = strarr;
-        return (indexes[key] = array.push(key) - 1);
-    };
-})();
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+ * with public access modifiers.
+ */
+function cast$1(set) {
+    return set;
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+function get(setarr, key) {
+    return cast$1(setarr)._indexes[key];
+}
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+function put(setarr, key) {
+    // The key may or may not be present. If it is present, it's a number.
+    const index = get(setarr, key);
+    if (index !== undefined)
+        return index;
+    const { array, _indexes: indexes } = cast$1(setarr);
+    const length = array.push(key);
+    return (indexes[key] = length - 1);
+}
+/**
+ * Removes the key, if it exists in the set.
+ */
+function remove(setarr, key) {
+    const index = get(setarr, key);
+    if (index === undefined)
+        return;
+    const { array, _indexes: indexes } = cast$1(setarr);
+    for (let i = index + 1; i < array.length; i++) {
+        const k = array[i];
+        array[i - 1] = k;
+        indexes[k]--;
+    }
+    indexes[key] = undefined;
+    array.pop();
+}
 
 const COLUMN = 0;
 const SOURCES_INDEX = 1;
@@ -10447,88 +10481,100 @@ const SOURCE_COLUMN = 3;
 const NAMES_INDEX = 4;
 
 const NO_NAME = -1;
+/**
+ * Provides the state to generate a sourcemap.
+ */
+class GenMapping {
+    constructor({ file, sourceRoot } = {}) {
+        this._names = new SetArray();
+        this._sources = new SetArray();
+        this._sourcesContent = [];
+        this._mappings = [];
+        this.file = file;
+        this.sourceRoot = sourceRoot;
+        this._ignoreList = new SetArray();
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
+}
 /**
  * Same as `addSegment`, but will only add the segment if it generates useful information in the
  * resulting map. This only works correctly if segments are added **in order**, meaning you should
  * not add a segment with a lower generated line/column than one that came before.
  */
-let maybeAddSegment;
+const maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+    return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+};
 /**
  * Adds/removes the content of the source file to the source map.
  */
-let setSourceContent;
+function setSourceContent(map, source, content) {
+    const { _sources: sources, _sourcesContent: sourcesContent } = cast(map);
+    const index = put(sources, source);
+    sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+    const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast(map);
+    const index = put(sources, source);
+    if (index === sourcesContent.length)
+        sourcesContent[index] = null;
+    if (ignore)
+        put(ignoreList, index);
+    else
+        remove(ignoreList, index);
+}
 /**
  * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
  * a sourcemap, or to JSON.stringify.
  */
-let toDecodedMap;
+function toDecodedMap(map) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList, } = cast(map);
+    removeEmptyFinalLines(mappings);
+    return {
+        version: 3,
+        file: map.file || undefined,
+        names: names.array,
+        sourceRoot: map.sourceRoot || undefined,
+        sources: sources.array,
+        sourcesContent,
+        mappings,
+        ignoreList: ignoreList.array,
+    };
+}
 /**
  * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
  * a sourcemap, or to JSON.stringify.
  */
-let toEncodedMap;
+function toEncodedMap(map) {
+    const decoded = toDecodedMap(map);
+    return Object.assign(Object.assign({}, decoded), { mappings: encode$1(decoded.mappings) });
+}
 // This split declaration is only so that terser can elminiate the static initialization block.
-let addSegmentInternal;
-/**
- * Provides the state to generate a sourcemap.
- */
-class GenMapping {
-    constructor({ file, sourceRoot } = {}) {
-        this._names = new SetArray();
-        this._sources = new SetArray();
-        this._sourcesContent = [];
-        this._mappings = [];
-        this.file = file;
-        this.sourceRoot = sourceRoot;
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = cast(map);
+    const line = getLine(mappings, genLine);
+    const index = getColumnIndex(line, genColumn);
+    if (!source) {
+        if (skipable && skipSourceless(line, index))
+            return;
+        return insert(line, index, [genColumn]);
+    }
+    const sourcesIndex = put(sources, source);
+    const namesIndex = name ? put(names, name) : NO_NAME;
+    if (sourcesIndex === sourcesContent.length)
+        sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
+    if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+        return;
     }
+    return insert(line, index, name
+        ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+        : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
 }
-(() => {
-    maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
-        return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
-    };
-    setSourceContent = (map, source, content) => {
-        const { _sources: sources, _sourcesContent: sourcesContent } = map;
-        sourcesContent[put(sources, source)] = content;
-    };
-    toDecodedMap = (map) => {
-        const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
-        removeEmptyFinalLines(mappings);
-        return {
-            version: 3,
-            file: file || undefined,
-            names: names.array,
-            sourceRoot: sourceRoot || undefined,
-            sources: sources.array,
-            sourcesContent,
-            mappings,
-        };
-    };
-    toEncodedMap = (map) => {
-        const decoded = toDecodedMap(map);
-        return Object.assign(Object.assign({}, decoded), { mappings: encode$1(decoded.mappings) });
-    };
-    // Internal helpers
-    addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
-        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
-        const line = getLine(mappings, genLine);
-        const index = getColumnIndex(line, genColumn);
-        if (!source) {
-            if (skipable && skipSourceless(line, index))
-                return;
-            return insert(line, index, [genColumn]);
-        }
-        const sourcesIndex = put(sources, source);
-        const namesIndex = name ? put(names, name) : NO_NAME;
-        if (sourcesIndex === sourcesContent.length)
-            sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
-        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
-            return;
-        }
-        return insert(line, index, name
-            ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
-            : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
-    };
-})();
 function getLine(mappings, index) {
     for (let i = mappings.length; i <= index; i++) {
         mappings[i] = [];
@@ -10587,17 +10633,18 @@ function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIn
         namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
 }
 
-const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null);
+const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);
 const EMPTY_SOURCES = [];
-function SegmentObject(source, line, column, name, content) {
-    return { source, line, column, name, content };
+function SegmentObject(source, line, column, name, content, ignore) {
+    return { source, line, column, name, content, ignore };
 }
-function Source(map, sources, source, content) {
+function Source(map, sources, source, content, ignore) {
     return {
         map,
         sources,
         source,
         content,
+        ignore,
     };
 }
 /**
@@ -10605,14 +10652,14 @@ function Source(map, sources, source, content) {
  * (which may themselves be SourceMapTrees).
  */
 function MapSource(map, sources) {
-    return Source(map, sources, '', null);
+    return Source(map, sources, '', null, false);
 }
 /**
  * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
  * segment tracing ends at the `OriginalSource`.
  */
-function OriginalSource(source, content) {
-    return Source(null, EMPTY_SOURCES, source, content);
+function OriginalSource(source, content, ignore) {
+    return Source(null, EMPTY_SOURCES, source, content, ignore);
 }
 /**
  * traceMappings is only called on the root level SourceMapTree, and begins the process of
@@ -10641,10 +10688,12 @@ function traceMappings(tree) {
                 if (traced == null)
                     continue;
             }
-            const { column, line, name, content, source } = traced;
+            const { column, line, name, content, source, ignore } = traced;
             maybeAddSegment(gen, i, genCol, source, line, column, name);
             if (source && content != null)
                 setSourceContent(gen, source, content);
+            if (ignore)
+                setIgnore(gen, source, true);
         }
     }
     return gen;
@@ -10655,7 +10704,7 @@ function traceMappings(tree) {
  */
 function originalPositionFor(source, line, column, name) {
     if (!source.map) {
-        return SegmentObject(source.source, line, column, name, source.content);
+        return SegmentObject(source.source, line, column, name, source.content, source.ignore);
     }
     const segment = traceSegment(source.map, line, column);
     // If we couldn't find a segment, then this doesn't exist in the sourcemap.
@@ -10700,7 +10749,7 @@ function buildSourceMapTree(input, loader) {
     return tree;
 }
 function build$2(map, loader, importer, importerDepth) {
-    const { resolvedSources, sourcesContent } = map;
+    const { resolvedSources, sourcesContent, ignoreList } = map;
     const depth = importerDepth + 1;
     const children = resolvedSources.map((sourceFile, i) => {
         // The loading context gives the loader more information about why this file is being loaded
@@ -10712,20 +10761,22 @@ function build$2(map, loader, importer, importerDepth) {
             depth,
             source: sourceFile || '',
             content: undefined,
+            ignore: undefined,
         };
         // Use the provided loader callback to retrieve the file's sourcemap.
         // TODO: We should eventually support async loading of sourcemap files.
         const sourceMap = loader(ctx.source, ctx);
-        const { source, content } = ctx;
+        const { source, content, ignore } = ctx;
         // If there is a sourcemap, then we need to recurse into it to load its source files.
         if (sourceMap)
             return build$2(new TraceMap(sourceMap, source), loader, source, depth);
-        // Else, it's an an unmodified source file.
+        // Else, it's an unmodified source file.
         // The contents of this unmodified source file can be overridden via the loader context,
         // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
         // the importing sourcemap's `sourcesContent` field.
         const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
-        return OriginalSource(source, sourceContent);
+        const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;
+        return OriginalSource(source, sourceContent, ignored);
     });
     return MapSource(map, children);
 }
@@ -10741,6 +10792,7 @@ class SourceMap {
         this.file = out.file;
         this.mappings = out.mappings;
         this.names = out.names;
+        this.ignoreList = out.ignoreList;
         this.sourceRoot = out.sourceRoot;
         this.sources = out.sources;
         if (!options.excludeContent) {
@@ -12873,7 +12925,7 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
             continue;
         }
         if (Array.isArray(existing) || Array.isArray(value)) {
-            merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
+            merged[key] = [...arraify(existing), ...arraify(value)];
             continue;
         }
         if (isObject$1(existing) && isObject$1(value)) {
@@ -14020,7 +14072,7 @@ async function parse$f(filename, options) {
 		/** @type {Promise<import('./public.d.ts').TSConfckParseResult>}*/
 		promise
 	} = makePromise();
-	cache?.setParseResult(filename, promise);
+	cache?.setParseResult(filename, promise, true);
 	try {
 		let tsconfigFile =
 			(await resolveTSConfigJson(filename, cache)) || (await find(filename, options));
@@ -14059,7 +14111,7 @@ async function getParsedDeep(filename, cache, options) {
 			parseExtends(result, cache),
 			parseReferences(result, options)
 		]).then(() => result);
-		cache.setParseResult(filename, promise);
+		cache.setParseResult(filename, promise, true);
 		return promise;
 	}
 	return result;
@@ -14073,7 +14125,11 @@ async function getParsedDeep(filename, cache, options) {
  * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
  */
 async function parseFile$1(tsconfigFile, cache, skipCache) {
-	if (!skipCache && cache?.hasParseResult(tsconfigFile)) {
+	if (
+		!skipCache &&
+		cache?.hasParseResult(tsconfigFile) &&
+		!cache.getParseResult(tsconfigFile)._isRootFile_
+	) {
 		return cache.getParseResult(tsconfigFile);
 	}
 	const promise = promises$1
@@ -14095,7 +14151,10 @@ async function parseFile$1(tsconfigFile, cache, skipCache) {
 				e
 			);
 		});
-	if (!skipCache) {
+	if (
+		!skipCache &&
+		(!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_)
+	) {
 		cache?.setParseResult(tsconfigFile, promise);
 	}
 	return promise;
@@ -14477,9 +14536,17 @@ class TSConfckCache {
 	 * @internal
 	 * @private
 	 * @param file
+	 * @param {boolean} isRootFile a flag to check if current file which involking the parse() api, used to distinguish the normal cache which only parsed by parseFile()
 	 * @param {Promise<T>} result
 	 */
-	setParseResult(file, result) {
+	setParseResult(file, result, isRootFile = false) {
+		// _isRootFile_ is a temporary property for Promise result, used to prevent deadlock with cache
+		Object.defineProperty(result, '_isRootFile_', {
+			value: isRootFile,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
 		this.#parsed.set(file, result);
 		result
 			.then((parsed) => {
@@ -32106,8 +32173,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-OHeF5w5D.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-WMYkPWs9.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-sFlFG1c_.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-pxQDj-UY.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -49077,18 +49144,23 @@ const inlineRE = /[?&]inline\b/;
 const WORKER_FILE_ID = 'worker_file';
 const workerCache = new WeakMap();
 function saveEmitWorkerAsset(config, asset) {
-    const fileName = asset.fileName;
     const workerMap = workerCache.get(config.mainConfig || config);
-    workerMap.assets.set(fileName, asset);
+    workerMap.assets.set(asset.fileName, asset);
 }
 async function bundleWorkerEntry(config, id) {
+    const input = cleanUrl(id);
+    const newBundleChain = [...config.bundleChain, input];
+    if (config.bundleChain.includes(input)) {
+        throw new Error('Circular worker imports detected. Vite does not support it. ' +
+            `Import chain: ${newBundleChain.map((id) => prettifyUrl(id, config.root)).join(' -> ')}`);
+    }
     // bundle the file as entry to support imports
     const { rollup } = await import('rollup');
     const { plugins, rollupOptions, format } = config.worker;
     const bundle = await rollup({
         ...rollupOptions,
-        input: cleanUrl(id),
-        plugins: await plugins(),
+        input,
+        plugins: await plugins(newBundleChain),
         onwarn(warning, warn) {
             onRollupWarning(warning, warn, config);
         },
@@ -49119,7 +49191,6 @@ async function bundleWorkerEntry(config, id) {
                 saveEmitWorkerAsset(config, {
                     fileName: outputChunk.fileName,
                     source: outputChunk.code,
-                    type: 'asset',
                 });
             }
         });
@@ -49138,7 +49209,6 @@ function emitSourcemapForWorkerEntry(config, chunk) {
             const mapFileName = chunk.fileName + '.map';
             saveEmitWorkerAsset(config, {
                 fileName: mapFileName,
-                type: 'asset',
                 source: data,
             });
         }
@@ -49163,7 +49233,6 @@ async function workerFileToUrl(config, id) {
         saveEmitWorkerAsset(config, {
             fileName,
             source: outputChunk.code,
-            type: 'asset',
         });
         workerMap.bundle.set(id, fileName);
     }
@@ -49260,8 +49329,6 @@ function webWorkerPlugin(config) {
             const workerMatch = workerOrSharedWorkerRE.exec(id);
             if (!workerMatch)
                 return;
-            // stringified url or `new URL(...)`
-            let url;
             const { format } = config.worker;
             const workerConstructor = workerMatch[1] === 'sharedworker' ? 'SharedWorker' : 'Worker';
             const workerType = isBuild
@@ -49273,8 +49340,12 @@ function webWorkerPlugin(config) {
         ${workerType === 'module' ? `type: "module",` : ''}
         name: options?.name
       }`;
+            let urlCode;
             if (isBuild) {
-                if (inlineRE.test(id)) {
+                if (isWorker && this.getModuleInfo(cleanUrl(id))?.isEntry) {
+                    urlCode = 'self.location.href';
+                }
+                else if (inlineRE.test(id)) {
                     const chunk = await bundleWorkerEntry(config, id);
                     const encodedJs = `const encodedJs = "${Buffer.from(chunk.code).toString('base64')}";`;
                     const code = 
@@ -49325,23 +49396,24 @@ function webWorkerPlugin(config) {
                     };
                 }
                 else {
-                    url = await workerFileToUrl(config, id);
+                    urlCode = JSON.stringify(await workerFileToUrl(config, id));
                 }
             }
             else {
-                url = await fileToUrl$1(cleanUrl(id), config, this);
+                let url = await fileToUrl$1(cleanUrl(id), config, this);
                 url = injectQuery(url, `${WORKER_FILE_ID}&type=${workerType}`);
+                urlCode = JSON.stringify(url);
             }
             if (urlRE.test(id)) {
                 return {
-                    code: `export default ${JSON.stringify(url)}`,
+                    code: `export default ${urlCode}`,
                     map: { mappings: '' }, // Empty sourcemap to suppress Rollup warning
                 };
             }
             return {
                 code: `export default function WorkerWrapper(options) {
           return new ${workerConstructor}(
-            ${JSON.stringify(url)},
+            ${urlCode},
             ${workerTypeOption}
           );
         }`,
@@ -49379,19 +49451,42 @@ function webWorkerPlugin(config) {
             }
             return result();
         },
-        generateBundle(opts) {
+        generateBundle(opts, bundle) {
             // @ts-expect-error asset emits are skipped in legacy bundle
             if (opts.__vite_skip_asset_emit__ || isWorker) {
                 return;
             }
             const workerMap = workerCache.get(config);
             workerMap.assets.forEach((asset) => {
-                this.emitFile(asset);
-                workerMap.assets.delete(asset.fileName);
+                const duplicateAsset = bundle[asset.fileName];
+                if (duplicateAsset) {
+                    const content = duplicateAsset.type === 'asset'
+                        ? duplicateAsset.source
+                        : duplicateAsset.code;
+                    // don't emit if the file name and the content is same
+                    if (isSameContent(content, asset.source)) {
+                        return;
+                    }
+                }
+                this.emitFile({
+                    type: 'asset',
+                    fileName: asset.fileName,
+                    source: asset.source,
+                });
             });
+            workerMap.assets.clear();
         },
     };
 }
+function isSameContent(a, b) {
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            return a === b;
+        }
+        return Buffer.from(a).equals(b);
+    }
+    return Buffer.from(b).equals(a);
+}
 
 /**
  * A plugin to avoid an aliased AND optimized dep from being aliased in src
@@ -49594,17 +49689,24 @@ function workerImportMetaUrlPlugin(config) {
                                 ? slash$1(path$o.join(config.publicDir, url))
                                 : slash$1(path$o.resolve(path$o.dirname(id), url));
                     }
-                    let builtUrl;
-                    if (isBuild) {
-                        builtUrl = await workerFileToUrl(config, file);
+                    if (isBuild &&
+                        config.isWorker &&
+                        this.getModuleInfo(cleanUrl(file))?.isEntry) {
+                        s.update(expStart, expEnd, 'self.location.href');
                     }
                     else {
-                        builtUrl = await fileToUrl$1(cleanUrl(file), config, this);
-                        builtUrl = injectQuery(builtUrl, `${WORKER_FILE_ID}&type=${workerType}`);
+                        let builtUrl;
+                        if (isBuild) {
+                            builtUrl = await workerFileToUrl(config, file);
+                        }
+                        else {
+                            builtUrl = await fileToUrl$1(cleanUrl(file), config, this);
+                            builtUrl = injectQuery(builtUrl, `${WORKER_FILE_ID}&type=${workerType}`);
+                        }
+                        s.update(expStart, expEnd, 
+                        // add `'' +` to skip vite:asset-import-meta-url plugin
+                        `new URL('' + ${JSON.stringify(builtUrl)}, import.meta.url)`);
                     }
-                    s.update(expStart, expEnd, 
-                    // add `'' +` to skip vite:asset-import-meta-url plugin
-                    `new URL('' + ${JSON.stringify(builtUrl)}, import.meta.url)`);
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -49707,7 +49809,7 @@ function assetImportMetaUrlPlugin(config) {
                     let builtUrl;
                     if (file) {
                         try {
-                            if (isParentDirectory(publicDir, file)) {
+                            if (publicDir && isParentDirectory(publicDir, file)) {
                                 const publicPath = '/' + path$o.posix.relative(publicDir, file);
                                 builtUrl = await fileToUrl$1(publicPath, config, this);
                             }
@@ -53782,6 +53884,54 @@ async function handleModuleSoftInvalidation(mod, ssr, timestamp, server) {
     return result;
 }
 
+/**
+ * Vite converts `import { } from 'foo'` to `const _ = __vite_ssr_import__('foo')`.
+ * Top-level imports and dynamic imports work slightly differently in Node.js.
+ * This function normalizes the differences so it matches prod behaviour.
+ */
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+    // No normalization needed if the user already dynamic imports this module
+    if (metadata?.isDynamicImport)
+        return;
+    // If file path is ESM, everything should be fine
+    if (moduleType === 'module')
+        return;
+    // For non-ESM, named imports is done via static analysis with cjs-module-lexer in Node.js.
+    // If the user named imports a specifier that can't be analyzed, error.
+    if (metadata?.importedNames?.length) {
+        const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+        if (missingBindings.length) {
+            const lastBinding = missingBindings[missingBindings.length - 1];
+            // Copied from Node.js
+            throw new SyntaxError(`\
+[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(', ')}} = pkg;
+`);
+        }
+    }
+}
+/**
+ * Guard invalid named exports only, similar to how Node.js errors for top-level imports.
+ * But since we transform as dynamic imports, we need to emulate the error manually.
+ */
+function proxyGuardOnlyEsm(mod, rawId, metadata) {
+    // If the module doesn't import anything explicitly, e.g. `import 'foo'` or
+    // `import * as foo from 'foo'`, we can skip the proxy guard.
+    if (!metadata?.importedNames?.length)
+        return mod;
+    return new Proxy(mod, {
+        get(mod, prop) {
+            if (prop !== 'then' && !(prop in mod)) {
+                throw new SyntaxError(`[vite] The requested module '${rawId}' does not provide an export named '${prop.toString()}'`);
+            }
+            return mod[prop];
+        },
+    });
+}
+
 /**
  * @param {import('estree').Node} param
  * @returns {string[]}
@@ -54610,15 +54760,6 @@ function ssrFixStacktrace(e, moduleGraph) {
     rewroteStacktraces.add(e);
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const AsyncFunction$1 = async function () { }.constructor;
-let fnDeclarationLineCount$1 = 0;
-{
-    const body = '/*code*/';
-    const source = new AsyncFunction$1('a', 'b', body).toString();
-    fnDeclarationLineCount$1 =
-        source.slice(0, source.indexOf(body)).split('\n').length - 1;
-}
 const pendingModules = new Map();
 const pendingImports = new Map();
 const importErrors = new WeakMap();
@@ -54744,15 +54885,13 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     let sourceMapSuffix = '';
     if (result.map && 'version' in result.map) {
         const moduleSourceMap = Object.assign({}, result.map, {
-            // currently we need to offset the line
-            // https://github.com/nodejs/node/issues/43047#issuecomment-1180632750
-            mappings: ';'.repeat(fnDeclarationLineCount$1) + result.map.mappings,
+            mappings: ';'.repeat(asyncFunctionDeclarationPaddingLineCount) +
+                result.map.mappings,
         });
-        sourceMapSuffix =
-            '\n//# sourceMappingURL=' + genSourceMapUrl(moduleSourceMap);
+        sourceMapSuffix = `\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(moduleSourceMap)}`;
     }
     try {
-        const initModule = new AsyncFunction$1(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, '"use strict";' +
+        const initModule = new AsyncFunction(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, '"use strict";' +
             result.code +
             `\n//# sourceURL=${mod.id}${sourceMapSuffix}`);
         await initModule(context.global, ssrModule, ssrImportMeta, ssrImport, ssrDynamicImport, ssrExportAll);
@@ -54798,7 +54937,9 @@ async function nodeImport(id, importer, resolveOptions, metadata) {
         return proxyESM(mod);
     }
     else if (filePath) {
-        analyzeImportedModDifference(mod, filePath, id, metadata, resolveOptions.packageCache);
+        analyzeImportedModDifference(mod, id, isFilePathESM(filePath, resolveOptions.packageCache)
+            ? 'module'
+            : undefined, metadata);
         return proxyGuardOnlyEsm(mod, id);
     }
     else {
@@ -54828,53 +54969,6 @@ function proxyESM(mod) {
 function isPrimitive(value) {
     return !value || (typeof value !== 'object' && typeof value !== 'function');
 }
-/**
- * Vite converts `import { } from 'foo'` to `const _ = __vite_ssr_import__('foo')`.
- * Top-level imports and dynamic imports work slightly differently in Node.js.
- * This function normalizes the differences so it matches prod behaviour.
- */
-function analyzeImportedModDifference(mod, filePath, rawId, metadata, packageCache) {
-    // No normalization needed if the user already dynamic imports this module
-    if (metadata?.isDynamicImport)
-        return;
-    // If file path is ESM, everything should be fine
-    if (isFilePathESM(filePath, packageCache))
-        return;
-    // For non-ESM, named imports is done via static analysis with cjs-module-lexer in Node.js.
-    // If the user named imports a specifier that can't be analyzed, error.
-    if (metadata?.importedNames?.length) {
-        const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
-        if (missingBindings.length) {
-            const lastBinding = missingBindings[missingBindings.length - 1];
-            // Copied from Node.js
-            throw new SyntaxError(`\
-[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
-CommonJS modules can always be imported via the default export, for example using:
-
-import pkg from '${rawId}';
-const {${missingBindings.join(', ')}} = pkg;
-`);
-        }
-    }
-}
-/**
- * Guard invalid named exports only, similar to how Node.js errors for top-level imports.
- * But since we transform as dynamic imports, we need to emulate the error manually.
- */
-function proxyGuardOnlyEsm(mod, rawId, metadata) {
-    // If the module doesn't import anything explicitly, e.g. `import 'foo'` or
-    // `import * as foo from 'foo'`, we can skip the proxy guard.
-    if (!metadata?.importedNames?.length)
-        return mod;
-    return new Proxy(mod, {
-        get(mod, prop) {
-            if (prop !== 'then' && !(prop in mod)) {
-                throw new SyntaxError(`[vite] The requested module '${rawId}' does not provide an export named '${prop.toString()}'`);
-            }
-            return mod[prop];
-        },
-    });
-}
 
 var isWsl$2 = {exports: {}};
 
@@ -56225,7 +56319,6 @@ async function fetchModule(server, url, importer, options = {}) {
             isProduction,
             root,
             ssrConfig: ssr,
-            legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
             packageCache: server.config.packageCache,
         };
         const resolved = tryNodeResolve(url, importer, { ...resolveOptions, tryEsmOnly: true }, false, undefined, true);
@@ -56270,26 +56363,17 @@ function inlineSourceMap(mod, result, processSourceMap) {
     OTHER_SOURCE_MAP_REGEXP.lastIndex = 0;
     if (OTHER_SOURCE_MAP_REGEXP.test(code))
         code = code.replace(OTHER_SOURCE_MAP_REGEXP, '');
-    const sourceMap = Buffer.from(JSON.stringify(processSourceMap?.(map) || map), 'utf-8').toString('base64');
-    result.code = `${code.trimEnd()}\n//# sourceURL=${mod.id}\n${VITE_RUNTIME_SOURCEMAPPING_SOURCE}\n//# ${VITE_RUNTIME_SOURCEMAPPING_URL};base64,${sourceMap}\n`;
+    const sourceMap = processSourceMap?.(map) || map;
+    result.code = `${code.trimEnd()}\n//# sourceURL=${mod.id}\n${VITE_RUNTIME_SOURCEMAPPING_SOURCE}\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}\n`;
     return result;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const AsyncFunction = async function () { }.constructor;
-const fnDeclarationLineCount = (() => {
-    const body = '/*code*/';
-    const source = new AsyncFunction('a', 'b', body).toString();
-    return source.slice(0, source.indexOf(body)).split('\n').length - 1;
-})();
 function ssrFetchModule(server, id, importer) {
     return fetchModule(server, id, importer, {
         processSourceMap(map) {
             // this assumes that "new AsyncFunction" is used to create the module
             return Object.assign({}, map, {
-                // currently we need to offset the line
-                // https://github.com/nodejs/node/issues/43047#issuecomment-1180632750
-                mappings: ';'.repeat(fnDeclarationLineCount) + map.mappings,
+                mappings: ';'.repeat(asyncFunctionDeclarationPaddingLineCount) + map.mappings,
             });
         },
     });
@@ -64592,14 +64676,12 @@ async function _createServer(inlineConfig = {}, options) {
     // proxy
     const { proxy } = serverConfig;
     if (proxy) {
-        const middlewareServer = (isObject$1(serverConfig.middlewareMode)
-            ? serverConfig.middlewareMode.server
-            : null) || httpServer;
+        const middlewareServer = (isObject$1(middlewareMode) ? middlewareMode.server : null) || httpServer;
         middlewares.use(proxyMiddleware(middlewareServer, proxy, config));
     }
     // base
     if (config.base !== '/') {
-        middlewares.use(baseMiddleware(config.rawBase, middlewareMode));
+        middlewares.use(baseMiddleware(config.rawBase, !!middlewareMode));
     }
     // open in editor support
     middlewares.use('/__open-in-editor', launchEditorMiddleware$1());
@@ -64639,7 +64721,7 @@ async function _createServer(inlineConfig = {}, options) {
         middlewares.use(notFoundMiddleware());
     }
     // error handler
-    middlewares.use(errorMiddleware(server, middlewareMode));
+    middlewares.use(errorMiddleware(server, !!middlewareMode));
     // httpServer.listen can be called multiple times
     // when port when using next port number
     // this code is to avoid calling buildStart multiple times
@@ -64751,7 +64833,7 @@ function resolveServerOptions(root, raw, logger) {
         sourcemapIgnoreList: raw?.sourcemapIgnoreList === false
             ? () => false
             : raw?.sourcemapIgnoreList || isInNodeModules$1,
-        middlewareMode: !!raw?.middlewareMode,
+        middlewareMode: raw?.middlewareMode || false,
     };
     let allowDirs = server.fs?.allow;
     const deny = server.fs?.deny || ['.env', '.env.*', '*.{crt,pem}'];
@@ -65980,7 +66062,7 @@ function createParseErrorInfo(importer, source) {
     };
 }
 // prettier-ignore
-const interopHelper = (m) => m?.__esModule ? m : { ...(typeof m === 'object' && !Array.isArray(m) ? m : {}), default: m };
+const interopHelper = (m) => m?.__esModule ? m : { ...(typeof m === 'object' && !Array.isArray(m) || typeof m === 'function' ? m : {}), default: m };
 function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex, importer, config) {
     const source = str.original;
     const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex, } = importSpecifier;
@@ -67222,7 +67304,7 @@ function injectSsrFlag(options) {
 }
 /*
   The following functions are copied from rollup
-  https://github.com/rollup/rollup/blob/0bcf0a672ac087ff2eb88fbba45ec62389a4f45f/src/ast/nodes/MetaProperty.ts#L145-L193
+  https://github.com/rollup/rollup/blob/ce6cb93098850a46fa242e37b74a919e99a5de28/src/ast/nodes/MetaProperty.ts#L155-L203
 
   https://github.com/rollup/rollup
   The MIT License (MIT)
@@ -67242,24 +67324,24 @@ function escapeId(id) {
 const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
 const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(relativePath)}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.src || document.baseURI`);
 const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
-const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${path}'`);
+const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
 const relativeUrlMechanisms = {
     amd: (relativePath) => {
         if (relativePath[0] !== '.')
             relativePath = './' + relativePath;
-        return getResolveUrl(`require.toUrl('${relativePath}'), document.baseURI`);
+        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
     },
     cjs: (relativePath) => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
-    es: (relativePath) => getResolveUrl(`'${relativePath}', import.meta.url`),
+    es: (relativePath) => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
     iife: (relativePath) => getRelativeUrlFromDocument(relativePath),
     // NOTE: make sure rollup generate `module` params
-    system: (relativePath) => getResolveUrl(`'${relativePath}', module.meta.url`),
+    system: (relativePath) => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
     umd: (relativePath) => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`,
 };
 /* end of copy */
 const customRelativeUrlMechanisms = {
     ...relativeUrlMechanisms,
-    'worker-iife': (relativePath) => getResolveUrl(`'${relativePath}', self.location.href`),
+    'worker-iife': (relativePath) => getResolveUrl(`'${escapeId(relativePath)}', self.location.href`),
 };
 function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelative) {
     const { renderBuiltUrl } = config.experimental;
@@ -67817,7 +67899,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         logger.warn(colors$1.yellow(`worker.plugins is now a function that returns an array of plugins. ` +
             `Please update your Vite config accordingly.\n`));
     }
-    const createWorkerPlugins = async function () {
+    const createWorkerPlugins = async function (bundleChain) {
         // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
         // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
         // So we need to separate the worker plugin from the plugin that vite needs to run.
@@ -67837,6 +67919,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
             ...resolved,
             isWorker: true,
             mainConfig: resolved,
+            bundleChain,
         };
         const resolvedWorkerPlugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
         // run configResolved hooks
@@ -67865,6 +67948,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         ssr,
         isWorker: false,
         mainConfig: null,
+        bundleChain: [],
         isProduction,
         plugins: userPlugins,
         css: resolveCSSOptions(config.css),