void 1.4.0 → 1.6.0

package/dist/{dist-Cegxq8gs.mjs → dist-B6eN80gc.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+// ../../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+/";
@@ -92,8 +92,7 @@ function encode(decoded) {
 	}
 	return writer.flush();
 }
-//#endregion
-//#region ../../node_modules/.pnpm/magic-string@1.4.3/node_modules/magic-string/dist/index.mjs
+// ../../node_modules/.pnpm/magic-string@1.4.5/node_modules/magic-string/dist/index.mjs
 var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -104,6 +103,17 @@ var BitSet = class BitSet {
 	has(n) {
 		return !!(this.bits[n >> 5] & 1 << (n & 31));
 	}
+	forEach(fn) {
+		const bits = this.bits;
+		for (let w = 0; w < bits.length; w++) {
+			let word = bits[w];
+			while (word) {
+				const lowest = word & -word;
+				fn((w << 5) + 31 - Math.clz32(lowest));
+				word ^= lowest;
+			}
+		}
+	}
 };
 var Chunk = class Chunk {
 	constructor(start, end, content) {
@@ -115,6 +125,8 @@ var Chunk = class Chunk {
 		this.content = content;
 		this.storeName = false;
 		this.edited = false;
+		this.replacesUntil = -1;
+		this.replacedFrom = -1;
 		this.previous = null;
 		this.next = null;
 	}
@@ -131,6 +143,8 @@ var Chunk = class Chunk {
 		chunk.content = this.content;
 		chunk.storeName = this.storeName;
 		chunk.edited = this.edited;
+		chunk.replacesUntil = this.replacesUntil;
+		chunk.replacedFrom = this.replacedFrom;
 		return chunk;
 	}
 	contains(index) {
@@ -171,6 +185,8 @@ var Chunk = class Chunk {
 	reset() {
 		this.intro = "";
 		this.outro = "";
+		this.replacesUntil = -1;
+		this.replacedFrom = -1;
 		if (this.edited) {
 			this.content = this.original;
 			this.storeName = false;
@@ -188,7 +204,7 @@ var Chunk = class Chunk {
 		this.end = index;
 		if (this.edited) {
 			newChunk.edit("", false, true);
-			this.content = "";
+			newChunk.replacedFrom = this.replacedFrom;
 		} else this.content = originalBefore;
 		newChunk.next = this.next;
 		if (newChunk.next) newChunk.next.previous = newChunk;
@@ -438,8 +454,8 @@ var Mappings = class {
 		this.generatedCodeColumn = 0;
 		this.raw = [];
 		this.rawSegments = this.raw[this.generatedCodeLine] = [];
-		this.rawRangeMappings = [];
-		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+		this.rawRangeMappingsIndices = [];
+		this.rawRangeMappings = hires === "experimental-range" ? [this.rawRangeMappingsIndices] : void 0;
 		this.encoder = encoder;
 	}
 	nextLine() {
@@ -452,7 +468,28 @@ var Mappings = class {
 			this.generatedCodeLine += 1;
 		}
 		this.generatedCodeColumn = 0;
-		this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+		if (this.rawRangeMappings) this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+	}
+	/**
+	* Emits the mappings for one MagicString: its intro, every chunk (with the
+	* chunk's own intro/outro) and its outro. `sourceIndex === -1` means the
+	* string has no source of its own, so its content only advances the
+	* generated position without mapping anything.
+	*/
+	addMagicString(magicString, sourceIndex, nameIndex) {
+		const { original } = magicString;
+		const locate = getLocator(original);
+		if (magicString.intro) this.advance(magicString.intro);
+		magicString.firstChunk.eachNext((chunk) => {
+			if (chunk.intro.length) this.advance(chunk.intro);
+			if (sourceIndex === -1) this.advance(chunk.content);
+			else if (chunk.edited) {
+				const name = chunk.storeName ? nameIndex.get(original.slice(chunk.start, chunk.replacesUntil)) : void 0;
+				this.addEdit(sourceIndex, chunk.content, locate(chunk.start), name ?? -1);
+			} else this.addUneditedChunk(sourceIndex, chunk, original, locate(chunk.start), magicString.sourcemapLocations);
+			if (chunk.outro.length) this.advance(chunk.outro);
+		});
+		if (magicString.outro) this.advance(magicString.outro);
 	}
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
@@ -665,6 +702,9 @@ function expandReplacement(replacement, matched, position, str, captures, namedC
 	return result;
 }
 var MagicString = class MagicString {
+	/**
+	* Wraps `string` for editing; every index passed to the editing methods refers to this original string.
+	*/
 	constructor(string, options = {}) {
 		const chunk = new Chunk(0, string.length, string);
 		Object.defineProperties(this, {
@@ -714,7 +754,7 @@ var MagicString = class MagicString {
 			},
 			storedNames: {
 				writable: true,
-				value: {}
+				value: /* @__PURE__ */ new Set()
 			},
 			indentStr: {
 				writable: true,
@@ -754,7 +794,8 @@ var MagicString = class MagicString {
 	* See also `s.prependLeft(...)`.
 	*/
 	appendLeft(index, content) {
-		index = index + this.offset;
+		index = this._resolveIndex(index);
+		if (index < 0 || index > this.original.length) throw new MagicStringError(`index ${index} is out of bounds`);
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
 		const chunk = this.byEnd.get(index);
@@ -768,7 +809,8 @@ var MagicString = class MagicString {
 	* See also `s.prependRight(...)`.
 	*/
 	appendRight(index, content) {
-		index = index + this.offset;
+		index = this._resolveIndex(index);
+		if (index < 0 || index > this.original.length) throw new MagicStringError(`index ${index} is out of bounds`);
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
 		const chunk = this.byStart.get(index);
@@ -777,7 +819,10 @@ var MagicString = class MagicString {
 		return this;
 	}
 	/**
-	* Does what you'd expect.
+	* Returns an independent copy: the chunk list, string-level intro/outro,
+	* sourcemap locations, stored names, indent exclusion ranges, `offset`,
+	* `filename` and `ignoreList` are all copied; later edits to either string
+	* do not affect the other.
 	*/
 	clone() {
 		const cloned = new MagicString(this.original, {
@@ -802,7 +847,7 @@ 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.storedNames = new Set(this.storedNames);
 		cloned.intro = this.intro;
 		cloned.outro = this.outro;
 		cloned.hasMovedChunks = this.hasMovedChunks;
@@ -838,18 +883,8 @@ var MagicString = class MagicString {
 	}
 	/** @internal */
 	_generateMappings(mappings) {
-		const sourceIndex = 0;
-		const names = Object.keys(this.storedNames);
-		const locate = getLocator(this.original);
-		if (this.intro) mappings.advance(this.intro);
-		this.firstChunk.eachNext((chunk) => {
-			const loc = locate(chunk.start);
-			if (chunk.intro.length) mappings.advance(chunk.intro);
-			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
-			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
-			if (chunk.outro.length) mappings.advance(chunk.outro);
-		});
-		if (this.outro) mappings.advance(this.outro);
+		const names = [...this.storedNames];
+		mappings.addMagicString(this, 0, new Map(names.map((name, i) => [name, i])));
 		return names;
 	}
 	/** @internal */
@@ -871,9 +906,13 @@ var MagicString = class MagicString {
 		this._ensureindentStr();
 		return this.indentStr;
 	}
+	/**
+	* Returns the indentation string guessed from the original content, falling back to a single tab character.
+	* This is the value `s.indent()` uses when no prefix is supplied.
+	*/
 	getIndentString() {
 		this._ensureindentStr();
-		return this.indentStr === null ? "	" : this.indentStr;
+		return this.indentStr ?? "	";
 	}
 	indent(indentStr, options) {
 		const pattern = /^[^\r\n]/gm;
@@ -888,9 +927,9 @@ var MagicString = class MagicString {
 		if (indentStr === "") return this;
 		const resolvedIndentStr = indentStr;
 		options = options || {};
-		const isExcluded = {};
+		const isExcluded = new BitSet();
 		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;
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded.add(i);
 		});
 		let shouldIndentNextCharacter = options.indentStart !== false;
 		const indentPiece = (str) => {
@@ -913,13 +952,14 @@ var MagicString = class MagicString {
 		};
 		while (chunk) {
 			const end = chunk.end;
-			if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
+			if (!isExcluded.has(chunk.start)) chunk.intro = indentPiece(chunk.intro);
 			if (chunk.edited) {
-				if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
+				if (!isExcluded.has(chunk.start)) chunk.content = indentPiece(chunk.content);
+				else if (chunk.content) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
 			} else if (options.exclude) {
 				charIndex = chunk.start;
 				while (charIndex < end) {
-					if (!isExcluded[charIndex]) {
+					if (!isExcluded.has(charIndex)) {
 						const char = this.original.charCodeAt(charIndex);
 						if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
 						else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
@@ -945,7 +985,7 @@ var MagicString = class MagicString {
 					charIndex += 1;
 				}
 			}
-			if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
+			if (!isExcluded.has(chunk.end - 1)) chunk.outro = indentPiece(chunk.outro);
 			charIndex = chunk.end;
 			chunk = chunk.next;
 		}
@@ -982,16 +1022,19 @@ var MagicString = class MagicString {
 	* mirroring the `appendLeft`/`appendRight` distinction.
 	*/
 	move(start, end, index, affinity = "right") {
-		start = start + this.offset;
-		end = end + this.offset;
-		index = index + this.offset;
+		start = this._resolveIndex(start);
+		end = this._resolveIndex(end);
+		index = this._resolveIndex(index);
 		if (start === end) return this;
+		if (start < 0 || end > this.original.length || index < 0 || index > 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})`);
 		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.get(start);
 		const last = this.byEnd.get(end);
+		if (!first || !last) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
 		if (this.hasMovedChunks) {
 			let cursor = first;
 			while (cursor !== last) {
@@ -1026,9 +1069,9 @@ var MagicString = class MagicString {
 		if (oldRight) oldRight.previous = oldLeft;
 		if (newLeft) newLeft.next = first;
 		if (newRight) newRight.previous = last;
-		if (!first.previous) this.firstChunk = last.next;
-		if (!last.next) {
-			this.lastChunk = first.previous;
+		if (!oldLeft) this.firstChunk = oldRight;
+		if (!oldRight) {
+			this.lastChunk = oldLeft;
 			this.lastChunk.next = null;
 		}
 		first.previous = newLeft;
@@ -1049,6 +1092,16 @@ var MagicString = class MagicString {
 	* It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
 	*/
 	overwrite(start, end, content, options) {
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+				warned.storeName = true;
+			}
+			return this.update(start, end, content, {
+				storeName: true,
+				overwrite: true
+			});
+		}
 		const optionObject = typeof options === "object" && options ? options : {};
 		return this.update(start, end, content, {
 			...optionObject,
@@ -1063,13 +1116,9 @@ var MagicString = class MagicString {
 	* 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;
+		start = this._resolveIndex(start);
+		end = this._resolveIndex(end);
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
-		if (this.original.length !== 0) {
-			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`);
 		if (start === end) throw new MagicStringError(`cannot overwrite a zero-length range at ${start}, use appendLeft() or prependRight()`);
@@ -1086,30 +1135,21 @@ var MagicString = class MagicString {
 		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, {
-				writable: true,
-				value: true,
-				enumerable: true
-			});
-		}
+		if (storeName) this.storedNames.add(this.original.slice(start, 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.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
-				chunk = chunk.next;
-				chunk.edit("", false, !overwrite);
-			}
-			first.edit(content, storeName, !overwrite);
-		} else {
-			const newChunk = new Chunk(start, end, "").edit(content, storeName);
-			last.next = newChunk;
-			newChunk.previous = last;
+		for (let chunk = first; chunk.end < end;) {
+			const next = chunk.next;
+			if (next === null || next !== this.byStart.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
+			chunk = next;
 		}
+		for (let chunk = first.next; chunk !== null && chunk.start < end; chunk = chunk.next) {
+			chunk.edit("", false, !overwrite);
+			chunk.replacesUntil = -1;
+			chunk.replacedFrom = start;
+		}
+		first.edit(content, storeName, !overwrite);
+		first.replacesUntil = end;
+		first.replacedFrom = -1;
 		return this;
 	}
 	/**
@@ -1124,7 +1164,8 @@ var MagicString = class MagicString {
 	* 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;
+		index = this._resolveIndex(index);
+		if (index < 0 || index > this.original.length) throw new MagicStringError(`index ${index} is out of bounds`);
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
 		const chunk = this.byEnd.get(index);
@@ -1136,7 +1177,8 @@ var MagicString = class MagicString {
 	* 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;
+		index = this._resolveIndex(index);
+		if (index < 0 || index > this.original.length) throw new MagicStringError(`index ${index} is out of bounds`);
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		this._split(index);
 		const chunk = this.byStart.get(index);
@@ -1152,12 +1194,8 @@ var MagicString = class MagicString {
 	* Repeated removals and removals with partially overlapping ranges are allowed.
 	*/
 	remove(start, end) {
-		start = start + this.offset;
-		end = end + this.offset;
-		if (this.original.length !== 0) {
-			if (start < 0) start = Math.max(0, start + this.original.length);
-			if (end < 0) end = Math.max(0, end + this.original.length);
-		}
+		start = this._resolveIndex(start);
+		end = this._resolveIndex(end);
 		if (start === end) return this;
 		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})`);
@@ -1168,7 +1206,9 @@ var MagicString = class MagicString {
 			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;
+			chunk.replacesUntil = -1;
+			chunk.replacedFrom = -1;
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : void 0;
 		}
 		return this;
 	}
@@ -1176,12 +1216,8 @@ var MagicString = class MagicString {
 	* 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) {
-			if (start < 0) start = Math.max(0, start + this.original.length);
-			if (end < 0) end = Math.max(0, end + this.original.length);
-		}
+		start = this._resolveIndex(start);
+		end = this._resolveIndex(end);
 		if (start === end) return this;
 		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})`);
@@ -1190,10 +1226,13 @@ var MagicString = class MagicString {
 		let chunk = this.byStart.get(start);
 		while (chunk) {
 			chunk.reset();
-			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : void 0;
 		}
 		return this;
 	}
+	/**
+	* Returns the last character of the generated string, or `''` if it is empty.
+	*/
 	lastChar() {
 		if (this.outro.length) return this.outro[this.outro.length - 1];
 		let chunk = this.lastChunk;
@@ -1206,49 +1245,57 @@ var MagicString = class MagicString {
 		if (this.intro.length) return this.intro[this.intro.length - 1];
 		return "";
 	}
+	/**
+	* Returns everything after the last newline in the generated string, or the whole string if there is no newline.
+	*/
 	lastLine() {
 		let lineIndex = this.outro.lastIndexOf(n);
-		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		if (lineIndex !== -1) return this.outro.slice(lineIndex + 1);
 		let lineStr = this.outro;
 		let chunk = this.lastChunk;
 		while (chunk) {
 			if (chunk.outro.length > 0) {
 				lineIndex = chunk.outro.lastIndexOf(n);
-				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				if (lineIndex !== -1) return chunk.outro.slice(lineIndex + 1) + lineStr;
 				lineStr = chunk.outro + lineStr;
 			}
 			if (chunk.content.length > 0) {
 				lineIndex = chunk.content.lastIndexOf(n);
-				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				if (lineIndex !== -1) return chunk.content.slice(lineIndex + 1) + lineStr;
 				lineStr = chunk.content + lineStr;
 			}
 			if (chunk.intro.length > 0) {
 				lineIndex = chunk.intro.lastIndexOf(n);
-				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				if (lineIndex !== -1) return chunk.intro.slice(lineIndex + 1) + lineStr;
 				lineStr = chunk.intro + lineStr;
 			}
 			chunk = chunk.previous;
 		}
 		lineIndex = this.intro.lastIndexOf(n);
-		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		if (lineIndex !== -1) return this.intro.slice(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.
+	* Returns the content of the generated string that corresponds to the slice
+	* between `start` and `end` of the original string, walking the generated
+	* string from the chunk holding `start` to the chunk holding `end`. Throws
+	* if either index falls inside replaced content. After `move()`, a range
+	* whose end now comes before its start in the output yields `''`.
 	*/
 	slice(start = 0, end = this.original.length - this.offset) {
-		start = start + this.offset;
-		end = end + this.offset;
-		if (this.original.length !== 0) {
-			if (start < 0) start = Math.max(0, start + this.original.length);
-			if (end < 0) end = Math.max(0, end + this.original.length);
-		}
+		start = this._resolveIndex(start);
+		end = this._resolveIndex(end);
 		let result = "";
-		let chunk = this.firstChunk;
-		while (chunk && (chunk.start > start || chunk.end <= start)) {
-			if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
-			chunk = chunk.next;
+		let chunk;
+		if (this.hasMovedChunks) {
+			chunk = this.firstChunk;
+			while (chunk && (chunk.start > start || chunk.end <= start)) {
+				if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
+				chunk = chunk.next;
+			}
+		} else {
+			if (start >= end) return result;
+			chunk = this._chunkAt(start);
 		}
 		if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
 		const startChunk = chunk;
@@ -1271,10 +1318,39 @@ var MagicString = class MagicString {
 	*/
 	snip(start, end) {
 		const clone = this.clone();
-		clone.remove(0, start);
-		clone.remove(end, clone.original.length);
+		clone.remove(-clone.offset, start);
+		clone.remove(end, clone.original.length - clone.offset);
 		return clone;
 	}
+	/**
+	* Applies `offset`, resolves a negative index from the end of `original` as
+	* `update`/`remove` always have, and rejects anything that is not an integer.
+	* Bounds are checked by the caller, because the methods report them differently.
+	*
+	* @internal
+	*/
+	_resolveIndex(index) {
+		const resolved = index + this.offset;
+		if (!Number.isInteger(resolved)) throw new MagicStringError(`index must be an integer, got ${index}`);
+		if (resolved < 0 && this.original.length !== 0) return Math.max(0, resolved + this.original.length);
+		return resolved;
+	}
+	/**
+	* The chunk whose original range holds `index` (`chunk.start <= index < chunk.end`),
+	* or `undefined` when `index` is at or past the end. Searches from the last
+	* visited chunk so that scans over nearby indices stay cheap.
+	*
+	* @internal
+	*/
+	_chunkAt(index) {
+		let chunk = this.byStart.get(index);
+		if (chunk) return chunk;
+		chunk = this.lastSearchedChunk;
+		const searchForward = index >= chunk.end;
+		while (chunk && !chunk.contains(index)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+		if (chunk) this.lastSearchedChunk = chunk;
+		return chunk;
+	}
 	/** @internal */
 	_split(index) {
 		if (this.byStart.get(index) || this.byEnd.get(index)) return;
@@ -1327,6 +1403,11 @@ var MagicString = class MagicString {
 		if (this.outro.length && this.outro.trim()) return false;
 		return true;
 	}
+	/**
+	* Returns the length of the generated string, counting only content attached to the original characters.
+	* Content outside the string body (`s.prepend()`/`s.append()`, and inserts before the first or after the last
+	* character) is not counted, so this can differ from `s.toString().length`.
+	*/
 	length() {
 		let chunk = this.firstChunk;
 		let length = 0;
@@ -1358,10 +1439,11 @@ var MagicString = class MagicString {
 			const end = chunk.end;
 			const aborted = chunk.trimEnd(rx);
 			if (chunk.end !== end) {
-				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
+				const next = chunk.next;
+				if (this.lastChunk === chunk) this.lastChunk = next;
 				this.byEnd.set(chunk.end, chunk);
-				this.byStart.set(chunk.next.start, chunk.next);
-				this.byEnd.set(chunk.next.end, chunk.next);
+				this.byStart.set(next.start, next);
+				this.byEnd.set(next.end, next);
 			}
 			if (aborted) return true;
 			chunk = chunk.previous;
@@ -1386,10 +1468,11 @@ var MagicString = class MagicString {
 			const end = chunk.end;
 			const aborted = chunk.trimStart(rx);
 			if (chunk.end !== end) {
-				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+				const next = chunk.next;
+				if (chunk === this.lastChunk) this.lastChunk = next;
 				this.byEnd.set(chunk.end, chunk);
-				this.byStart.set(chunk.next.start, chunk.next);
-				this.byEnd.set(chunk.next.end, chunk.next);
+				this.byStart.set(next.start, next);
+				this.byEnd.set(next.end, next);
 			}
 			if (aborted) return true;
 			chunk = chunk.next;
@@ -1431,30 +1514,29 @@ var MagicString = class MagicString {
 	* @internal
 	*/
 	_hasRemovedContent(start, end) {
-		let chunk = this.byStart.get(start);
-		if (!chunk) {
-			chunk = this.lastSearchedChunk;
-			const searchForward = start >= chunk.end;
-			while (chunk && !chunk.contains(start)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
-			if (chunk) this.lastSearchedChunk = chunk;
+		const atBoundary = this.byStart.get(start);
+		if (atBoundary && start === end) {
+			const previous = this.byEnd.get(start);
+			return !!previous && previous.content === "" && atBoundary.content === "";
 		}
+		let chunk = this._chunkAt(start);
 		while (chunk && chunk.start < end) {
-			if (chunk.content === "") return true;
+			if (chunk.content === "" && (chunk.replacedFrom < start || this.byStart.get(chunk.replacedFrom).replacesUntil < chunk.end)) return true;
 			chunk = this.byStart.get(chunk.end);
 		}
 		return false;
 	}
 	/** @internal */
 	_replaceRegexp(searchValue, replacement) {
-		function getReplacement(match, str) {
-			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);
+		function getReplacement(match, index, str) {
+			if (typeof replacement === "string") return expandReplacement(replacement, match[0], index, str, match.slice(1), match.groups);
+			else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), index, str) : replacement(match[0], ...match.slice(1), 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 false;
 			if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
-			const replacement = getReplacement(match, this.original);
+			const replacement = getReplacement(match, match.index, this.original);
 			if (replacement === match[0]) return true;
 			if (match[0].length === 0) this.appendRight(match.index - this.offset, replacement);
 			else this.overwrite(match.index - this.offset, match.index + match[0].length - this.offset, replacement);
@@ -1527,5 +1609,4 @@ var MagicString = class MagicString {
 		return this._replaceRegexp(searchValue, replacement);
 	}
 };
-//#endregion
 export { MagicString as t };