vite 8.3.0-beta.1 → 8.3.1

package/dist/node/chunks/node.js

@@ -628,7 +628,7 @@ var BaseEnvironment = class extends PartialEnvironment {
 };
 //#endregion
 //#region package.json
-var version = "8.3.0-beta.1";
+var version = "8.3.1";
 //#endregion
 //#region src/node/constants.ts
 const ROLLUP_HOOKS = [
@@ -762,7 +762,7 @@ const KNOWN_ASSET_TYPES = [
 	"pdf",
 	"txt"
 ];
-const DEFAULT_ASSETS_RE = new RegExp(`\\.(` + KNOWN_ASSET_TYPES.join("|") + `)(\\?.*)?$`, "i");
+const DEFAULT_ASSETS_RE = new RegExp(`\\.(?:` + KNOWN_ASSET_TYPES.join("|") + `)(\\?.*)?$`, "i");
 const DEP_VERSION_RE = /[?&](v=[\w.-]+)\b/;
 const loopbackHosts = /* @__PURE__ */ new Set([
 	"localhost",
@@ -840,18 +840,18 @@ function ignoreDeprecationWarnings(fn) {
 	return ret;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma$1 = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar$1 = /* @__PURE__ */ new Uint8Array(64);
+var intToChar$2 = /* @__PURE__ */ new Uint8Array(64);
 var charToInt$1 = /* @__PURE__ */ new Uint8Array(128);
 for (let i = 0; i < chars$1.length; i++) {
 	const c = chars$1.charCodeAt(i);
-	intToChar$1[i] = c;
+	intToChar$2[i] = c;
 	charToInt$1[c] = i;
 }
-function decodeInteger$1(reader, relative) {
+function decodeInteger$1(reader) {
 	let value = 0;
 	let shift = 0;
 	let integer = 0;
@@ -860,21 +860,21 @@ function decodeInteger$1(reader, relative) {
 		value |= (integer & 31) << shift;
 		shift += 5;
 	} while (integer & 32);
-	const shouldNegate = value & 1;
-	value >>>= 1;
-	if (shouldNegate) value = -2147483648 | -value;
-	return relative + value;
+	return value;
+}
+function decodeSign(num) {
+	return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
 }
-function encodeInteger(builder, num, relative) {
-	let delta = num - relative;
-	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+function encodeInteger(builder, num) {
 	do {
-		let clamped = delta & 31;
-		delta >>>= 5;
-		if (delta > 0) clamped |= 32;
-		builder.write(intToChar$1[clamped]);
-	} while (delta > 0);
-	return num;
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		builder.write(intToChar$2[clamped]);
+	} while (num > 0);
+}
+function encodeSign(num) {
+	return num < 0 ? -num << 1 | 1 : num << 1;
 }
 function hasMoreVlq$1(reader, max) {
 	if (reader.pos >= max) return false;
@@ -924,6 +924,21 @@ var StringReader$1 = class {
 		return idx === -1 ? buffer.length : idx;
 	}
 };
+function encodeRangeMappings(decoded) {
+	if (decoded.length === 0) return "";
+	const writer = new StringWriter();
+	for (let i = 0; i < decoded.length; i++) {
+		const indices = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		let index = 0;
+		for (let j = 0; j < indices.length; j++) {
+			const offset = indices[j];
+			encodeInteger(writer, offset - index);
+			index = offset;
+		}
+	}
+	return writer.flush();
+}
 function decode$1(mappings) {
 	const { length } = mappings;
 	const reader = new StringReader$1(mappings);
@@ -941,15 +956,15 @@ function decode$1(mappings) {
 		genColumn = 0;
 		while (reader.pos < semi) {
 			let seg;
-			genColumn = decodeInteger$1(reader, genColumn);
+			genColumn += decodeSign(decodeInteger$1(reader));
 			if (genColumn < lastCol) sorted = false;
 			lastCol = genColumn;
 			if (hasMoreVlq$1(reader, semi)) {
-				sourcesIndex = decodeInteger$1(reader, sourcesIndex);
-				sourceLine = decodeInteger$1(reader, sourceLine);
-				sourceColumn = decodeInteger$1(reader, sourceColumn);
+				sourcesIndex += decodeSign(decodeInteger$1(reader));
+				sourceLine += decodeSign(decodeInteger$1(reader));
+				sourceColumn += decodeSign(decodeInteger$1(reader));
 				if (hasMoreVlq$1(reader, semi)) {
-					namesIndex = decodeInteger$1(reader, namesIndex);
+					namesIndex += decodeSign(decodeInteger$1(reader));
 					seg = [
 						genColumn,
 						sourcesIndex,
@@ -993,13 +1008,18 @@ function encode$1(decoded) {
 		for (let j = 0; j < line.length; j++) {
 			const segment = line[j];
 			if (j > 0) writer.write(comma$1);
-			genColumn = encodeInteger(writer, segment[0], genColumn);
+			encodeInteger(writer, encodeSign(segment[0] - genColumn));
+			genColumn = segment[0];
 			if (segment.length === 1) continue;
-			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-			sourceLine = encodeInteger(writer, segment[2], sourceLine);
-			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+			encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+			encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+			sourcesIndex = segment[1];
+			sourceLine = segment[2];
+			sourceColumn = segment[3];
 			if (segment.length === 4) continue;
-			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+			encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+			namesIndex = segment[4];
 		}
 	}
 	return writer.flush();
@@ -2057,8 +2077,9 @@ function isNodeBuiltin(id) {
 	if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
 	return nodeBuiltins.includes(id);
 }
+const inNodeModulesRE = /(?:^|[\\/])node_modules(?:[\\/]|$)/;
 function isInNodeModules(id) {
-	return id.includes("node_modules");
+	return inNodeModulesRE.test(id);
 }
 function moduleListContains(moduleList, id) {
 	return moduleList?.some((m) => m === id || id.startsWith(withTrailingSlash(m)));
@@ -2253,6 +2274,13 @@ function isFilePathFormatExplicit(filePath, packageCache) {
 }
 const splitRE = /\r?\n/g;
 const range = 2;
+/**
+* `splitRE` treats both LF and CRLF as a line terminator, so the terminator
+* following a line is 2 characters long when the source uses CRLF.
+*/
+function lineTerminatorLengthAt(source, index) {
+	return source[index] === "\r" ? 2 : 1;
+}
 function pad(source, n = 2) {
 	return source.split(splitRE).map((l) => ` `.repeat(n) + l).join(`\n`);
 }
@@ -2261,7 +2289,10 @@ function posToNumber(source, pos) {
 	const lines = source.split(splitRE);
 	const { line, column } = pos;
 	let start = 0;
-	for (let i = 0; i < line - 1 && i < lines.length; i++) start += lines[i].length + 1;
+	for (let i = 0; i < line - 1 && i < lines.length; i++) {
+		start += lines[i].length;
+		start += lineTerminatorLengthAt(source, start);
+	}
 	return start + column;
 }
 function numberToPos(source, offset) {
@@ -2319,12 +2350,12 @@ function generateCodeFrame(source, start = 0, end) {
 						const underline = "^".repeat(Math.min(length, MAX_DISPLAY_LEN));
 						res.push(`${" ".repeat(lineNumberWidth)}|  ` + underline);
 					}
-					count += lineLength + 1;
+					count += lineTerminatorLengthAt(source, count) + lineLength;
 				}
 			}
 			break;
 		}
-		count++;
+		count += lineTerminatorLengthAt(source, count);
 	}
 	return res.join("\n");
 }
@@ -2796,7 +2827,10 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
 	const merged = { ...defaults };
 	if (rollupOptionsRootPaths.has(rootPath)) setupRollupOptionCompat(merged, rootPath);
 	if (rootPath === "server") setupHmrWsOptionCompat(merged);
-	if (rootPath === "server.hmr") for (const key of wsOptionKeys) Object.defineProperty(merged, key, Object.getOwnPropertyDescriptor(defaults, key));
+	if (rootPath === "server.hmr") for (const key of wsOptionKeys) {
+		const descriptor = Object.getOwnPropertyDescriptor(defaults, key);
+		if (descriptor) Object.defineProperty(merged, key, descriptor);
+	}
 	for (const key in overrides) {
 		const value = overrides[key];
 		if (value == null) continue;
@@ -3426,7 +3460,7 @@ function alias$1(options = {}) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/magic-string@1.2.3/node_modules/magic-string/dist/index.mjs
+//#region ../../node_modules/.pnpm/magic-string@1.4.1/node_modules/magic-string/dist/index.mjs
 var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -3537,8 +3571,10 @@ var Chunk = class Chunk {
 		if (this.outro.length) return true;
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
-			if (trimmed !== this.content) if (this.edited) this.edit(trimmed, this.storeName, true);
-			else this.split(this.start + trimmed.length).edit("", void 0, true);
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else this.split(this.start + trimmed.length).edit("", void 0, true);
+			}
 			return true;
 		} else {
 			this.edit("", void 0, true);
@@ -3551,10 +3587,12 @@ var Chunk = class Chunk {
 		if (this.intro.length) return true;
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
-			if (trimmed !== this.content) if (this.edited) this.edit(trimmed, this.storeName, true);
-			else {
-				this.split(this.end - trimmed.length);
-				this.edit("", void 0, true);
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else {
+					this.split(this.end - trimmed.length);
+					this.edit("", void 0, true);
+				}
 			}
 			return true;
 		} else {
@@ -3577,12 +3615,14 @@ var MagicStringError = class extends Error {
 	}
 };
 function getBtoa() {
+	/* v8 ignore next -- environment fallback, unreachable when `btoa` is present */
 	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
 	const buffer = globalThis["Buffer"];
 	if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
 	return () => {
 		throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
 	};
+	/* v8 ignore stop */
 }
 const btoa$1 = /* #__PURE__ */ getBtoa();
 var SourceMap = class {
@@ -3592,9 +3632,17 @@ var SourceMap = class {
 		this.sources = properties.sources;
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
-		this.mappings = encode$1(properties.mappings);
+		this.mappings = typeof properties.mappings === "string" ? properties.mappings : encode$1(properties.mappings);
 		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
 		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+		if (typeof properties.rangeMappings !== "undefined") {
+			let shouldOutputRangeMapping = false;
+			for (const line of properties.rangeMappings) if (line.length !== 0) {
+				shouldOutputRangeMapping = true;
+				break;
+			}
+			if (shouldOutputRangeMapping) this.rangeMappings = encodeRangeMappings(properties.rangeMappings);
+		}
 	}
 	/**
 	* Returns the equivalent of `JSON.stringify(map)`
@@ -3611,12 +3659,8 @@ var SourceMap = class {
 	}
 };
 function getLocator(source) {
-	const originalLines = source.split("\n");
-	const lineOffsets = [];
-	for (let i = 0, pos = 0; i < originalLines.length; i++) {
-		lineOffsets.push(pos);
-		pos += originalLines[i].length + 1;
-	}
+	const lineOffsets = [0];
+	for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) lineOffsets.push(i + 1);
 	return function locate(index) {
 		let i = 0;
 		let j = lineOffsets.length;
@@ -3662,15 +3706,120 @@ const toString = Object.prototype.toString;
 function isObject(thing) {
 	return toString.call(thing) === "[object Object]";
 }
-const wordRegex = /\w/;
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar$1 = /* #__PURE__ */ (() => {
+	const chars = /* @__PURE__ */ new Uint8Array(64);
+	for (let i = 0; i < 64; i++) chars[i] = BASE64_CHARS.charCodeAt(i);
+	return chars;
+})();
+const COMMA = 44;
+const SEMICOLON = 59;
+const BUFFER_SIZE = 16384;
+const FLUSH_THRESHOLD = 16348;
+const scratch = /* #__PURE__ */ new Uint8Array(BUFFER_SIZE);
+function writeVlq(pos, num) {
+	num = num < 0 ? -num << 1 | 1 : num << 1;
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		scratch[pos++] = intToChar$1[clamped];
+	} while (num > 0);
+	return pos;
+}
+const decoder$1 = /* #__PURE__ */ new TextDecoder();
+var MappingsEncoder = class {
+	constructor() {
+		this.out = "";
+		this.pos = 0;
+		this.lines = [];
+		this.buffered = 0;
+		this.needsComma = false;
+		this.prevGenColumn = 0;
+		this.prevSourceIndex = 0;
+		this.prevSourceLine = 0;
+		this.prevSourceColumn = 0;
+		this.prevNameIndex = 0;
+	}
+	endLine(segments) {
+		this.lines.push(segments);
+		this.buffered += segments.length + 1;
+		if (this.buffered >= 4096) this.drain(null);
+	}
+	segments(segments) {
+		this.drain(segments);
+	}
+	finish(segments) {
+		this.drain(segments);
+		this.flush();
+		return this.out;
+	}
+	drain(trailing) {
+		const lines = this.lines;
+		const lineCount = lines.length;
+		for (let l = 0; l <= lineCount; l++) {
+			const line = l < lineCount ? lines[l] : trailing;
+			if (line === null) break;
+			for (let i = 0; i < line.length; i++) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				const segment = line[i];
+				if (this.needsComma) scratch[this.pos++] = COMMA;
+				this.needsComma = true;
+				this.pos = writeVlq(this.pos, segment[0] - this.prevGenColumn);
+				this.prevGenColumn = segment[0];
+				this.pos = writeVlq(this.pos, segment[1] - this.prevSourceIndex);
+				this.prevSourceIndex = segment[1];
+				this.pos = writeVlq(this.pos, segment[2] - this.prevSourceLine);
+				this.prevSourceLine = segment[2];
+				this.pos = writeVlq(this.pos, segment[3] - this.prevSourceColumn);
+				this.prevSourceColumn = segment[3];
+				if (segment.length === 5) {
+					this.pos = writeVlq(this.pos, segment[4] - this.prevNameIndex);
+					this.prevNameIndex = segment[4];
+				}
+			}
+			if (l < lineCount) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				scratch[this.pos++] = SEMICOLON;
+				this.needsComma = false;
+				this.prevGenColumn = 0;
+			}
+		}
+		lines.length = 0;
+		this.buffered = 0;
+		this.flush();
+	}
+	flush() {
+		this.out += decoder$1.decode(scratch.subarray(0, this.pos));
+		this.pos = 0;
+	}
+};
+const NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
 var Mappings = class {
-	constructor(hires) {
+	constructor(hires, encoder = null) {
 		this.hires = hires;
 		this.generatedCodeLine = 0;
 		this.generatedCodeColumn = 0;
 		this.raw = [];
 		this.rawSegments = this.raw[this.generatedCodeLine] = [];
-		this.pending = null;
+		this.rawRangeMappings = [];
+		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+		this.encoder = encoder;
+	}
+	nextLine() {
+		if (this.encoder === null) {
+			this.generatedCodeLine += 1;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+		} else {
+			this.encoder.endLine(this.rawSegments);
+			this.rawSegments = [];
+			this.generatedCodeLine += 1;
+		}
+		this.generatedCodeColumn = 0;
+		this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
 	}
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
@@ -3686,9 +3835,7 @@ var Mappings = class {
 				];
 				if (nameIndex >= 0) segment.push(nameIndex);
 				this.rawSegments.push(segment);
-				this.generatedCodeLine += 1;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-				this.generatedCodeColumn = 0;
+				this.nextLine();
 				previousContentLineEnd = contentLineEnd;
 				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
 			}
@@ -3701,63 +3848,122 @@ var Mappings = class {
 			if (nameIndex >= 0) segment.push(nameIndex);
 			this.rawSegments.push(segment);
 			this.advance(content.slice(previousContentLineEnd + 1));
-		} else if (this.pending) {
-			this.rawSegments.push(this.pending);
-			this.advance(content);
 		}
-		this.pending = null;
 	}
 	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
-		let originalCharIndex = chunk.start;
-		let first = true;
-		let charInHiresBoundary = false;
-		while (originalCharIndex < chunk.end) {
-			if (original[originalCharIndex] === "\n") {
-				loc.line += 1;
-				loc.column = 0;
-				this.generatedCodeLine += 1;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-				this.generatedCodeColumn = 0;
-				first = true;
-				charInHiresBoundary = false;
-			} else {
-				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-					const segment = [
+		const end = chunk.end;
+		let i = chunk.start;
+		if (this.hires) {
+			const boundary = this.hires === "boundary";
+			const experimentalRange = this.hires === "experimental-range";
+			const encoder = experimentalRange ? null : this.encoder;
+			let charInHiresBoundary = false;
+			while (i < end) {
+				if (encoder !== null && this.rawSegments.length >= 4096) {
+					encoder.segments(this.rawSegments);
+					this.rawSegments.length = 0;
+				}
+				if (experimentalRange && i + 1 >= end) this.rawSegments.push([
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				]);
+				const code = original.charCodeAt(i);
+				if (code === NEWLINE_CHAR$1) {
+					loc.line += 1;
+					loc.column = 0;
+					this.nextLine();
+					charInHiresBoundary = false;
+				} else {
+					if (boundary) {
+						if (isWordCode(code)) {
+							if (!charInHiresBoundary) {
+								this.rawSegments.push([
+									this.generatedCodeColumn,
+									sourceIndex,
+									loc.line,
+									loc.column
+								]);
+								charInHiresBoundary = true;
+							}
+						} else {
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+							charInHiresBoundary = false;
+						}
+					} else if (experimentalRange) {
+						if (i === chunk.start) {
+							this.rawRangeMappingsIndices.push(this.rawSegments.length);
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+						}
+					} else this.rawSegments.push([
 						this.generatedCodeColumn,
 						sourceIndex,
 						loc.line,
 						loc.column
-					];
-					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
+					]);
+					loc.column += 1;
+					this.generatedCodeColumn += 1;
+				}
+				i += 1;
+			}
+		} else {
+			const bits = sourcemapLocations.bits;
+			while (i < end) {
+				let newline = original.indexOf("\n", i);
+				if (newline === -1 || newline > end) newline = end;
+				if (newline > i) {
+					this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					for (let w = i + 1 >> 5, last = newline - 1 >> 5; w <= last; w++) {
+						let word = bits[w];
+						if (!word) continue;
+						const base = w << 5;
+						while (word) {
+							const lowest = word & -word;
+							const index = base + 31 - Math.clz32(lowest);
+							if (index > i && index < newline) {
+								const offset = index - i;
+								this.rawSegments.push([
+									this.generatedCodeColumn + offset,
+									sourceIndex,
+									loc.line,
+									loc.column + offset
+								]);
+							}
+							word ^= lowest;
 						}
-					} else {
-						this.rawSegments.push(segment);
-						charInHiresBoundary = false;
 					}
-					else this.rawSegments.push(segment);
+					loc.column += newline - i;
+					this.generatedCodeColumn += newline - i;
 				}
-				loc.column += 1;
-				this.generatedCodeColumn += 1;
-				first = false;
+				if (newline === end) break;
+				loc.line += 1;
+				loc.column = 0;
+				this.nextLine();
+				i = newline + 1;
 			}
-			originalCharIndex += 1;
 		}
-		this.pending = null;
 	}
 	advance(str) {
 		if (!str) return;
-		const lines = str.split("\n");
-		if (lines.length > 1) {
-			for (let i = 0; i < lines.length - 1; i++) {
-				this.generatedCodeLine++;
-				this.raw[this.generatedCodeLine] = this.rawSegments = [];
-			}
-			this.generatedCodeColumn = 0;
-		}
-		this.generatedCodeColumn += lines[lines.length - 1].length;
+		const lastNewline = str.lastIndexOf("\n");
+		for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) this.nextLine();
+		this.generatedCodeColumn += str.length - lastNewline - 1;
 	}
 };
 const n$1 = "\n";
@@ -3768,6 +3974,63 @@ const warned = {
 	insertRight: false,
 	storeName: false
 };
+/**
+* Expands the `$` substitution patterns that `String.prototype.replace` accepts
+* in a string replacement.
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+*
+* `captures` holds the capture groups in order, so `captures[0]` is `$1`.
+* `namedCaptures` is `undefined` when the pattern has no named groups, and
+* `$<name>` is then literal text - which is also the case for a string search
+* value, where there are no groups of either kind.
+*/
+function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
+	if (!replacement.includes("$")) return replacement;
+	let result = "";
+	let index = 0;
+	while (index < replacement.length) {
+		const dollar = replacement.indexOf("$", index);
+		if (dollar === -1) {
+			result += replacement.slice(index);
+			break;
+		}
+		result += replacement.slice(index, dollar);
+		const char = replacement[dollar + 1];
+		let expansion = "$";
+		let consumed = 1;
+		if (char === "$") consumed = 2;
+		else if (char === "&") {
+			expansion = matched;
+			consumed = 2;
+		} else if (char === "`") {
+			expansion = str.slice(0, position);
+			consumed = 2;
+		} else if (char === "'") {
+			expansion = str.slice(position + matched.length);
+			consumed = 2;
+		} else if (char === "<" && namedCaptures !== void 0) {
+			const close = replacement.indexOf(">", dollar + 2);
+			if (close !== -1) {
+				expansion = namedCaptures[replacement.slice(dollar + 2, close)] ?? "";
+				consumed = close + 1 - dollar;
+			}
+		} else if (char >= "0" && char <= "9") {
+			const second = replacement[dollar + 2];
+			const double = second >= "0" && second <= "9" ? Number(char + second) : NaN;
+			const single = Number(char);
+			if (double >= 1 && double <= captures.length) {
+				expansion = captures[double - 1] ?? "";
+				consumed = 3;
+			} else if (single >= 1 && single <= captures.length) {
+				expansion = captures[single - 1] ?? "";
+				consumed = 2;
+			}
+		}
+		result += expansion;
+		index = dollar + consumed;
+	}
+	return result;
+}
 var MagicString = class MagicString {
 	constructor(string, options = {}) {
 		const chunk = new Chunk(0, string.length, string);
@@ -3918,9 +4181,32 @@ var MagicString = class MagicString {
 	*/
 	generateDecodedMap(options) {
 		options = options || {};
+		const mappings = new Mappings(options.hires);
+		const names = this._generateMappings(mappings);
+		return {
+			...this._mapProperties(options, names),
+			mappings: mappings.raw,
+			rangeMappings: mappings.rawRangeMappings
+		};
+	}
+	/**
+	* Generates a version 3 sourcemap.
+	*/
+	generateMap(options) {
+		options = options || {};
+		const encoder = new MappingsEncoder();
+		const mappings = new Mappings(options.hires, encoder);
+		const names = this._generateMappings(mappings);
+		return new SourceMap({
+			...this._mapProperties(options, names),
+			mappings: encoder.finish(mappings.rawSegments),
+			rangeMappings: mappings.rawRangeMappings
+		});
+	}
+	/** @internal */
+	_generateMappings(mappings) {
 		const sourceIndex = 0;
 		const names = Object.keys(this.storedNames);
-		const mappings = new Mappings(options.hires);
 		const locate = getLocator(this.original);
 		if (this.intro) mappings.advance(this.intro);
 		this.firstChunk.eachNext((chunk) => {
@@ -3931,21 +4217,18 @@ var MagicString = class MagicString {
 			if (chunk.outro.length) mappings.advance(chunk.outro);
 		});
 		if (this.outro) mappings.advance(this.outro);
+		return names;
+	}
+	/** @internal */
+	_mapProperties(options, names) {
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
 			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
 			sourcesContent: options.includeContent ? [this.original] : void 0,
 			names,
-			mappings: mappings.raw,
-			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+			x_google_ignoreList: this.ignoreList ? [0] : void 0
 		};
 	}
-	/**
-	* Generates a version 3 sourcemap.
-	*/
-	generateMap(options) {
-		return new SourceMap(this.generateDecodedMap(options));
-	}
 	/** @internal */
 	_ensureindentStr() {
 		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
@@ -3977,17 +4260,18 @@ var MagicString = class MagicString {
 			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
 		});
 		let shouldIndentNextCharacter = options.indentStart !== false;
-		const replacer = (match) => {
-			if (shouldIndentNextCharacter) return `${resolvedIndentStr}${match}`;
-			shouldIndentNextCharacter = true;
-			return match;
+		const indentPiece = (str) => {
+			if (str === "") return str;
+			const indented = str.replace(pattern, (match, offset) => offset > 0 || shouldIndentNextCharacter ? `${resolvedIndentStr}${match}` : match);
+			shouldIndentNextCharacter = str[str.length - 1] === "\n";
+			return indented;
 		};
-		this.intro = this.intro.replace(pattern, replacer);
+		this.intro = indentPiece(this.intro);
 		let charIndex = 0;
 		let chunk = this.firstChunk;
 		const indentAt = (index) => {
 			shouldIndentNextCharacter = false;
-			if (index === chunk.start) chunk.prependRight(resolvedIndentStr);
+			if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
 			else {
 				this._splitChunk(chunk, index);
 				chunk = chunk.next;
@@ -3996,11 +4280,9 @@ var MagicString = class MagicString {
 		};
 		while (chunk) {
 			const end = chunk.end;
+			if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
 			if (chunk.edited) {
-				if (!isExcluded[charIndex]) {
-					chunk.content = chunk.content.replace(pattern, replacer);
-					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
-				}
+				if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
 			} else if (options.exclude) {
 				charIndex = chunk.start;
 				while (charIndex < end) {
@@ -4030,10 +4312,11 @@ var MagicString = class MagicString {
 					charIndex += 1;
 				}
 			}
+			if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
 			charIndex = chunk.end;
 			chunk = chunk.next;
 		}
-		this.outro = this.outro.replace(pattern, replacer);
+		this.outro = indentPiece(this.outro);
 		return this;
 	}
 	/** @internal */
@@ -4058,8 +4341,14 @@ var MagicString = class MagicString {
 	}
 	/**
 	* Moves the characters from `start` and `end` to `index`.
+	*
+	* `affinity` controls where the range is anchored at `index`. With the
+	* default `'right'`, it is inserted before the content that starts at `index`;
+	* with `'left'`, it is inserted after the content that ends at `index`. The
+	* two differ only when other content has already been moved to that boundary,
+	* mirroring the `appendLeft`/`appendRight` distinction.
 	*/
-	move(start, end, index) {
+	move(start, end, index, affinity = "right") {
 		start = start + this.offset;
 		end = end + this.offset;
 		index = index + this.offset;
@@ -4079,9 +4368,27 @@ var MagicString = class MagicString {
 		}
 		const oldLeft = first.previous;
 		const oldRight = last.next;
-		const newRight = this.byStart.get(index);
-		if (!newRight && last === this.lastChunk) return this;
-		const newLeft = newRight ? newRight.previous : this.lastChunk;
+		let newLeft;
+		let newRight;
+		if (affinity === "left") {
+			newLeft = this.byEnd.get(index) ?? null;
+			if (!newLeft) {
+				if (first === this.firstChunk) return this;
+				newRight = this.firstChunk;
+			} else {
+				if (newLeft.next === first) return this;
+				newRight = newLeft.next;
+			}
+		} else {
+			newRight = this.byStart.get(index) ?? null;
+			if (!newRight) {
+				if (last === this.lastChunk) return this;
+				newLeft = this.lastChunk;
+			} else {
+				if (newRight.previous === last) return this;
+				newLeft = newRight.previous;
+			}
+		}
 		if (oldLeft) oldLeft.next = oldRight;
 		if (oldRight) oldRight.previous = oldLeft;
 		if (newLeft) newLeft.next = first;
@@ -4156,6 +4463,7 @@ var MagicString = class MagicString {
 		}
 		const first = this.byStart.get(start);
 		const last = this.byEnd.get(end);
+		/* v8 ignore else -- unreachable: a valid start/end always yields a `first` chunk */
 		if (first) {
 			let chunk = first;
 			while (chunk !== last) {
@@ -4205,6 +4513,9 @@ var MagicString = class MagicString {
 	}
 	/**
 	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Content appended or prepended at positions strictly inside the range is removed with it, while
+	* content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
+	* the range including its edge inserts.
 	* Removing the same content twice, or making removals that partially overlap, will cause an error.
 	*/
 	remove(start, end) {
@@ -4221,9 +4532,9 @@ var MagicString = class MagicString {
 		this._split(end);
 		let chunk = this.byStart.get(start);
 		while (chunk) {
-			chunk.intro = "";
-			chunk.outro = "";
-			chunk.edit("");
+			if (chunk.start > start) chunk.intro = "";
+			if (chunk.end < end) chunk.outro = "";
+			chunk.edit("", false, true);
 			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
 		}
 		return this;
@@ -4303,12 +4614,13 @@ var MagicString = class MagicString {
 		let result = "";
 		let chunk = this.firstChunk;
 		while (chunk && (chunk.start > start || chunk.end <= start)) {
-			if (chunk.start < end && chunk.end >= end) return result;
+			if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
 			chunk = chunk.next;
 		}
 		if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
 		const startChunk = chunk;
 		while (chunk) {
+			if (end === 0 && chunk.start === 0) break;
 			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
 			const containsEnd = chunk.start < end && chunk.end >= end;
 			if (containsEnd && chunk.edited && chunk.end !== end) throw new MagicStringError(`cannot use edited character ${end} as slice end anchor`);
@@ -4373,11 +4685,13 @@ var MagicString = class MagicString {
 	* Returns true if the resulting source is empty (disregarding white space).
 	*/
 	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
 		let chunk = this.firstChunk;
 		while (chunk) {
 			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
 			chunk = chunk.next;
 		}
+		if (this.outro.length && this.outro.trim()) return false;
 		return true;
 	}
 	length() {
@@ -4419,7 +4733,8 @@ var MagicString = class MagicString {
 			if (aborted) return true;
 			chunk = chunk.previous;
 		} while (chunk);
-		return false;
+		this.intro = this.intro.replace(rx, "");
+		return this.intro.length > 0;
 	}
 	/**
 	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
@@ -4446,7 +4761,8 @@ var MagicString = class MagicString {
 			if (aborted) return true;
 			chunk = chunk.next;
 		} while (chunk);
-		return false;
+		this.outro = this.outro.replace(rx, "");
+		return this.outro.length > 0;
 	}
 	/**
 	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
@@ -4473,41 +4789,66 @@ var MagicString = class MagicString {
 		}
 		return outputIndex !== this.original.length;
 	}
+	/**
+	* Whether the original range [start, end) has had any of its characters
+	* removed. `replace`/`replaceAll` search `original`, so a match can land on
+	* text that is no longer in the output - overwriting it would resurrect the
+	* removed characters, so such matches are skipped instead.
+	*
+	* @internal
+	*/
+	_hasRemovedContent(start, end) {
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.content === "" && chunk.start < end && chunk.end > start) return true;
+			chunk = chunk.next;
+		}
+		return false;
+	}
 	/** @internal */
 	_replaceRegexp(searchValue, replacement) {
 		function getReplacement(match, str) {
-			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
-				if (i === "$") return "$";
-				if (i === "&") return match[0];
-				if (+i < match.length) return match[+i];
-				return `$${i}`;
-			});
-			else return replacement(match[0], ...match.slice(1), match.index, str, match.groups);
+			if (typeof replacement === "string") return expandReplacement(replacement, match[0], match.index, str, match.slice(1), match.groups);
+			else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), match.index, str) : replacement(match[0], ...match.slice(1), match.index, str, match.groups);
 		}
 		const replaceMatch = (match) => {
-			if (match.index == null) return;
+			/* v8 ignore next 2 -- `match.index` is always defined for matches from `matchAll` */
+			if (match.index == null) return false;
+			if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
 			const replacement = getReplacement(match, this.original);
-			if (replacement === match[0]) return;
+			if (replacement === match[0]) return true;
 			if (match[0].length === 0) this.appendRight(match.index, replacement);
 			else this.overwrite(match.index, match.index + match[0].length, replacement);
+			return true;
 		};
 		if (searchValue.global) {
 			searchValue.lastIndex = 0;
 			for (const match of this.original.matchAll(searchValue)) replaceMatch(match);
 		} else {
 			const match = this.original.match(searchValue);
-			if (match) replaceMatch(match);
+			if (match && !replaceMatch(match)) {
+				const global = new RegExp(searchValue.source, `${searchValue.flags}g`);
+				for (const next of this.original.matchAll(global)) if (replaceMatch(next)) break;
+			}
 		}
 		return this;
 	}
 	/** @internal */
 	_replaceString(string, replacement) {
 		const { original } = this;
-		const index = original.indexOf(string);
-		if (index !== -1) {
+		let index = original.indexOf(string);
+		while (index !== -1) {
+			if (this._hasRemovedContent(index, index + string.length)) {
+				index = original.indexOf(string, index + string.length);
+				continue;
+			}
 			if (typeof replacement === "function") replacement = replacement(string, index, original);
-			if (string !== replacement) if (string.length === 0) this.appendRight(index, replacement);
-			else this.overwrite(index, index + string.length, replacement);
+			else replacement = expandReplacement(replacement, string, index, original, [], void 0);
+			if (string !== replacement) {
+				if (string.length === 0) this.appendRight(index, replacement);
+				else this.overwrite(index, index + string.length, replacement);
+			}
+			break;
 		}
 		return this;
 	}
@@ -4524,14 +4865,15 @@ var MagicString = class MagicString {
 		const stringLength = string.length;
 		if (stringLength === 0) {
 			for (let index = 0; index <= original.length; index += 1) {
-				const _replacement = typeof replacement === "function" ? replacement("", index, original) : replacement;
+				const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
 				if (_replacement !== "") this.appendRight(index, _replacement);
 			}
 			return this;
 		}
 		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			if (this._hasRemovedContent(index, index + stringLength)) continue;
 			const previous = original.slice(index, index + stringLength);
-			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : replacement;
+			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
 			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
 		}
 		return this;
@@ -5744,7 +6086,7 @@ function perEnvironmentState(initial) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/artichokie@0.4.4/node_modules/artichokie/dist/index.js
+//#region ../../node_modules/.pnpm/artichokie@0.4.5/node_modules/artichokie/dist/index.js
 const AsyncFunction = async function() {}.constructor;
 const codeToDataUrl = (code) => `data:application/javascript,${encodeURIComponent(code + "\n//# sourceURL=[worker-eval(artichokie)]")}`;
 const viteSsrDynamicImport = "__vite_ssr_dynamic_import__";
@@ -5779,7 +6121,14 @@ var Worker$1 = class {
 		return new Promise((resolve, reject) => {
 			worker.currentResolve = resolve;
 			worker.currentReject = reject;
-			worker.postMessage({ args });
+			try {
+				worker.postMessage({ args });
+			} catch (err) {
+				worker.currentResolve = null;
+				worker.currentReject = null;
+				this._assignDoneWorker(worker);
+				throw err;
+			}
 		});
 	}
 	stop() {
@@ -5822,18 +6171,23 @@ var Worker$1 = class {
 				}
 				this._assignDoneWorker(worker);
 			});
-			worker.on("error", (err) => {
+			const rejectWorker = (err) => {
 				worker.currentReject?.(err);
 				worker.currentReject = null;
 				parentFunctionResponder.close();
-			});
+			};
+			worker.on("error", rejectWorker);
 			worker.on("exit", (code) => {
 				const i = this._pool.indexOf(worker);
 				if (i > -1) this._pool.splice(i, 1);
-				if (code !== 0 && worker.currentReject) {
-					worker.currentReject(/* @__PURE__ */ new Error(`Worker stopped with non-0 exit code ${code}`));
-					worker.currentReject = null;
-					parentFunctionResponder.close();
+				const idleIndex = this._idlePool.indexOf(worker);
+				if (idleIndex > -1) this._idlePool.splice(idleIndex, 1);
+				if (code !== 0) {
+					rejectWorker(/* @__PURE__ */ new Error(`Worker stopped with non-0 exit code ${code}`));
+					if (this._queue.length) {
+						const [resolve, reject] = this._queue.shift();
+						this._getAvailableWorker().then(resolve, reject);
+					}
 				}
 			});
 			this._pool.push(worker);
@@ -6430,7 +6784,7 @@ var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.13_yaml@2.9.0/node_modules/postcss-load-config/src/req.js
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.15_yaml@2.9.0/node_modules/postcss-load-config/src/req.js
 var require_req = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { createRequire: createRequire$1 } = __require("node:module");
 	const { fileURLToPath: fileURLToPath$1, pathToFileURL: pathToFileURL$1 } = __require("node:url");
@@ -6472,7 +6826,7 @@ var require_req = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = req;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.13_yaml@2.9.0/node_modules/postcss-load-config/src/options.js
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.15_yaml@2.9.0/node_modules/postcss-load-config/src/options.js
 var require_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const req = require_req();
 	/**
@@ -6506,7 +6860,7 @@ var require_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = options;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.13_yaml@2.9.0/node_modules/postcss-load-config/src/plugins.js
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.15_yaml@2.9.0/node_modules/postcss-load-config/src/plugins.js
 var require_plugins = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const req = require_req();
 	/**
@@ -6560,7 +6914,7 @@ var require_plugins = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = plugins;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.13_yaml@2.9.0/node_modules/postcss-load-config/src/index.js
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.28_tsx@4.23.15_yaml@2.9.0/node_modules/postcss-load-config/src/index.js
 var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { resolve: resolve$3 } = __require("node:path");
 	const config = require_src$1();
@@ -16403,6 +16757,26 @@ var NoopWatcher = class extends EventEmitter {
 function createNoopWatcher(options) {
 	return new NoopWatcher(options);
 }
+/**
+* Chokidar's `add()` reopens a closed watcher. It may be called after shutdown
+* starts from an in-flight plugin hook or directly through the exposed watcher.
+* This wrapper makes `close()` final so those calls cannot create new file
+* system handles.
+*/
+function makeWatcherCloseFinal(watcher) {
+	let closed = false;
+	const add = watcher.add;
+	watcher.add = function(...args) {
+		if (closed) return this;
+		return add.apply(this, args);
+	};
+	const close = watcher.close;
+	watcher.close = function(...args) {
+		closed = true;
+		return close.apply(this, args);
+	};
+	return watcher;
+}
 //#endregion
 //#region src/node/server/middlewares/base.ts
 function baseMiddleware(rawBase, middlewareMode) {
@@ -17054,6 +17428,7 @@ async function computeSourceRoute(map, file) {
 	return sourceRoot;
 }
 async function injectSourcesContent(map, file, logger) {
+	if (map.sourceRoot && isExternalUrl(map.sourceRoot)) return;
 	let sourceRootPromise;
 	const packageRoot = getNodeModulesPackageRoot(file);
 	const missingSources = [];
@@ -17061,7 +17436,7 @@ async function injectSourcesContent(map, file, logger) {
 	const sourcesContentPromises = [];
 	for (let index = 0; index < map.sources.length; index++) {
 		const sourcePath = map.sources[index];
-		if (sourcesContent[index] == null && sourcePath && !virtualSourceRE.test(sourcePath)) sourcesContentPromises.push((async () => {
+		if (sourcesContent[index] == null && sourcePath && !isExternalUrl(sourcePath) && !virtualSourceRE.test(sourcePath)) sourcesContentPromises.push((async () => {
 			sourceRootPromise ??= computeSourceRoute(map, file);
 			const sourceRoot = await sourceRootPromise;
 			let resolvedSourcePath = cleanUrl(decodeURI(sourcePath));
@@ -19349,6 +19724,13 @@ const rewriteOriginHeader = (proxyReq, options, config) => {
 		}
 	}
 };
+function createProxyContextMatcher(context) {
+	if (context[0] === "^") {
+		const regex = new RegExp(context);
+		return (url) => regex.test(url);
+	}
+	return (url) => url.startsWith(context);
+}
 function proxyMiddleware(httpServer, options, config) {
 	const proxies = {};
 	Object.keys(options).forEach((context) => {
@@ -19384,72 +19766,77 @@ function proxyMiddleware(httpServer, options, config) {
 				});
 			});
 		});
-		proxies[context] = [proxy, { ...opts }];
+		proxies[context] = {
+			proxy,
+			options: { ...opts },
+			match: createProxyContextMatcher(context)
+		};
 	});
 	if (httpServer) httpServer.on("upgrade", async (req, socket, head) => {
 		const url = req.url;
-		for (const context in proxies) if (doesProxyContextMatchUrl(context, url)) {
-			const [proxy, opts] = proxies[context];
-			if (opts.ws || opts.target?.toString().startsWith("ws:") || opts.target?.toString().startsWith("wss:")) {
-				if (opts.bypass) try {
-					const bypassResult = await opts.bypass(req, void 0, opts);
-					if (typeof bypassResult === "string") {
-						debug$8?.(`bypass: ${req.url} -> ${bypassResult}`);
-						req.url = bypassResult;
-						return;
-					}
-					if (bypassResult === false) {
-						debug$8?.(`bypass: ${req.url} -> 404`);
-						socket.end("HTTP/1.1 404 Not Found\r\n\r\n", "");
+		for (const context in proxies) {
+			const { proxy, options: opts, match } = proxies[context];
+			if (match(url)) {
+				if (opts.ws || opts.target?.toString().startsWith("ws:") || opts.target?.toString().startsWith("wss:")) {
+					if (opts.bypass) try {
+						const bypassResult = await opts.bypass(req, void 0, opts);
+						if (typeof bypassResult === "string") {
+							debug$8?.(`bypass: ${req.url} -> ${bypassResult}`);
+							req.url = bypassResult;
+							return;
+						}
+						if (bypassResult === false) {
+							debug$8?.(`bypass: ${req.url} -> 404`);
+							socket.end("HTTP/1.1 404 Not Found\r\n\r\n", "");
+							return;
+						}
+					} catch (err) {
+						config.logger.error(`${import_picocolors.default.red(`ws proxy bypass error:`)}\n${err.stack}`, {
+							timestamp: true,
+							error: err
+						});
 						return;
 					}
-				} catch (err) {
-					config.logger.error(`${import_picocolors.default.red(`ws proxy bypass error:`)}\n${err.stack}`, {
-						timestamp: true,
-						error: err
-					});
+					if (opts.rewrite) req.url = opts.rewrite(url);
+					debug$8?.(`${req.url} -> ws ${opts.target}`);
+					proxy.ws(req, socket, head);
 					return;
 				}
-				if (opts.rewrite) req.url = opts.rewrite(url);
-				debug$8?.(`${req.url} -> ws ${opts.target}`);
-				proxy.ws(req, socket, head);
-				return;
 			}
 		}
 	});
 	return async function viteProxyMiddleware(req, res, next) {
 		const url = req.url;
-		for (const context in proxies) if (doesProxyContextMatchUrl(context, url)) {
-			const [proxy, opts] = proxies[context];
-			const options = {};
-			if (opts.bypass) try {
-				const bypassResult = await opts.bypass(req, res, opts);
-				if (typeof bypassResult === "string") {
-					debug$8?.(`bypass: ${req.url} -> ${bypassResult}`);
-					req.url = bypassResult;
-					if (res.writableEnded) return;
-					return next();
-				}
-				if (bypassResult === false) {
-					debug$8?.(`bypass: ${req.url} -> 404`);
-					res.statusCode = 404;
-					return res.end();
+		for (const context in proxies) {
+			const { proxy, options: opts, match } = proxies[context];
+			if (match(url)) {
+				const options = {};
+				if (opts.bypass) try {
+					const bypassResult = await opts.bypass(req, res, opts);
+					if (typeof bypassResult === "string") {
+						debug$8?.(`bypass: ${req.url} -> ${bypassResult}`);
+						req.url = bypassResult;
+						if (res.writableEnded) return;
+						return next();
+					}
+					if (bypassResult === false) {
+						debug$8?.(`bypass: ${req.url} -> 404`);
+						res.statusCode = 404;
+						return res.end();
+					}
+				} catch (e) {
+					debug$8?.(`bypass: ${req.url} -> ${e}`);
+					return next(e);
 				}
-			} catch (e) {
-				debug$8?.(`bypass: ${req.url} -> ${e}`);
-				return next(e);
+				debug$8?.(`${req.url} -> ${opts.target || opts.forward}`);
+				if (opts.rewrite) req.url = opts.rewrite(req.url);
+				proxy.web(req, res, options);
+				return;
 			}
-			debug$8?.(`${req.url} -> ${opts.target || opts.forward}`);
-			if (opts.rewrite) req.url = opts.rewrite(req.url);
-			proxy.web(req, res, options);
-			return;
 		}
 		next();
 	};
 }
-function doesProxyContextMatchUrl(context, url) {
-	return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
-}
 //#endregion
 //#region src/node/server/middlewares/rejectInvalidRequest.ts
 /**
@@ -24262,12 +24649,12 @@ async function _createServer(inlineConfig = {}, options) {
 	const publicFiles = await initPublicFilesPromise;
 	const { publicDir } = config;
 	if (httpServer) setClientErrorHandler(httpServer, config.logger);
-	const watcher = serverConfig.watch !== null ? import_chokidar.watch([
+	const watcher = serverConfig.watch !== null ? makeWatcherCloseFinal(import_chokidar.watch([
 		...config.experimental.bundledDev ? [] : [root],
 		...config.configFileDependencies,
 		...getEnvFilesForMode(config.mode, config.envDir),
 		...publicDir && publicFiles ? [publicDir] : []
-	], resolvedWatchOptions) : createNoopWatcher(resolvedWatchOptions);
+	], resolvedWatchOptions)) : createNoopWatcher(resolvedWatchOptions);
 	const environments = {};
 	await Promise.all(Object.entries(config.environments).map(async ([name, environmentOptions]) => {
 		const environment = await environmentOptions.dev.createEnvironment(name, config, { ws });
@@ -25293,6 +25680,7 @@ function optimizedDepsPlugin() {
 				if (info) {
 					if (browserHash && info.browserHash !== browserHash && !environment.config.optimizeDeps.ignoreOutdatedRequests) throwOutdatedRequest(id);
 					try {
+						if (info.processing && depsOptimizer.initState === "idle") debug$7?.(`transforming ${import_picocolors.default.cyan(file)} is waiting for the dependency optimizer to initialize`);
 						await info.processing;
 					} catch {
 						throwProcessingError(id);
@@ -25352,7 +25740,7 @@ function preAliasPlugin(config) {
 			const ssr = environment.config.consumer === "server";
 			const depsOptimizer = environment.depsOptimizer;
 			if (importer && depsOptimizer && bareImportRE.test(id) && !options.scan && id !== "@vite/client" && id !== "@vite/env") {
-				if (findPatterns.find((pattern) => matches(pattern, id))) {
+				if (findPatterns.some((pattern) => matches(pattern, id))) {
 					const optimizedId = await tryOptimizedResolve(depsOptimizer, id, importer, config.resolve.preserveSymlinks, config.packageCache);
 					if (optimizedId) return optimizedId;
 					if (depsOptimizer.options.noDiscovery) return;
@@ -26412,7 +26800,7 @@ function preload(baseModule, deps, importerUrl) {
 				link.addEventListener("load", res);
 				link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
 			});
-		}));
+		}).filter((p) => p !== void 0));
 	}
 	function handlePreloadError(err) {
 		const e = new Event("vite:preloadError", { cancelable: true });
@@ -27396,7 +27784,7 @@ function devToScanEnvironment(environment) {
 }
 const debug$5 = createDebugger("vite:deps");
 const htmlTypesRE = /\.(?:html|vue|svelte|astro|imba)$/;
-const importsRE = /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type)(?:[\w*{}\n\r\t, ]+from)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm;
+const importsRE = /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type\b)(?:[\w*{}\n\r\t, ]+from)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm;
 function scanImports(environment) {
 	const start = performance$1.now();
 	const { config } = environment;
@@ -33940,10 +34328,8 @@ function resolveRolldownOptions(environment, chunkMetadataMap) {
 			...options.rolldownOptions.resolve,
 			tsconfigFilename: void 0
 		} : options.rolldownOptions.resolve,
-		output: options.rolldownOptions.output,
 		input,
 		plugins,
-		external: options.rolldownOptions.external,
 		onLog(level, log) {
 			onRollupLog(level, log, environment);
 		},
@@ -33987,19 +34373,19 @@ function resolveRolldownOptions(environment, chunkMetadataMap) {
 			chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
 			assetFileNames: libOptions ? `[name].[ext]` : path.posix.join(options.assetsDir, `[name]-[hash].[ext]`),
 			codeSplitting: output.codeSplitting ?? (output.format === "umd" || output.format === "iife" || isSsrTargetWebworkerEnvironment && (typeof input === "string" || Object.keys(input).length === 1) ? false : void 0),
-			comments: typeof output.comments === "boolean" ? output.comments : {
-				annotation: !options.minify || libOptions && (format === "es" || format === "esm"),
-				jsdoc: !options.minify,
-				legal: !options.minify,
-				...output.comments
-			},
 			minify: options.minify === "oxc" ? libOptions && (format === "es" || format === "esm") ? {
 				compress: true,
 				mangle: true,
 				codegen: false
 			} : true : options.minify === false ? "dce-only" : false,
 			topLevelVar: true,
-			...output
+			...output,
+			comments: typeof output.comments === "boolean" ? output.comments : {
+				annotation: !options.minify || libOptions && (format === "es" || format === "esm"),
+				jsdoc: !options.minify,
+				legal: !options.minify,
+				...output.comments
+			}
 		};
 	};
 	const outputs = resolveBuildOutputs(options.rolldownOptions.output, libOptions, logger);
@@ -35097,6 +35483,7 @@ function createDepsOptimizer(environment) {
 	let metadata = initDepsOptimizerMetadata(environment, sessionTimestamp);
 	const depsOptimizer = {
 		init,
+		initState: "idle",
 		metadata,
 		registerMissingImport,
 		run: () => debouncedProcessing(0),
@@ -35137,16 +35524,19 @@ function createDepsOptimizer(environment) {
 	let discover;
 	async function close() {
 		closed = true;
+		if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
+		debounceProcessingHandle = void 0;
 		await Promise.allSettled([
 			discover?.cancel(),
 			depsOptimizer.scanProcessing,
 			optimizationResult?.cancel()
 		]);
+		depOptimizationProcessing.resolve();
+		resolveEnqueuedProcessingPromises();
 	}
-	let initState = "idle";
 	async function init() {
-		if (initState !== "idle") return;
-		initState = "initializing";
+		if (depsOptimizer.initState !== "idle") return;
+		depsOptimizer.initState = "initializing";
 		const cachedMetadata = await loadCachedDepOptimizationMetadata(environment);
 		firstRunCalled = !!cachedMetadata;
 		metadata = depsOptimizer.metadata = cachedMetadata || initDepsOptimizerMetadata(environment, sessionTimestamp);
@@ -35203,7 +35593,7 @@ function createDepsOptimizer(environment) {
 				})();
 			});
 		}
-		initState = "initialized";
+		depsOptimizer.initState = "initialized";
 	}
 	function startNextDiscoveredBatch() {
 		newDepsDiscovered = false;
@@ -35227,8 +35617,6 @@ function createDepsOptimizer(environment) {
 		if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
 		if (closed) {
 			currentlyProcessing = false;
-			depOptimizationProcessing.resolve();
-			resolveEnqueuedProcessingPromises();
 			return;
 		}
 		currentlyProcessing = true;
@@ -35245,7 +35633,6 @@ function createDepsOptimizer(environment) {
 			if (closed) {
 				currentlyProcessing = false;
 				processingResult.cancel();
-				resolveEnqueuedProcessingPromises();
 				return;
 			}
 			const newData = processingResult.metadata;
@@ -35340,7 +35727,7 @@ function createDepsOptimizer(environment) {
 		let missing = metadata.discovered[id];
 		if (missing) return missing;
 		missing = addMissingDep(id, resolved);
-		if (initState === "initialized" && !waitingForCrawlEnd) debouncedProcessing();
+		if (depsOptimizer.initState === "initialized" && !waitingForCrawlEnd) debouncedProcessing();
 		return missing;
 	}
 	function addMissingDep(id, resolved) {
@@ -35417,6 +35804,7 @@ function createDepsOptimizer(environment) {
 function createExplicitDepsOptimizer(environment) {
 	const depsOptimizer = {
 		metadata: initDepsOptimizerMetadata(environment),
+		initState: "idle",
 		isOptimizedDepFile: createIsOptimizedDepFile(environment),
 		isOptimizedDepUrl: createIsOptimizedDepUrl(environment),
 		getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
@@ -35428,11 +35816,11 @@ function createExplicitDepsOptimizer(environment) {
 		close: async () => {},
 		options: environment.config.optimizeDeps
 	};
-	let inited = false;
 	async function init() {
-		if (inited) return;
-		inited = true;
+		if (depsOptimizer.initState !== "idle") return;
+		depsOptimizer.initState = "initializing";
 		depsOptimizer.metadata = await optimizeExplicitEnvironmentDeps(environment);
+		depsOptimizer.initState = "initialized";
 	}
 	return depsOptimizer;
 }