void 0.10.12 → 0.20.0

package/dist/{magic-string.es-ZQjdJFFn.mjs → dist-BR1quN_w.mjs}

@@ -1,4 +1,4 @@
-//#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 = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -9,18 +9,18 @@ for (let i = 0; i < chars.length; i++) {
 	intToChar[i] = c;
 	charToInt[c] = i;
 }
-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);
 }
-var bufLength = 1024 * 16;
+function encodeSign(num) {
+	return num < 0 ? -num << 1 | 1 : num << 1;
+}
+var bufLength = 16384;
 var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
 	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
 } } : { decode(buf) {
@@ -47,6 +47,21 @@ var StringWriter = class {
 		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
 	}
 };
+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 encode(decoded) {
 	const writer = new StringWriter();
 	let sourcesIndex = 0;
@@ -61,19 +76,24 @@ 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();
 }
 //#endregion
-//#region ../../node_modules/.pnpm/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
+//#region ../../node_modules/.pnpm/magic-string@1.3.1/node_modules/magic-string/dist/index.mjs
 var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -117,14 +137,16 @@ var Chunk = class Chunk {
 		return this.start < index && index < this.end;
 	}
 	eachNext(fn) {
-		let chunk = this;
+		fn(this);
+		let chunk = this.next;
 		while (chunk) {
 			fn(chunk);
 			chunk = chunk.next;
 		}
 	}
 	eachPrevious(fn) {
-		let chunk = this;
+		fn(this);
+		let chunk = this.previous;
 		while (chunk) {
 			fn(chunk);
 			chunk = chunk.previous;
@@ -183,8 +205,8 @@ var Chunk = class Chunk {
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
 			if (trimmed !== this.content) {
-				this.split(this.start + trimmed.length).edit("", void 0, true);
 				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else this.split(this.start + trimmed.length).edit("", void 0, true);
 			}
 			return true;
 		} else {
@@ -199,9 +221,11 @@ var Chunk = class Chunk {
 		const trimmed = this.content.replace(rx, "");
 		if (trimmed.length) {
 			if (trimmed !== this.content) {
-				const newChunk = this.split(this.end - trimmed.length);
-				if (this.edited) newChunk.edit(trimmed, this.storeName, true);
-				this.edit("", void 0, true);
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else {
+					this.split(this.end - trimmed.length);
+					this.edit("", void 0, true);
+				}
 			}
 			return true;
 		} else {
@@ -211,14 +235,29 @@ var Chunk = class Chunk {
 		}
 	}
 };
+/**
+* The single error type thrown by MagicString.
+*
+* Every message is prefixed with `[MagicString]` so its source is obvious at a
+* glance, and is kept short and consistent in tone.
+*/
+var MagicStringError = class extends Error {
+	name = "MagicStringError";
+	constructor(message, options) {
+		super(`[MagicString] ${message}`, options);
+	}
+};
 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)));
-	else if (typeof Buffer === "function") return (str) => Buffer.from(str, "utf-8").toString("base64");
-	else return () => {
-		throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+	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();
+const btoa = /* #__PURE__ */ getBtoa();
 var SourceMap = class {
 	constructor(properties) {
 		this.version = 3;
@@ -229,25 +268,46 @@ 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)`
+	*/
 	toString() {
 		return JSON.stringify(this);
 	}
+	/**
+	* Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+	* `generateMap(options?: SourceMapOptions): SourceMap;`
+	*/
 	toUrl() {
-		return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+		return `data:application/json;charset=utf-8;base64,${btoa(this.toString())}`;
 	}
 };
-function guessIndent(code) {
-	const lines = code.split("\n");
-	const tabbed = lines.filter((line) => /^\t+/.test(line));
-	const spaced = lines.filter((line) => /^ {2,}/.test(line));
-	if (tabbed.length === 0 && spaced.length === 0) return null;
-	if (tabbed.length >= spaced.length) return "	";
-	const min = spaced.reduce((previous, current) => {
-		const numSpaces = /^ +/.exec(current)[0].length;
-		return Math.min(numSpaces, previous);
-	}, Infinity);
-	return new Array(min + 1).join(" ");
+function getLocator(source) {
+	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;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
 }
 function getRelativePath(from, to) {
 	const fromParts = from.split(/[/\\]/);
@@ -263,33 +323,26 @@ function getRelativePath(from, to) {
 	}
 	return fromParts.concat(toParts).join("/");
 }
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return " ".repeat(min);
+}
 const toString = Object.prototype.toString;
 function isObject(thing) {
 	return toString.call(thing) === "[object Object]";
 }
-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;
-	}
-	return function locate(index) {
-		let i = 0;
-		let j = lineOffsets.length;
-		while (i < j) {
-			const m = i + j >> 1;
-			if (index < lineOffsets[m]) j = m;
-			else i = m + 1;
-		}
-		const line = i - 1;
-		return {
-			line,
-			column: index - lineOffsets[line]
-		};
-	};
+const NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
 }
-const wordRegex = /\w/;
 var Mappings = class {
 	constructor(hires) {
 		this.hires = hires;
@@ -297,9 +350,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);
@@ -315,6 +371,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);
@@ -335,64 +392,195 @@ 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
-					];
-					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.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;
 	}
 };
 const n = "\n";
+const NEWLINE_CHAR = "\n".charCodeAt(0);
+const CR_CHAR = "\r".charCodeAt(0);
 const warned = {
 	insertLeft: false,
 	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);
@@ -423,11 +611,11 @@ var MagicString = class MagicString {
 			},
 			byStart: {
 				writable: true,
-				value: {}
+				value: /* @__PURE__ */ new Map([[0, chunk]])
 			},
 			byEnd: {
 				writable: true,
-				value: {}
+				value: /* @__PURE__ */ new Map([[string.length, chunk]])
 			},
 			filename: {
 				writable: true,
@@ -456,47 +644,69 @@ var MagicString = class MagicString {
 			offset: {
 				writable: true,
 				value: options.offset || 0
+			},
+			hasMovedChunks: {
+				writable: true,
+				value: false
 			}
 		});
-		this.byStart[0] = chunk;
-		this.byEnd[string.length] = chunk;
 	}
+	/**
+	* Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+	*/
 	addSourcemapLocation(char) {
 		this.sourcemapLocations.add(char);
 	}
+	/**
+	* Appends the specified content to the end of the string.
+	*/
 	append(content) {
-		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this.outro += content;
 		return this;
 	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *ending* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependLeft(...)`.
+	*/
 	appendLeft(index, content) {
 		index = index + this.offset;
-		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
-		const chunk = this.byEnd[index];
+		const chunk = this.byEnd.get(index);
 		if (chunk) chunk.appendLeft(content);
 		else this.intro += content;
 		return this;
 	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *starting* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependRight(...)`.
+	*/
 	appendRight(index, content) {
 		index = index + this.offset;
-		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
-		const chunk = this.byStart[index];
+		const chunk = this.byStart.get(index);
 		if (chunk) chunk.appendRight(content);
 		else this.outro += content;
 		return this;
 	}
+	/**
+	* Does what you'd expect.
+	*/
 	clone() {
 		const cloned = new MagicString(this.original, {
 			filename: this.filename,
+			ignoreList: this.ignoreList,
 			offset: this.offset
 		});
 		let originalChunk = this.firstChunk;
 		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
 		while (originalChunk) {
-			cloned.byStart[clonedChunk.start] = clonedChunk;
-			cloned.byEnd[clonedChunk.end] = clonedChunk;
+			cloned.byStart.set(clonedChunk.start, clonedChunk);
+			cloned.byEnd.set(clonedChunk.end, clonedChunk);
 			const nextOriginalChunk = originalChunk.next;
 			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
 			if (nextClonedChunk) {
@@ -509,10 +719,16 @@ var MagicString = class MagicString {
 		cloned.lastChunk = clonedChunk;
 		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
 		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.storedNames = { ...this.storedNames };
 		cloned.intro = this.intro;
 		cloned.outro = this.outro;
+		cloned.hasMovedChunks = this.hasMovedChunks;
 		return cloned;
 	}
+	/**
+	* Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+	* Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+	*/
 	generateDecodedMap(options) {
 		options = options || {};
 		const sourceIndex = 0;
@@ -534,15 +750,21 @@ 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
 		};
 	}
+	/**
+	* 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);
 	}
+	/** @internal */
 	_getRawIndentString() {
 		this._ensureindentStr();
 		return this.indentStr;
@@ -562,55 +784,77 @@ var MagicString = class MagicString {
 			indentStr = this.indentStr || "	";
 		}
 		if (indentStr === "") return this;
+		const resolvedIndentStr = indentStr;
 		options = options || {};
 		const isExcluded = {};
 		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
 			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
 		});
 		let shouldIndentNextCharacter = options.indentStart !== false;
-		const replacer = (match) => {
-			if (shouldIndentNextCharacter) return `${indentStr}${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.appendRight(resolvedIndentStr);
+			else {
+				this._splitChunk(chunk, index);
+				chunk = chunk.next;
+				chunk.prependRight(resolvedIndentStr);
+			}
+		};
 		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) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original.charCodeAt(charIndex);
+						if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
+						else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
+					}
+					charIndex += 1;
 				}
 			} else {
 				charIndex = chunk.start;
 				while (charIndex < end) {
-					if (!isExcluded[charIndex]) {
-						const char = this.original[charIndex];
-						if (char === "\n") shouldIndentNextCharacter = true;
-						else if (char !== "\r" && shouldIndentNextCharacter) {
-							shouldIndentNextCharacter = false;
-							if (charIndex === chunk.start) chunk.prependRight(indentStr);
-							else {
-								this._splitChunk(chunk, charIndex);
-								chunk = chunk.next;
-								chunk.prependRight(indentStr);
-							}
-						}
+					if (!shouldIndentNextCharacter) {
+						const nextLine = this.original.indexOf(n, charIndex);
+						if (nextLine === -1 || nextLine >= end) break;
+						shouldIndentNextCharacter = true;
+						charIndex = nextLine + 1;
+						continue;
+					}
+					const char = this.original.charCodeAt(charIndex);
+					if (char === NEWLINE_CHAR || char === CR_CHAR) {
+						charIndex += 1;
+						continue;
 					}
+					indentAt(charIndex);
 					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 */
 	insert() {
-		throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
+		throw new MagicStringError("insert() is deprecated, use appendLeft() or prependRight()");
 	}
+	/** @internal */
 	insertLeft(index, content) {
 		if (!warned.insertLeft) {
 			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
@@ -618,6 +862,7 @@ var MagicString = class MagicString {
 		}
 		return this.appendLeft(index, content);
 	}
+	/** @internal */
 	insertRight(index, content) {
 		if (!warned.insertRight) {
 			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
@@ -625,19 +870,30 @@ var MagicString = class MagicString {
 		}
 		return this.prependRight(index, content);
 	}
+	/**
+	* Moves the characters from `start` and `end` to `index`.
+	*/
 	move(start, end, index) {
 		start = start + this.offset;
 		end = end + this.offset;
 		index = index + this.offset;
-		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+		if (start === end) return this;
+		if (index >= start && index <= end) throw new MagicStringError("cannot move a selection inside itself");
 		this._split(start);
 		this._split(end);
 		this._split(index);
-		const first = this.byStart[start];
-		const last = this.byEnd[end];
+		const first = this.byStart.get(start);
+		const last = this.byEnd.get(end);
+		if (this.hasMovedChunks) {
+			let cursor = first;
+			while (cursor !== last) {
+				cursor = cursor.next;
+				if (!cursor || cursor.start < start || cursor.end > end) throw new MagicStringError(`cannot move ${start} to ${end} because an earlier move split that range`);
+			}
+		}
 		const oldLeft = first.previous;
 		const oldRight = last.next;
-		const newRight = this.byStart[index];
+		const newRight = this.byStart.get(index);
 		if (!newRight && last === this.lastChunk) return this;
 		const newLeft = newRight ? newRight.previous : this.lastChunk;
 		if (oldLeft) oldLeft.next = oldRight;
@@ -653,25 +909,45 @@ var MagicString = class MagicString {
 		last.next = newRight || null;
 		if (!newLeft) this.firstChunk = first;
 		if (!newRight) this.lastChunk = last;
+		this.hasMovedChunks = true;
 		return this;
 	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+	* that range. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and a contentOnly property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*
+	* It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+	*/
 	overwrite(start, end, content, options) {
-		options = options || {};
+		const optionObject = typeof options === "object" && options ? options : {};
 		return this.update(start, end, content, {
-			...options,
-			overwrite: !options.contentOnly
+			...optionObject,
+			overwrite: !optionObject.contentOnly
 		});
 	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and an overwrite property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*/
 	update(start, end, content, options) {
 		start = start + this.offset;
 		end = end + this.offset;
-		if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+		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 (end > this.original.length) throw new Error("end is out of bounds");
-		if (start === end) throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
+		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`);
+		if (start === end) throw new MagicStringError(`cannot overwrite a zero-length range at ${start}, use appendLeft() or prependRight()`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
 		this._split(start);
 		this._split(end);
 		if (options === true) {
@@ -681,8 +957,9 @@ var MagicString = class MagicString {
 			}
 			options = { storeName: true };
 		}
-		const storeName = options !== void 0 ? options.storeName : false;
-		const overwrite = options !== void 0 ? options.overwrite : false;
+		const optionObject = typeof options === "object" && options ? options : {};
+		const storeName = optionObject.storeName || false;
+		const overwrite = optionObject.overwrite || false;
 		if (storeName) {
 			const original = this.original.slice(start, end);
 			Object.defineProperty(this.storedNames, original, {
@@ -691,12 +968,13 @@ var MagicString = class MagicString {
 				enumerable: true
 			});
 		}
-		const first = this.byStart[start];
-		const last = this.byEnd[end];
+		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) {
-				if (chunk.next !== this.byStart[chunk.end]) throw new Error("Cannot overwrite across a split point");
+				if (chunk.next !== this.byStart.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
 				chunk = chunk.next;
 				chunk.edit("", false);
 			}
@@ -708,77 +986,94 @@ var MagicString = class MagicString {
 		}
 		return this;
 	}
+	/**
+	* Prepends the string with the specified content.
+	*/
 	prepend(content) {
-		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this.intro = content + this.intro;
 		return this;
 	}
+	/**
+	* Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+	*/
 	prependLeft(index, content) {
 		index = index + this.offset;
-		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
-		const chunk = this.byEnd[index];
+		const chunk = this.byEnd.get(index);
 		if (chunk) chunk.prependLeft(content);
 		else this.intro = content + this.intro;
 		return this;
 	}
+	/**
+	* Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+	*/
 	prependRight(index, content) {
 		index = index + this.offset;
-		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
-		const chunk = this.byStart[index];
+		const chunk = this.byStart.get(index);
 		if (chunk) chunk.prependRight(content);
 		else this.outro = content + this.outro;
 		return this;
 	}
+	/**
+	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Removing the same content twice, or making removals that partially overlap, will cause an error.
+	*/
 	remove(start, end) {
 		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 Error("Character is out of bounds");
-		if (start > end) throw new Error("end must be greater than start");
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
 		this._split(start);
 		this._split(end);
-		let chunk = this.byStart[start];
+		let chunk = this.byStart.get(start);
 		while (chunk) {
 			chunk.intro = "";
 			chunk.outro = "";
 			chunk.edit("");
-			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
 		}
 		return this;
 	}
+	/**
+	* Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+	*/
 	reset(start, end) {
 		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 Error("Character is out of bounds");
-		if (start > end) throw new Error("end must be greater than start");
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
 		this._split(start);
 		this._split(end);
-		let chunk = this.byStart[start];
+		let chunk = this.byStart.get(start);
 		while (chunk) {
 			chunk.reset();
-			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
 		}
 		return this;
 	}
 	lastChar() {
 		if (this.outro.length) return this.outro[this.outro.length - 1];
 		let chunk = this.lastChunk;
-		do {
+		while (chunk) {
 			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
 			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
 			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
-		} while (chunk = chunk.previous);
+			chunk = chunk.previous;
+		}
 		if (this.intro.length) return this.intro[this.intro.length - 1];
 		return "";
 	}
@@ -787,7 +1082,7 @@ var MagicString = class MagicString {
 		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
 		let lineStr = this.outro;
 		let chunk = this.lastChunk;
-		do {
+		while (chunk) {
 			if (chunk.outro.length > 0) {
 				lineIndex = chunk.outro.lastIndexOf(n);
 				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
@@ -803,17 +1098,22 @@ var MagicString = class MagicString {
 				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.intro + lineStr;
 			}
-		} while (chunk = chunk.previous);
+			chunk = chunk.previous;
+		}
 		lineIndex = this.intro.lastIndexOf(n);
 		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
 		return this.intro + lineStr;
 	}
+	/**
+	* Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+	* Throws error if the indices are for characters that were already removed.
+	*/
 	slice(start = 0, end = this.original.length - this.offset) {
 		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;
@@ -821,12 +1121,12 @@ var MagicString = class MagicString {
 			if (chunk.start < end && chunk.end >= end) return result;
 			chunk = chunk.next;
 		}
-		if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+		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 (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 Error(`Cannot use replaced character ${end} as slice end anchor.`);
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new MagicStringError(`cannot use edited character ${end} as slice end anchor`);
 			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
 			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
 			result += chunk.content.slice(sliceStart, sliceEnd);
@@ -836,37 +1136,45 @@ var MagicString = class MagicString {
 		}
 		return result;
 	}
+	/**
+	* Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+	*/
 	snip(start, end) {
 		const clone = this.clone();
 		clone.remove(0, start);
 		clone.remove(end, clone.original.length);
 		return clone;
 	}
+	/** @internal */
 	_split(index) {
-		if (this.byStart[index] || this.byEnd[index]) return;
+		if (this.byStart.get(index) || this.byEnd.get(index)) return;
 		let chunk = this.lastSearchedChunk;
 		let previousChunk = chunk;
 		const searchForward = index > chunk.end;
 		while (chunk) {
 			if (chunk.contains(index)) return this._splitChunk(chunk, index);
-			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+			chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
 			if (chunk === previousChunk) return;
 			previousChunk = chunk;
 		}
 	}
+	/** @internal */
 	_splitChunk(chunk, index) {
 		if (chunk.edited && chunk.content.length) {
 			const loc = getLocator(this.original)(index);
-			throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+			throw new MagicStringError(`cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
 		}
 		const newChunk = chunk.split(index);
-		this.byEnd[index] = chunk;
-		this.byStart[index] = newChunk;
-		this.byEnd[newChunk.end] = newChunk;
+		this.byEnd.set(index, chunk);
+		this.byStart.set(index, newChunk);
+		this.byEnd.set(newChunk.end, newChunk);
 		if (chunk === this.lastChunk) this.lastChunk = newChunk;
 		this.lastSearchedChunk = chunk;
 		return true;
 	}
+	/**
+	* Returns the generated string.
+	*/
 	toString() {
 		let str = this.intro;
 		let chunk = this.firstChunk;
@@ -876,29 +1184,43 @@ var MagicString = class MagicString {
 		}
 		return str + this.outro;
 	}
+	/**
+	* 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;
-		do
+		while (chunk) {
 			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
-		while (chunk = chunk.next);
+			chunk = chunk.next;
+		}
+		if (this.outro.length && this.outro.trim()) return false;
 		return true;
 	}
 	length() {
 		let chunk = this.firstChunk;
 		let length = 0;
-		do
+		while (chunk) {
 			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
-		while (chunk = chunk.next);
+			chunk = chunk.next;
+		}
 		return length;
 	}
+	/**
+	* Removes empty lines from the start and end.
+	*/
 	trimLines() {
 		return this.trim("[\\r\\n]");
 	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+	*/
 	trim(charType) {
 		return this.trimStart(charType).trimEnd(charType);
 	}
+	/** @internal */
 	trimEndAborted(charType) {
-		const rx = new RegExp((charType || "\\s") + "+$");
+		const rx = new RegExp(`${charType || "\\s"}+$`);
 		this.outro = this.outro.replace(rx, "");
 		if (this.outro.length) return true;
 		let chunk = this.lastChunk;
@@ -907,21 +1229,25 @@ var MagicString = class MagicString {
 			const aborted = chunk.trimEnd(rx);
 			if (chunk.end !== end) {
 				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
-				this.byEnd[chunk.end] = chunk;
-				this.byStart[chunk.next.start] = chunk.next;
-				this.byEnd[chunk.next.end] = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
 			}
 			if (aborted) return true;
 			chunk = chunk.previous;
 		} while (chunk);
 		return false;
 	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+	*/
 	trimEnd(charType) {
 		this.trimEndAborted(charType);
 		return this;
 	}
+	/** @internal */
 	trimStartAborted(charType) {
-		const rx = new RegExp("^" + (charType || "\\s") + "+");
+		const rx = new RegExp(`^${charType || "\\s"}+`);
 		this.intro = this.intro.replace(rx, "");
 		if (this.intro.length) return true;
 		let chunk = this.firstChunk;
@@ -930,80 +1256,108 @@ var MagicString = class MagicString {
 			const aborted = chunk.trimStart(rx);
 			if (chunk.end !== end) {
 				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
-				this.byEnd[chunk.end] = chunk;
-				this.byStart[chunk.next.start] = chunk.next;
-				this.byEnd[chunk.next.end] = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
 			}
 			if (aborted) return true;
 			chunk = chunk.next;
 		} while (chunk);
 		return false;
 	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+	*/
 	trimStart(charType) {
 		this.trimStartAborted(charType);
 		return this;
 	}
+	/**
+	* Indicates if the string has been changed.
+	*/
 	hasChanged() {
-		return this.original !== this.toString();
+		if (this.intro || this.outro) return true;
+		let outputIndex = 0;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.intro || chunk.outro) return true;
+			if (!chunk.edited && chunk.start === outputIndex) outputIndex = chunk.end;
+			else {
+				if (!this.original.startsWith(chunk.content, outputIndex)) return true;
+				outputIndex += chunk.content.length;
+			}
+			chunk = chunk.next;
+		}
+		return outputIndex !== this.original.length;
 	}
+	/** @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, match.index, str, match.groups);
-		}
-		function matchAll(re, str) {
-			let match;
-			const matches = [];
-			while (match = re.exec(str)) matches.push(match);
-			return matches;
-		}
-		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 {
+			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) => {
+			/* 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;
 	}
+	/** @internal */
 	_replaceString(string, replacement) {
 		const { original } = this;
 		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;
 	}
+	/**
+	* String replacement with RegExp or string.
+	*/
 	replace(searchValue, replacement) {
 		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
 		return this._replaceRegexp(searchValue, replacement);
 	}
+	/** @internal */
 	_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);
-			let _replacement = replacement;
-			if (typeof replacement === "function") _replacement = replacement(previous, index, original);
+			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;
 	}
+	/**
+	* Same as `s.replace`, but replace all matched strings instead of just one.
+	*/
 	replaceAll(searchValue, replacement) {
 		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
-		if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
+		if (!searchValue.global) throw new MagicStringError("replaceAll() requires a global RegExp");
 		return this._replaceRegexp(searchValue, replacement);
 	}
 };