rollup 4.63.1 → 4.63.3

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.63.1
-	Fri, 28 Aug 2026 05:58:50 GMT - commit 78bfef0cb94479566f81012fafa372c84b90bd34
+	Rollup.js v4.63.3
+	Mon, 14 Sep 2026 12:44:36 GMT - commit 250deca2945f8817350564f7d52bab0f79175d1b
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _mergeNamespaces(n, m) {
   return Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' });
 }
 
-var version = "4.63.1";
+var version = "4.63.3";
 const pkg = {
 	version: version};
 
@@ -42,7 +42,7 @@ for (let i = 0; i < chars$1.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function decodeInteger(reader, relative) {
+function decodeInteger(reader) {
   let value = 0;
   let shift = 0;
   let integer = 0;
@@ -52,23 +52,21 @@ function decodeInteger(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;
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
     builder.write(intToChar[clamped]);
-  } while (delta > 0);
-  return num;
+  } while (num > 0);
+}
+function encodeSign(num) {
+  return num < 0 ? -num << 1 | 1 : num << 1;
 }
 function hasMoreVlq(reader, max) {
   if (reader.pos >= max) return false;
@@ -127,6 +125,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) {
@@ -146,15 +159,15 @@ function decode(mappings) {
     genColumn = 0;
     while (reader.pos < semi) {
       let seg;
-      genColumn = decodeInteger(reader, genColumn);
+      genColumn += decodeSign(decodeInteger(reader));
       if (genColumn < lastCol) sorted = false;
       lastCol = genColumn;
       if (hasMoreVlq(reader, semi)) {
-        sourcesIndex = decodeInteger(reader, sourcesIndex);
-        sourceLine = decodeInteger(reader, sourceLine);
-        sourceColumn = decodeInteger(reader, sourceColumn);
+        sourcesIndex += decodeSign(decodeInteger(reader));
+        sourceLine += decodeSign(decodeInteger(reader));
+        sourceColumn += decodeSign(decodeInteger(reader));
         if (hasMoreVlq(reader, semi)) {
-          namesIndex = decodeInteger(reader, namesIndex);
+          namesIndex += decodeSign(decodeInteger(reader));
           seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
         } else {
           seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
@@ -191,13 +204,18 @@ function encode(decoded) {
     for (let j = 0; j < line.length; j++) {
       const segment = line[j];
       if (j > 0) writer.write(comma);
-      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();
@@ -316,8 +334,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);
@@ -330,10 +350,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 {
@@ -360,12 +382,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 {
@@ -378,6 +402,14 @@ var SourceMap = class {
 		this.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)`
@@ -396,12 +428,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;
@@ -455,7 +483,10 @@ function isObject(thing) {
 }
 //#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) {
 		this.hires = hires;
@@ -463,9 +494,12 @@ var Mappings = class {
 		this.generatedCodeColumn = 0;
 		this.raw = [];
 		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.rawRangeMappings = [];
+		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
 		this.pending = null;
 	}
 	addEdit(sourceIndex, content, loc, nameIndex) {
+		/* v8 ignore else -- `pending` is never assigned a truthy value */
 		if (content.length) {
 			const contentLengthMinusOne = content.length - 1;
 			let contentLineEnd = content.indexOf("\n", 0);
@@ -481,6 +515,7 @@ var Mappings = class {
 				this.rawSegments.push(segment);
 				this.generatedCodeLine += 1;
 				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
 				this.generatedCodeColumn = 0;
 				previousContentLineEnd = contentLineEnd;
 				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
@@ -501,56 +536,128 @@ var Mappings = class {
 		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";
+			let charInHiresBoundary = false;
+			while (i < end) {
+				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.generatedCodeLine += 1;
+					this.raw[this.generatedCodeLine] = this.rawSegments = [];
+					this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+					this.generatedCodeColumn = 0;
+					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.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+				this.generatedCodeColumn = 0;
+				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++) {
+		const lastNewline = str.lastIndexOf("\n");
+		if (lastNewline !== -1) {
+			for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) {
 				this.generatedCodeLine++;
 				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
 			}
 			this.generatedCodeColumn = 0;
 		}
-		this.generatedCodeColumn += lines[lines.length - 1].length;
+		this.generatedCodeColumn += str.length - lastNewline - 1;
 	}
 };
 //#endregion
@@ -563,6 +670,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);
@@ -732,7 +896,8 @@ var MagicString = class MagicString {
 			sourcesContent: options.includeContent ? [this.original] : void 0,
 			names,
 			mappings: mappings.raw,
-			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0,
+			rangeMappings: mappings.rawRangeMappings
 		};
 	}
 	/**
@@ -772,17 +937,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;
@@ -791,11 +957,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) {
@@ -825,10 +989,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 */
@@ -922,8 +1087,8 @@ var MagicString = class MagicString {
 		end = end + this.offset;
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start < 0) throw new MagicStringError(`start ${start} is out of bounds`);
 		if (end > this.original.length) throw new MagicStringError(`end ${end} is out of bounds`);
@@ -951,6 +1116,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) {
@@ -1006,8 +1172,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start === end) return this;
 		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
@@ -1030,8 +1196,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start === end) return this;
 		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
@@ -1092,8 +1258,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		let result = "";
 		let chunk = this.firstChunk;
@@ -1168,11 +1334,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() {
@@ -1271,35 +1439,23 @@ var MagicString = class MagicString {
 	/** @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);
-		}
-		function matchAll(re, str) {
-			const matches = [];
-			while (true) {
-				const match = re.exec(str);
-				if (!match) break;
-				matches.push(match);
-			}
-			return matches;
+			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);
 		}
-		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
-			if (match.index != null) {
-				const replacement = getReplacement(match, this.original);
-				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
-			}
-		});
-		else {
+		const replaceMatch = (match) => {
+			/* v8 ignore next 2 -- `match.index` is always defined for matches from `matchAll` */
+			if (match.index == null) return;
+			const replacement = getReplacement(match, this.original);
+			if (replacement === match[0]) return;
+			if (match[0].length === 0) this.appendRight(match.index, replacement);
+			else this.overwrite(match.index, match.index + match[0].length, replacement);
+		};
+		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 && match.index != null) {
-				const replacement = getReplacement(match, this.original);
-				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
-			}
+			if (match) replaceMatch(match);
 		}
 		return this;
 	}
@@ -1309,7 +1465,11 @@ var MagicString = class MagicString {
 		const index = original.indexOf(string);
 		if (index !== -1) {
 			if (typeof replacement === "function") replacement = replacement(string, index, original);
-			if (string !== replacement) 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);
+			}
 		}
 		return this;
 	}
@@ -1324,9 +1484,16 @@ var MagicString = class MagicString {
 	_replaceAllString(string, replacement) {
 		const { original } = this;
 		const stringLength = string.length;
+		if (stringLength === 0) {
+			for (let index = 0; index <= original.length; index += 1) {
+				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)) {
 			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;
@@ -1377,15 +1544,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;
@@ -1424,7 +1593,9 @@ var Bundle$1 = class Bundle {
 		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);
@@ -1432,9 +1603,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);
@@ -1449,11 +1621,12 @@ var Bundle$1 = class Bundle {
 				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
+			x_google_ignoreList,
+			rangeMappings: mappings.rawRangeMappings
 		};
 	}
 	generateMap(options) {
@@ -1468,7 +1641,7 @@ var Bundle$1 = class Bundle {
 			indentStringCounts[indentStr] += 1;
 		});
 		return Object.keys(indentStringCounts).sort((a, b) => {
-			return indentStringCounts[a] - indentStringCounts[b];
+			return indentStringCounts[b] - indentStringCounts[a];
 		})[0] || "	";
 	}
 	indent(indentStr) {
@@ -1476,6 +1649,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, {
@@ -1495,6 +1669,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("");
@@ -1503,6 +1678,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;
@@ -1510,8 +1686,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() {
@@ -1523,27 +1700,27 @@ var Bundle$1 = class Bundle {
 	trimStart(charType) {
 		const rx = new RegExp(`^${charType || "\\s"}+`);
 		this.intro = this.intro.replace(rx, "");
-		if (!this.intro) {
-			let source;
-			let i = 0;
-			do {
-				source = this.sources[i++];
-				if (!source) break;
-			} while (!source.content.trimStartAborted(charType));
+		if (!this.intro) for (let i = 0; i < this.sources.length; i += 1) {
+			const source = this.sources[i];
+			if (i > 0) {
+				source.separator = (source.separator !== void 0 ? source.separator : this.separator).replace(rx, "");
+				if (source.separator) break;
+			}
+			if (source.content.trimStartAborted(charType)) break;
 		}
 		return this;
 	}
 	trimEnd(charType) {
 		const rx = new RegExp(`${charType || "\\s"}+$`);
-		let source;
-		let i = this.sources.length - 1;
-		do {
-			source = this.sources[i--];
-			if (!source) {
-				this.intro = this.intro.replace(rx, "");
-				break;
+		for (let i = this.sources.length - 1; i >= 0; i -= 1) {
+			const source = this.sources[i];
+			if (source.content.trimEndAborted(charType)) return this;
+			if (i > 0) {
+				source.separator = (source.separator !== void 0 ? source.separator : this.separator).replace(rx, "");
+				if (source.separator) return this;
 			}
-		} while (!source.content.trimEndAborted(charType));
+		}
+		this.intro = this.intro.replace(rx, "");
 		return this;
 	}
 };
@@ -1594,6 +1771,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) {
@@ -1602,7 +1787,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 /*"/"*/)