rollup 4.63.2 → 4.63.4

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.63.2
-	Sat, 12 Sep 2026 06:36:48 GMT - commit 43ed4ec364940fbce7054d8da1f92c695d1e6808
+	Rollup.js v4.63.4
+	Sat, 19 Sep 2026 06:35:38 GMT - commit ba78d5752a1e1ff4ff4af3a8bffab7691d822f7d
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.63.2";
+var version = "4.63.4";
 const package_ = {
 	version: version};
 
@@ -3805,7 +3805,7 @@ class PluginDriver {
     /**
      * Run a sync plugin hook and return the result.
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-     * @param args Arguments passed to the plugin hook.
+     * @param parameters Arguments passed to the plugin hook.
      * @param plugin The actual plugin
      * @param replaceContext When passed, the plugin context can be overridden.
      */
@@ -4225,11 +4225,11 @@ function handleError(error, recover = false) {
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar = new Uint8Array(64);
+var intToChar$1 = new Uint8Array(64);
 var charToInt = new Uint8Array(128);
 for (let i = 0; i < chars.length; i++) {
   const c = chars.charCodeAt(i);
-  intToChar[i] = c;
+  intToChar$1[i] = c;
   charToInt[c] = i;
 }
 function decodeInteger(reader) {
@@ -4252,7 +4252,7 @@ function encodeInteger(builder, num) {
     let clamped = num & 31;
     num >>>= 5;
     if (num > 0) clamped |= 32;
-    builder.write(intToChar[clamped]);
+    builder.write(intToChar$1[clamped]);
   } while (num > 0);
 }
 function encodeSign(num) {
@@ -4315,6 +4315,21 @@ var StringReader = 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();
+}
 
 // src/sourcemap-codec.ts
 function decode(mappings) {
@@ -4509,8 +4524,10 @@ var Chunk$1 = 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);
@@ -4523,10 +4540,12 @@ var Chunk$1 = 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 {
@@ -4553,12 +4572,14 @@ var MagicStringError = class extends Error {
 //#endregion
 //#region src/SourceMap.ts
 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 = /* #__PURE__ */ getBtoa();
 var SourceMap = class {
@@ -4568,9 +4589,17 @@ var SourceMap = class {
 		this.sources = properties.sources;
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
-		this.mappings = encode(properties.mappings);
+		this.mappings = typeof properties.mappings === "string" ? properties.mappings : encode(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)`
@@ -4589,12 +4618,8 @@ var SourceMap = class {
 //#endregion
 //#region src/utils/getLocator.ts
 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;
@@ -4646,17 +4671,122 @@ const toString = Object.prototype.toString;
 function isObject(thing) {
 	return toString.call(thing) === "[object Object]";
 }
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = /* #__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[clamped];
+	} while (num > 0);
+	return pos;
+}
+const decoder = /* #__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.decode(scratch.subarray(0, this.pos));
+		this.pos = 0;
+	}
+};
 //#endregion
 //#region src/utils/Mappings.ts
-const wordRegex = /\w/;
+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) {
@@ -4672,9 +4802,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);
 			}
@@ -4687,63 +4815,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
+					]);
+					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
-					];
-					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
+					]);
+					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;
 	}
 };
 //#endregion
@@ -4756,6 +4943,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$1(0, string.length, string);
@@ -4906,9 +5150,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) => {
@@ -4919,21 +5186,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);
@@ -4965,17 +5229,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;
@@ -4984,11 +5249,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) {
@@ -5018,10 +5281,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 */
@@ -5046,8 +5310,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;
@@ -5067,9 +5337,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;
@@ -5144,6 +5432,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) {
@@ -5193,6 +5482,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) {
@@ -5209,9 +5501,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;
@@ -5291,12 +5583,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`);
@@ -5361,11 +5654,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() {
@@ -5407,7 +5702,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.
@@ -5434,7 +5730,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.
@@ -5461,41 +5758,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;
 	}
@@ -5512,14 +5834,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;
@@ -5570,15 +5893,17 @@ var Bundle$1 = class Bundle {
 			if (!hasOwnProp.call(source, option)) source[option] = source.content[option];
 		});
 		if (source.separator === void 0) source.separator = this.separator;
-		if (source.filename) if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
-			this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
-			this.uniqueSources.push({
-				filename: source.filename,
-				content: source.content.original
-			});
-		} else {
-			const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
-			if (source.content.original !== uniqueSource.content) throw new MagicStringError(`duplicate filename "${source.filename}" with different content, use unique filenames`);
+		if (source.filename) {
+			if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
+				this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
+				this.uniqueSources.push({
+					filename: source.filename,
+					content: source.content.original
+				});
+			} else {
+				const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
+				if (source.content.original !== uniqueSource.content) throw new MagicStringError(`duplicate filename "${source.filename}" with different content, use unique filenames`);
+			}
 		}
 		this.sources.push(source);
 		return this;
@@ -5606,7 +5931,103 @@ var Bundle$1 = class Bundle {
 		});
 		return bundle;
 	}
+	/**
+	* Flattens the bundle into a single `MagicString`, so the concatenated result can be
+	* processed further with the full `MagicString` API. The returned string's `original`
+	* is the concatenation of every source's `original`, and all existing edits, inserts,
+	* intros, outros and separators are preserved as inserted content, so its `toString()`
+	* equals the bundle's `toString()` and its sourcemap maps back to that combined original.
+	*
+	* Because a `MagicString` maps to a single source, per-source `filename`s are not carried
+	* over; generate the bundle's map before flattening if you need the multi-source mapping.
+	*/
+	toMagicString() {
+		const combined = new MagicString(this.sources.map((source) => source.content.original).join(""));
+		let offset = 0;
+		let pending = this.intro;
+		let first = null;
+		let last = null;
+		const byStart = /* @__PURE__ */ new Map();
+		const byEnd = /* @__PURE__ */ new Map();
+		let hasMovedChunks = false;
+		this.sources.forEach((source, i) => {
+			const magicString = source.content;
+			const separator = i > 0 ? source.separator !== void 0 ? source.separator : this.separator : "";
+			if (magicString.original.length === 0) {
+				pending += separator + magicString.toString();
+				return;
+			}
+			pending += separator + magicString.intro;
+			let sourceFirst = null;
+			let previous = null;
+			let originalChunk = magicString.firstChunk;
+			while (originalChunk) {
+				const chunk = originalChunk.clone();
+				chunk.start += offset;
+				chunk.end += offset;
+				chunk.previous = previous;
+				chunk.next = null;
+				if (previous) previous.next = chunk;
+				byStart.set(chunk.start, chunk);
+				byEnd.set(chunk.end, chunk);
+				sourceFirst ??= chunk;
+				previous = chunk;
+				originalChunk = originalChunk.next;
+			}
+			const sourceLast = previous;
+			sourceFirst.intro = pending + sourceFirst.intro;
+			pending = "";
+			sourceLast.outro += magicString.outro;
+			if (last) {
+				last.next = sourceFirst;
+				sourceFirst.previous = last;
+			} else first = sourceFirst;
+			last = sourceLast;
+			for (let index = 0; index < magicString.original.length; index += 1) if (magicString.sourcemapLocations.has(index)) combined.sourcemapLocations.add(index + offset);
+			Object.keys(magicString.storedNames).forEach((name) => {
+				Object.defineProperty(combined.storedNames, name, {
+					writable: true,
+					value: true,
+					enumerable: true
+				});
+			});
+			if (magicString.hasMovedChunks) hasMovedChunks = true;
+			offset += magicString.original.length;
+		});
+		if (!first) {
+			combined.intro = pending;
+			return combined;
+		}
+		if (pending) last.outro += pending;
+		combined.firstChunk = first;
+		combined.lastChunk = last;
+		combined.lastSearchedChunk = first;
+		combined.byStart = byStart;
+		combined.byEnd = byEnd;
+		combined.hasMovedChunks = hasMovedChunks;
+		return combined;
+	}
 	generateDecodedMap(options = {}) {
+		const mappings = new Mappings(options.hires);
+		const { names, x_google_ignoreList } = this._generateMappings(mappings);
+		return {
+			...this._mapProperties(options, names, x_google_ignoreList),
+			mappings: mappings.raw,
+			rangeMappings: mappings.rawRangeMappings
+		};
+	}
+	generateMap(options = {}) {
+		const encoder = new MappingsEncoder();
+		const mappings = new Mappings(options.hires, encoder);
+		const { names, x_google_ignoreList } = this._generateMappings(mappings);
+		return new SourceMap({
+			...this._mapProperties(options, names, x_google_ignoreList),
+			mappings: encoder.finish(mappings.rawSegments),
+			rangeMappings: mappings.rawRangeMappings
+		});
+	}
+	/** @internal */
+	_generateMappings(mappings) {
 		const names = [];
 		let x_google_ignoreList;
 		this.sources.forEach((source) => {
@@ -5614,10 +6035,11 @@ var Bundle$1 = class Bundle {
 				if (!names.includes(name)) names.push(name);
 			});
 		});
-		const mappings = new Mappings(options.hires);
 		if (this.intro) mappings.advance(this.intro);
 		this.sources.forEach((source, i) => {
-			if (i > 0) mappings.advance(source.separator !== void 0 ? source.separator : this.separator);
+			if (i > 0)
+ /* v8 ignore next -- addSource always normalizes source.separator */
+			mappings.advance(source.separator !== void 0 ? source.separator : this.separator);
 			const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
 			const magicString = source.content;
 			const locate = getLocator(magicString.original);
@@ -5625,9 +6047,10 @@ var Bundle$1 = class Bundle {
 			magicString.firstChunk.eachNext((chunk) => {
 				const loc = locate(chunk.start);
 				if (chunk.intro.length) mappings.advance(chunk.intro);
-				if (source.filename) if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
-				else mappings.addUneditedChunk(sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations);
-				else mappings.advance(chunk.content);
+				if (source.filename) {
+					if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+					else mappings.addUneditedChunk(sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations);
+				} else mappings.advance(chunk.content);
 				if (chunk.outro.length) mappings.advance(chunk.outro);
 			});
 			if (magicString.outro) mappings.advance(magicString.outro);
@@ -5636,22 +6059,25 @@ var Bundle$1 = class Bundle {
 				x_google_ignoreList.push(sourceIndex);
 			}
 		});
+		return {
+			names,
+			x_google_ignoreList
+		};
+	}
+	/** @internal */
+	_mapProperties(options, names, x_google_ignoreList) {
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
 			sources: this.uniqueSources.map((source) => {
 				return options.file ? getRelativePath(options.file, source.filename) : source.filename;
 			}),
 			sourcesContent: this.uniqueSources.map((source) => {
-				return options.includeContent ? source.content : null;
+				return (typeof options.includeContent === "function" ? options.includeContent(source) : options.includeContent) ? source.content : null;
 			}),
 			names,
-			mappings: mappings.raw,
 			x_google_ignoreList
 		};
 	}
-	generateMap(options) {
-		return new SourceMap(this.generateDecodedMap(options));
-	}
 	getIndentString() {
 		const indentStringCounts = {};
 		this.sources.forEach((source) => {
@@ -5669,6 +6095,7 @@ var Bundle$1 = class Bundle {
 		if (indentStr === "") return this;
 		let trailingNewline = !this.intro || this.intro.slice(-1) === "\n";
 		this.sources.forEach((source, i) => {
+			/* v8 ignore next -- addSource always normalizes source.separator */
 			const separator = source.separator !== void 0 ? source.separator : this.separator;
 			const indentStart = trailingNewline || i > 0 && /\r?\n$/.test(separator);
 			source.content.indent(indentStr, {
@@ -5688,6 +6115,7 @@ var Bundle$1 = class Bundle {
 	}
 	toString() {
 		const body = this.sources.map((source, i) => {
+			/* v8 ignore next -- addSource always normalizes source.separator */
 			const separator = source.separator !== void 0 ? source.separator : this.separator;
 			return (i > 0 ? separator : "") + source.content.toString();
 		}).join("");
@@ -5696,6 +6124,7 @@ var Bundle$1 = class Bundle {
 	isEmpty() {
 		if (this.intro.length && this.intro.trim()) return false;
 		if (this.sources.some((source, i) => {
+			/* v8 ignore next -- addSource always normalizes source.separator */
 			const separator = source.separator !== void 0 ? source.separator : this.separator;
 			return i > 0 && separator.trim() !== "" || !source.content.isEmpty();
 		})) return false;
@@ -5703,8 +6132,9 @@ var Bundle$1 = class Bundle {
 	}
 	length() {
 		return this.sources.reduce((length, source, i) => {
+			/* v8 ignore next -- addSource always normalizes source.separator */
 			const separator = source.separator !== void 0 ? source.separator : this.separator;
-			return length + (i > 0 ? separator.length : 0) + source.content.length();
+			return length + (i > 0 ? separator.length : 0) + source.content.toString().length;
 		}, this.intro.length);
 	}
 	trimLines() {
@@ -5787,6 +6217,14 @@ function findLastWhiteSpaceReverse(code, start, end) {
         }
     }
 }
+// A CRLF pair is one line break and must be removed as one. Removing only the
+// LF leaves the CR, which is still a line terminator, so ASI fires anyway and
+// the operand after a `return` or `throw` becomes dead code.
+function getLineBreakStart(code, lineBreakPos) {
+    return lineBreakPos > 0 && code.charCodeAt(lineBreakPos - 1) === 13 /*"\r"*/
+        ? lineBreakPos - 1
+        : lineBreakPos;
+}
 // This assumes "code" only contains white-space and comments
 // Returns position of line-comment if applicable
 function findFirstLineBreakOutsideComment(code) {
@@ -5795,7 +6233,7 @@ function findFirstLineBreakOutsideComment(code) {
     while (true) {
         start = code.indexOf('/', start);
         if (start === -1 || start > lineBreakPos)
-            return [lineBreakPos, lineBreakPos + 1];
+            return [getLineBreakStart(code, lineBreakPos), lineBreakPos + 1];
         // With our assumption, '/' always starts a comment. Determine comment type:
         charCodeAfterSlash = code.charCodeAt(start + 1);
         if (charCodeAfterSlash === 47 /*"/"*/)
@@ -12145,7 +12583,7 @@ function formatAttributes(attributes, { getObject }) {
     if (!attributes) {
         return null;
     }
-    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, `'${value}'`]);
+    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, JSON.stringify(value)]);
     if (assertionEntries.length > 0) {
         return getObject(assertionEntries, { lineBreakIndent: null });
     }
@@ -19279,7 +19717,7 @@ class Module {
         }
         return null;
     }
-    updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
+    updateOptions({ meta, moduleSideEffects, syntheticNamedExports }, { replaceExistingMeta = false } = parseAst_js.EMPTY_OBJECT) {
         if (moduleSideEffects != null) {
             this.info.moduleSideEffects = moduleSideEffects;
         }
@@ -19287,6 +19725,11 @@ class Module {
             this.info.syntheticNamedExports = syntheticNamedExports;
         }
         if (meta != null) {
+            if (replaceExistingMeta) {
+                for (const key of Object.keys(this.info.meta)) {
+                    delete this.info.meta[key];
+                }
+            }
             Object.assign(this.info.meta, meta);
         }
     }
@@ -22991,8 +23434,14 @@ class ModuleLoader {
         const cachedModule = this.graph.cachedModules.get(id);
         if (cachedModule &&
             !cachedModule.customTransformCache &&
-            cachedModule.originalCode === sourceDescription.code &&
-            !(await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
+            cachedModule.originalCode === sourceDescription.code) {
+            const originalModuleOptions = {
+                meta: { ...module.info.meta },
+                moduleSideEffects: module.info.moduleSideEffects,
+                syntheticNamedExports: module.info.syntheticNamedExports
+            };
+            module.updateOptions(cachedModule);
+            if (await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
                 {
                     ast: cachedModule.ast,
                     attributes: cachedModule.attributes,
@@ -23003,17 +23452,20 @@ class ModuleLoader {
                     resolvedSources: cachedModule.resolvedIds,
                     syntheticNamedExports: cachedModule.syntheticNamedExports
                 }
-            ]))) {
-            if (cachedModule.transformFiles) {
-                for (const emittedFile of cachedModule.transformFiles)
-                    this.pluginDriver.emitFile(emittedFile);
+            ])) {
+                module.updateOptions(originalModuleOptions, { replaceExistingMeta: true });
+            }
+            else {
+                if (cachedModule.transformFiles) {
+                    for (const emittedFile of cachedModule.transformFiles)
+                        this.pluginDriver.emitFile(emittedFile);
+                }
+                await module.setSource(cachedModule);
+                return;
             }
-            await module.setSource(cachedModule);
-        }
-        else {
-            module.updateOptions(sourceDescription);
-            await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options));
         }
+        module.updateOptions(sourceDescription);
+        await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options));
     }
     async awaitLoadModulesPromise() {
         let startingPromise;