@rollup/wasm-node 4.62.5 → 4.63.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.62.5
-	Thu, 20 Aug 2026 16:59:36 GMT - commit c20402e2d4498a5861a4f49e00b2e7446c9900bb
+	Rollup.js v4.63.0
+	Tue, 25 Aug 2026 13:03:35 GMT - commit 34b8b924c815ec9413d7821f6fd54cc615584a51
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.62.5";
+var version = "4.63.0";
 const package_ = {
 	version: version};
 
@@ -2188,33 +2188,9 @@ function requireParse () {
 	  };
 
 	  const extglobClose = token => {
-	    const literal = input.slice(token.startIndex, state.index + 1);
+	    input.slice(token.startIndex, state.index + 1);
 	    const body = input.slice(token.startIndex + 2, state.index);
-	    const analysis = analyzeRepeatedExtglob(body, opts);
-
-	    if ((token.type === 'plus' || token.type === 'star') && analysis.risky) {
-	      const safeOutput = analysis.safeOutput
-	        ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput)
-	        : undefined;
-	      const open = tokens[token.tokensIndex];
-
-	      open.type = 'text';
-	      open.value = literal;
-	      open.output = safeOutput || utils.escapeRegex(literal);
-
-	      for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
-	        tokens[i].value = '';
-	        tokens[i].output = '';
-	        delete tokens[i].suffix;
-	      }
-
-	      state.output = token.output + open.output;
-	      state.backtrack = true;
-
-	      push({ type: 'paren', extglob: true, value, output: '' });
-	      decrement('parens');
-	      return;
-	    }
+	    analyzeRepeatedExtglob(body, opts);
 
 	    let output = token.close + (opts.capture ? ')' : '');
 	    let rest;
@@ -4513,13 +4489,27 @@ var Chunk$1 = class Chunk {
 	}
 };
 //#endregion
+//#region src/MagicStringError.ts
+/**
+* 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);
+	}
+};
+//#endregion
 //#region src/SourceMap.ts
 function getBtoa() {
 	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 Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+		throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
 	};
 }
 const btoa = /* #__PURE__ */ getBtoa();
@@ -4748,11 +4738,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,
@@ -4781,10 +4771,12 @@ var MagicString = class MagicString {
 			offset: {
 				writable: true,
 				value: options.offset || 0
+			},
+			hasMovedChunks: {
+				writable: true,
+				value: false
 			}
 		});
-		this.byStart = /* @__PURE__ */ new Map([[0, chunk]]);
-		this.byEnd = /* @__PURE__ */ new Map([[string.length, chunk]]);
 	}
 	/**
 	* Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
@@ -4796,7 +4788,7 @@ var MagicString = class MagicString {
 	* 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;
 	}
@@ -4807,7 +4799,7 @@ var MagicString = class MagicString {
 	*/
 	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.get(index);
 		if (chunk) chunk.appendLeft(content);
@@ -4821,7 +4813,7 @@ var MagicString = class MagicString {
 	*/
 	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.get(index);
 		if (chunk) chunk.appendRight(content);
@@ -4834,6 +4826,7 @@ var MagicString = class MagicString {
 	clone() {
 		const cloned = new MagicString(this.original, {
 			filename: this.filename,
+			ignoreList: this.ignoreList,
 			offset: this.offset
 		});
 		let originalChunk = this.firstChunk;
@@ -4853,8 +4846,10 @@ 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;
 	}
 	/**
@@ -4983,7 +4978,7 @@ var MagicString = class MagicString {
 	}
 	/** @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) {
@@ -5009,12 +5004,19 @@ var MagicString = class MagicString {
 		end = end + this.offset;
 		index = index + this.offset;
 		if (start === end) return this;
-		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+		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 (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.get(index);
@@ -5033,6 +5035,7 @@ var MagicString = class MagicString {
 		last.next = newRight || null;
 		if (!newLeft) this.firstChunk = first;
 		if (!newRight) this.lastChunk = last;
+		this.hasMovedChunks = true;
 		return this;
 	}
 	/**
@@ -5062,13 +5065,15 @@ var MagicString = class MagicString {
 	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 (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) {
@@ -5094,7 +5099,7 @@ var MagicString = class MagicString {
 		if (first) {
 			let chunk = first;
 			while (chunk !== last) {
-				if (chunk.next !== this.byStart.get(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);
 			}
@@ -5110,7 +5115,7 @@ var MagicString = class MagicString {
 	* 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;
 	}
@@ -5119,7 +5124,7 @@ var MagicString = class MagicString {
 	*/
 	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.get(index);
 		if (chunk) chunk.prependLeft(content);
@@ -5131,7 +5136,7 @@ var MagicString = class MagicString {
 	*/
 	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.get(index);
 		if (chunk) chunk.prependRight(content);
@@ -5150,8 +5155,8 @@ var MagicString = class MagicString {
 			while (end < 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.get(start);
@@ -5174,8 +5179,8 @@ var MagicString = class MagicString {
 			while (end < 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.get(start);
@@ -5241,12 +5246,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);
@@ -5282,7 +5287,7 @@ var MagicString = class MagicString {
 	_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.set(index, chunk);
@@ -5394,7 +5399,19 @@ var MagicString = class MagicString {
 	* 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) {
@@ -5464,7 +5481,7 @@ var MagicString = class MagicString {
 	*/
 	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);
 	}
 };
@@ -5495,7 +5512,7 @@ var Bundle$1 = class Bundle {
 			filename: source.filename,
 			separator: this.separator
 		});
-		if (!isObject(source) || !source.content) throw new Error("bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`");
+		if (!isObject(source) || !source.content) throw new MagicStringError("addSource() requires a `content` property that is a MagicString");
 		[
 			"filename",
 			"ignoreList",
@@ -5513,7 +5530,7 @@ var Bundle$1 = class Bundle {
 			});
 		} else {
 			const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
-			if (source.content.original !== uniqueSource.content) throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
+			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;
@@ -5534,6 +5551,8 @@ var Bundle$1 = class Bundle {
 			bundle.addSource({
 				filename: source.filename,
 				content: source.content.clone(),
+				ignoreList: source.ignoreList,
+				indentExclusionRanges: source.indentExclusionRanges,
 				separator: source.separator
 			});
 		});
@@ -5550,7 +5569,7 @@ 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(this.separator);
+			if (i > 0) 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);
@@ -5628,11 +5647,17 @@ var Bundle$1 = class Bundle {
 	}
 	isEmpty() {
 		if (this.intro.length && this.intro.trim()) return false;
-		if (this.sources.some((source) => !source.content.isEmpty())) return false;
+		if (this.sources.some((source, i) => {
+			const separator = source.separator !== void 0 ? source.separator : this.separator;
+			return i > 0 && separator.trim() !== "" || !source.content.isEmpty();
+		})) return false;
 		return true;
 	}
 	length() {
-		return this.sources.reduce((length, source) => length + source.content.length(), this.intro.length);
+		return this.sources.reduce((length, source, i) => {
+			const separator = source.separator !== void 0 ? source.separator : this.separator;
+			return length + (i > 0 ? separator.length : 0) + source.content.length();
+		}, this.intro.length);
 	}
 	trimLines() {
 		return this.trim("[\\r\\n]");
@@ -6177,8 +6202,17 @@ class ExpressionEntity {
         return true;
     }
 }
-const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
-})();
+class LiteralExpression extends ExpressionEntity {
+    constructor(value, parent) {
+        super();
+        this.value = value;
+        this.parent = parent;
+    }
+    getLiteralValueAtPath(path) {
+        return path.length > 0 ? UnknownValue : this.value;
+    }
+}
+const UNKNOWN_EXPRESSION = new LiteralExpression(UnknownValue);
 const UNKNOWN_RETURN_EXPRESSION = [
     UNKNOWN_EXPRESSION,
     false
@@ -6908,11 +6942,7 @@ function isExpressionStatementNode(node) {
 function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
     return Object.create(inheritedDescriptions, memberDescriptions);
 }
-const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
-    getLiteralValueAtPath(path) {
-        return path.length > 0 ? UnknownValue : undefined;
-    }
-})();
+const UNDEFINED_EXPRESSION = new LiteralExpression(undefined);
 const returnsUnknown = {
     value: {
         hasEffectsWhenCalled: null,
@@ -7093,7 +7123,7 @@ function getLiteralMembersForValue(value) {
             return literalStringMembers;
         }
     }
-    return Object.create(null);
+    return parseAst_js.BLANK;
 }
 function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
     if (typeof memberName !== 'string' || !members[memberName]) {
@@ -7393,6 +7423,8 @@ class ObjectEntity extends ExpressionEntity {
             // causes an issue with TypeScript enums in files with moduleSideEffects:
             // false because we cannot properly track whether a "var" has been
             // initialized. This should be reverted once we can properly track this.
+            // ALSO needs to be updated once this is resolved:
+            // - literals-from-return-expressions-branches/main.js
             // return UnknownTruthyValue;
             return UnknownValue;
         }
@@ -10093,6 +10125,156 @@ class ThisVariable extends ParameterVariable {
     }
 }
 
+const UNASSIGNED = Symbol('unassigned');
+
+class ReturnStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.expressionsToBeDeoptimized = [];
+    }
+    checkReached(origin) {
+        if (this.deoptimized)
+            return true;
+        this.expressionsToBeDeoptimized.push(origin);
+        return false;
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { expressionsToBeDeoptimized } = this;
+        if (expressionsToBeDeoptimized.length) {
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!context.ignore.returnYield || this.argument?.hasEffects(context))
+            return true;
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included)
+            this.includeNode(context);
+        this.argument?.include(context, includeChildrenRecursively);
+        context.brokenFlow = true;
+    }
+    includeNode(context) {
+        this.included = true;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.argument?.includePath(UNKNOWN_PATH, context);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.addReturnExpression(this.argument || new LiteralExpression(undefined, this));
+    }
+    render(code, options) {
+        if (this.argument) {
+            this.argument.render(code, options, { preventASI: true });
+            if (this.argument.start === this.start + 6 /* 'return'.length */) {
+                code.prependLeft(this.start + 6, ' ');
+            }
+        }
+    }
+}
+
+function mergeValues(a, b) {
+    if (a === b)
+        return a;
+    if (a === UnknownTruthyValue) {
+        if (b && b !== UnknownFalsyValue)
+            return UnknownTruthyValue;
+        return UnknownValue;
+    }
+    if (a === UnknownFalsyValue) {
+        if (!b || b === UnknownFalsyValue)
+            return UnknownFalsyValue;
+        return UnknownValue;
+    }
+    if (a && b)
+        return UnknownTruthyValue;
+    if (!a && !b)
+        return UnknownFalsyValue;
+    return UnknownValue;
+}
+class MultiExpression extends ExpressionEntity {
+    constructor(expressions) {
+        super();
+        this.expressions = expressions;
+        this.literalValue = UNASSIGNED;
+        this.dependantEntities = new Set();
+    }
+    deoptimizeCache() {
+        if (this.literalValue !== UNASSIGNED) {
+            const { dependantEntities } = this;
+            this.literalValue = UNASSIGNED;
+            this.dependantEntities = new Set();
+            for (const entity of dependantEntities) {
+                entity.deoptimizeCache();
+            }
+        }
+    }
+    deoptimizePath(path) {
+        for (const expression of this.expressions) {
+            expression.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length === 0) {
+            if (this.literalValue === UNASSIGNED)
+                this.literalValue = this.doGetLiteralValueAtPath(path, recursionTracker, this);
+            this.dependantEntities.add(origin);
+            return this.literalValue;
+        }
+        return this.doGetLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    doGetLiteralValueAtPath(path, recursionTracker, origin) {
+        let value = UnknownValue;
+        for (const expression of this.expressions) {
+            if (this.isTreeshaken(expression))
+                continue;
+            const expressionValue = expression.getLiteralValueAtPath(path, recursionTracker, origin);
+            if (expressionValue === UnknownValue)
+                return UnknownValue;
+            if (value === UnknownValue) {
+                value = expressionValue;
+                continue;
+            }
+            value = mergeValues(value, expressionValue);
+            if (value === UnknownValue)
+                return UnknownValue;
+        }
+        return value;
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const returnExpressions = this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin));
+        let pure = true;
+        return [
+            new MultiExpression(returnExpressions.map(expression => ((pure &&= expression[1]), expression[0]))),
+            pure
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        for (const expression of this.expressions) {
+            if (!this.isTreeshaken(expression) &&
+                expression.hasEffectsOnInteractionAtPath(path, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    isTreeshaken(expression) {
+        if ('parent' in expression && expression.parent instanceof ReturnStatement) {
+            return !expression.parent.checkReached(this);
+        }
+        return false;
+    }
+}
+
 class CatchBodyScope extends ChildScope {
     constructor(parent) {
         super(parent, parent.context);
@@ -10302,8 +10484,12 @@ class ReturnValueScope extends ParameterScope {
         }
     }
     getReturnExpression() {
-        if (this.returnExpression === null)
-            this.updateReturnExpression();
+        if (!this.returnExpression) {
+            this.returnExpression =
+                this.returnExpressions.length === 1
+                    ? this.returnExpressions[0]
+                    : new MultiExpression(this.returnExpressions);
+        }
         return this.returnExpression;
     }
     deoptimizeAllParameters() {
@@ -10322,17 +10508,6 @@ class ReturnValueScope extends ParameterScope {
         }
     }
     addArgumentToBeDeoptimized(_argument) { }
-    updateReturnExpression() {
-        if (this.returnExpressions.length === 1) {
-            this.returnExpression = this.returnExpressions[0];
-        }
-        else {
-            this.returnExpression = UNKNOWN_EXPRESSION;
-            for (const expression of this.returnExpressions) {
-                expression.deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-    }
 }
 
 class FunctionScope extends ReturnValueScope {
@@ -10394,6 +10569,10 @@ ExpressionStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
 ExpressionStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class BlockStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.virtualReturnStatement = null;
+    }
     get deoptimizeBody() {
         return isFlagSet(this.flags, 32768 /* Flag.deoptimizeBody */);
     }
@@ -10409,7 +10588,13 @@ class BlockStatement extends NodeBase {
     addImplicitReturnExpressionToScope() {
         const lastStatement = this.body[this.body.length - 1];
         if (!lastStatement || lastStatement.type !== parseAst_js.ReturnStatement) {
-            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
+            const virtualReturnStatement = new ReturnStatement(this, this.scope);
+            virtualReturnStatement.type = parseAst_js.ReturnStatement;
+            virtualReturnStatement.argument = null;
+            virtualReturnStatement.initialise();
+            if (this.deoptimizeBody)
+                virtualReturnStatement.includeNode(createInclusionContext());
+            this.virtualReturnStatement = virtualReturnStatement;
         }
     }
     createScope(parentScope) {
@@ -10420,13 +10605,15 @@ class BlockStatement extends NodeBase {
     hasEffects(context) {
         if (this.deoptimizeBody)
             return true;
+        let hasEffect = false;
         for (const node of this.body) {
-            if (context.brokenFlow)
+            if (context.brokenFlow || (hasEffect = node.hasEffects(context)))
                 break;
-            if (node.hasEffects(context))
-                return true;
         }
-        return false;
+        if (!context.brokenFlow) {
+            hasEffect ||= !!this.virtualReturnStatement?.hasEffects(context);
+        }
+        return hasEffect;
     }
     include(context, includeChildrenRecursively) {
         if (!(this.deoptimizeBody && this.directlyIncluded)) {
@@ -10438,6 +10625,8 @@ class BlockStatement extends NodeBase {
                 if (includeChildrenRecursively || node.shouldBeIncluded(context))
                     node.include(context, includeChildrenRecursively);
             }
+            if (includeChildrenRecursively || !context.brokenFlow)
+                this.virtualReturnStatement?.include(context, includeChildrenRecursively);
         }
     }
     initialise() {
@@ -11450,7 +11639,7 @@ class MemberExpression extends NodeBase {
         if (!this.included)
             this.includeNode(context);
         if (this.variable) {
-            this.variable?.includePath(path, context);
+            this.variable.includePath(path, context);
         }
         else if (!this.isUndefined) {
             this.object.includePath([
@@ -13658,11 +13847,10 @@ const binaryOperators = {
     // in: () => UnknownValue,
     // instanceof: () => UnknownValue,
 };
-const UNASSIGNED$1 = Symbol('Unassigned');
 class BinaryExpression extends NodeBase {
     constructor() {
         super(...arguments);
-        this.renderedLiteralValue = UNASSIGNED$1;
+        this.renderedLiteralValue = UNASSIGNED;
     }
     deoptimizeCache() {
         this.renderedLiteralValue = UnknownValue;
@@ -13695,7 +13883,7 @@ class BinaryExpression extends NodeBase {
         if (this.operator !== 'in' || !(this.right.variable instanceof NamespaceVariable)) {
             return UnknownValue;
         }
-        if (this.renderedLiteralValue !== UNASSIGNED$1)
+        if (this.renderedLiteralValue !== UNASSIGNED)
             return this.renderedLiteralValue;
         return (this.renderedLiteralValue = getRenderedLiteralValue(this.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this)));
     }
@@ -13830,10 +14018,10 @@ class CallExpressionBase extends NodeBase {
     }
     deoptimizeCache() {
         if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
-            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            this.returnExpression = null;
             const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
-            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = new Set();
+            this.deoptimizableDependentExpressions = [];
             for (const expression of deoptimizableDependentExpressions) {
                 expression.deoptimizeCache();
             }
@@ -13859,7 +14047,7 @@ class CallExpressionBase extends NodeBase {
         }
         return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
             this.deoptimizableDependentExpressions.push(origin);
-            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+            return returnExpression.getLiteralValueAtPath(path, recursionTracker, this);
         }, UnknownValue);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
@@ -13971,11 +14159,6 @@ class CallExpression extends CallExpressionBase {
             this.callee.includeCallArguments(this.interaction, context);
         }
     }
-    includeNode(_context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-    }
     initialise() {
         super.initialise();
         if (this.annotations &&
@@ -14007,12 +14190,13 @@ class CallExpression extends CallExpressionBase {
     }
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
-            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
-            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION; // In case of recursion
+            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this);
         }
         return this.returnExpression;
     }
 }
+CallExpression.prototype.includeNode = onlyIncludeSelf;
 
 class CatchClause extends NodeBase {
     createScope(parentScope) {
@@ -14112,31 +14296,6 @@ function tryCastLiteralValueToBoolean(literalValue) {
     return !!literalValue;
 }
 
-class MultiExpression extends ExpressionEntity {
-    constructor(expressions) {
-        super();
-        this.expressions = expressions;
-    }
-    deoptimizePath(path) {
-        for (const expression of this.expressions) {
-            expression.deoptimizePath(path);
-        }
-    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return [
-            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
-            false
-        ];
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        for (const expression of this.expressions) {
-            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
-                return true;
-        }
-        return false;
-    }
-}
-
 class ConditionalExpression extends NodeBase {
     constructor() {
         super(...arguments);
@@ -14640,14 +14799,13 @@ class TrackingScope extends BlockScope {
     }
 }
 
-const unset = Symbol('unset');
 class IfStatement extends NodeBase {
     constructor() {
         super(...arguments);
-        this.testValue = unset;
+        this.testValue = UNASSIGNED;
     }
     deoptimizeCache() {
-        this.testValue = UnknownValue;
+        this.testValue = UNASSIGNED;
     }
     hasEffects(context) {
         if (this.test.hasEffects(context)) {
@@ -14736,8 +14894,8 @@ class IfStatement extends NodeBase {
         this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
     }
     getTestValue() {
-        if (this.testValue === unset) {
-            return (this.testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this)));
+        if (this.testValue === UNASSIGNED) {
+            this.testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
         }
         return this.testValue;
     }
@@ -16391,38 +16549,6 @@ class PropertyDefinition extends NodeBase {
 }
 PropertyDefinition.prototype.applyDeoptimizations = doNotDeoptimize;
 
-class ReturnStatement extends NodeBase {
-    hasEffects(context) {
-        if (!context.ignore.returnYield || this.argument?.hasEffects(context))
-            return true;
-        context.brokenFlow = true;
-        return false;
-    }
-    include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        this.argument?.include(context, includeChildrenRecursively);
-        context.brokenFlow = true;
-    }
-    includeNode(context) {
-        this.included = true;
-        this.argument?.includePath(UNKNOWN_PATH, context);
-    }
-    initialise() {
-        super.initialise();
-        this.scope.addReturnExpression(this.argument || UNKNOWN_EXPRESSION);
-    }
-    render(code, options) {
-        if (this.argument) {
-            this.argument.render(code, options, { preventASI: true });
-            if (this.argument.start === this.start + 6 /* 'return'.length */) {
-                code.prependLeft(this.start + 6, ' ');
-            }
-        }
-    }
-}
-ReturnStatement.prototype.applyDeoptimizations = doNotDeoptimize;
-
 class SequenceExpression extends NodeBase {
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         this.expressions[this.expressions.length - 1].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -16946,7 +17072,6 @@ const unaryOperators = {
     void: () => undefined,
     '~': value => ~value
 };
-const UNASSIGNED = Symbol('Unassigned');
 class UnaryExpression extends NodeBase {
     constructor() {
         super(...arguments);
@@ -20795,7 +20920,6 @@ class Chunk {
         const usedModules = [];
         let hoistedSource = '';
         const accessedGlobals = new Set();
-        const renderedModuleSources = new Map();
         const renderOptions = {
             accessedDocumentCurrentScript: false,
             exportNamesByVariable,
@@ -20825,7 +20949,6 @@ class Chunk {
                 if (renderedLength) {
                     if (compact && source.lastLine().includes('//'))
                         source.append('\n');
-                    renderedModuleSources.set(module, source);
                     magicString.addSource(source);
                     usedModules.push(module);
                 }