@rollup/wasm-node 4.63.0 → 4.63.2

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.63.0
-	Tue, 25 Aug 2026 13:03:35 GMT - commit 34b8b924c815ec9413d7821f6fd54cc615584a51
+	Rollup.js v4.63.2
+	Sat, 12 Sep 2026 06:36:48 GMT - commit 43ed4ec364940fbce7054d8da1f92c695d1e6808
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.63.0";
+var version = "4.63.2";
 const package_ = {
 	version: version};
 
@@ -1309,7 +1309,7 @@ function requireScan () {
 	  const opts = options || {};
 
 	  const length = input.length - 1;
-	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
 	  const slashes = [];
 	  const tokens = [];
 	  const parts = [];
@@ -1443,15 +1443,21 @@ function requireScan () {
 	        }
 
 	        if (scanToEnd === true) {
+	          let parens = 0;
+
 	          while (eos() !== true && (code = advance())) {
 	            if (code === CHAR_BACKWARD_SLASH) {
 	              backslashes = token.backslashes = true;
-	              code = advance();
+	              advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_LEFT_PARENTHESES) {
+	              parens++;
 	              continue;
 	            }
 
-	            if (code === CHAR_RIGHT_PARENTHESES) {
-	              isGlob = token.isGlob = true;
+	            if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 	              finished = true;
 	              break;
 	            }
@@ -1516,14 +1522,21 @@ function requireScan () {
 	      isGlob = token.isGlob = true;
 
 	      if (scanToEnd === true) {
+	        let parens = 1;
+
 	        while (eos() !== true && (code = advance())) {
-	          if (code === CHAR_LEFT_PARENTHESES) {
+	          if (code === CHAR_BACKWARD_SLASH) {
 	            backslashes = token.backslashes = true;
-	            code = advance();
+	            advance();
 	            continue;
 	          }
 
-	          if (code === CHAR_RIGHT_PARENTHESES) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            parens++;
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 	            finished = true;
 	            break;
 	          }
@@ -1610,7 +1623,7 @@ function requireScan () {
 	    let prevIndex;
 
 	    for (let idx = 0; idx < slashes.length; idx++) {
-	      const n = prevIndex ? prevIndex + 1 : start;
+	      const n = prevIndex !== undefined ? prevIndex + 1 : start;
 	      const i = slashes[idx];
 	      const value = input.slice(n, i);
 	      if (opts.tokens) {
@@ -1623,21 +1636,20 @@ function requireScan () {
 	        depth(tokens[idx]);
 	        state.maxDepth += tokens[idx].depth;
 	      }
-	      if (idx !== 0 || value !== '') {
+	      if (i >= start) {
 	        parts.push(value);
+	        prevIndex = i;
 	      }
-	      prevIndex = i;
 	    }
 
-	    if (prevIndex && prevIndex + 1 < input.length) {
-	      const value = input.slice(prevIndex + 1);
-	      parts.push(value);
+	    const n = prevIndex !== undefined ? prevIndex + 1 : start;
+	    const value = input.slice(n);
+	    parts.push(value);
 
-	      if (opts.tokens) {
-	        tokens[tokens.length - 1].value = value;
-	        depth(tokens[tokens.length - 1]);
-	        state.maxDepth += tokens[tokens.length - 1].depth;
-	      }
+	    if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
+	      tokens[tokens.length - 1].value = value;
+	      depth(tokens[tokens.length - 1]);
+	      state.maxDepth += tokens[tokens.length - 1].depth;
 	    }
 
 	    state.slashes = slashes;
@@ -2188,9 +2200,33 @@ function requireParse () {
 	  };
 
 	  const extglobClose = token => {
-	    input.slice(token.startIndex, state.index + 1);
+	    const literal = input.slice(token.startIndex, state.index + 1);
 	    const body = input.slice(token.startIndex + 2, state.index);
-	    analyzeRepeatedExtglob(body, opts);
+	    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;
+	    }
 
 	    let output = token.close + (opts.capture ? ')' : '');
 	    let rest;
@@ -2802,6 +2838,15 @@ function requireParse () {
 	        consume('/**', 3);
 	      }
 
+	      // A globstar followed only by balanced closing parens is at the logical end of patterns like
+	      // `test(/utils/**)` and `test?(/utils/**)`. Treat it as EOS so the trailing `/**` can match its
+	      // parent path, except in negated extglobs where that would change the exclusion semantics.
+	      const isEnd = eos() || (
+	        state.parens > 0
+	        && rest === ')'.repeat(state.parens)
+	        && !extglobs.some(extglob => extglob.type === 'negate')
+	      );
+
 	      if (prior.type === 'bos' && eos()) {
 	        prev.type = 'globstar';
 	        prev.value += value;
@@ -2812,7 +2857,7 @@ function requireParse () {
 	        continue;
 	      }
 
-	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && isEnd) {
 	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
 	        prior.output = `(?:${prior.output}`;
 
@@ -4187,7 +4232,7 @@ for (let i = 0; i < chars.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function decodeInteger(reader, relative) {
+function decodeInteger(reader) {
   let value = 0;
   let shift = 0;
   let integer = 0;
@@ -4197,23 +4242,21 @@ function decodeInteger(reader, relative) {
     value |= (integer & 31) << shift;
     shift += 5;
   } while (integer & 32);
-  const shouldNegate = value & 1;
-  value >>>= 1;
-  if (shouldNegate) {
-    value = -2147483648 | -value;
-  }
-  return relative + value;
+  return value;
 }
-function encodeInteger(builder, num, relative) {
-  let delta = num - relative;
-  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+function decodeSign(num) {
+  return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
+}
+function encodeInteger(builder, num) {
   do {
-    let clamped = delta & 31;
-    delta >>>= 5;
-    if (delta > 0) clamped |= 32;
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
     builder.write(intToChar[clamped]);
-  } while (delta > 0);
-  return num;
+  } while (num > 0);
+}
+function encodeSign(num) {
+  return num < 0 ? -num << 1 | 1 : num << 1;
 }
 function hasMoreVlq(reader, max) {
   if (reader.pos >= max) return false;
@@ -4291,15 +4334,15 @@ function decode(mappings) {
     genColumn = 0;
     while (reader.pos < semi) {
       let seg;
-      genColumn = decodeInteger(reader, genColumn);
+      genColumn += decodeSign(decodeInteger(reader));
       if (genColumn < lastCol) sorted = false;
       lastCol = genColumn;
       if (hasMoreVlq(reader, semi)) {
-        sourcesIndex = decodeInteger(reader, sourcesIndex);
-        sourceLine = decodeInteger(reader, sourceLine);
-        sourceColumn = decodeInteger(reader, sourceColumn);
+        sourcesIndex += decodeSign(decodeInteger(reader));
+        sourceLine += decodeSign(decodeInteger(reader));
+        sourceColumn += decodeSign(decodeInteger(reader));
         if (hasMoreVlq(reader, semi)) {
-          namesIndex = decodeInteger(reader, namesIndex);
+          namesIndex += decodeSign(decodeInteger(reader));
           seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
         } else {
           seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
@@ -4336,13 +4379,18 @@ function encode(decoded) {
     for (let j = 0; j < line.length; j++) {
       const segment = line[j];
       if (j > 0) writer.write(comma);
-      genColumn = encodeInteger(writer, segment[0], genColumn);
+      encodeInteger(writer, encodeSign(segment[0] - genColumn));
+      genColumn = segment[0];
       if (segment.length === 1) continue;
-      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-      sourceLine = encodeInteger(writer, segment[2], sourceLine);
-      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+      encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+      encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+      sourcesIndex = segment[1];
+      sourceLine = segment[2];
+      sourceColumn = segment[3];
       if (segment.length === 4) continue;
-      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+      encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+      namesIndex = segment[4];
     }
   }
   return writer.flush();
@@ -5067,8 +5115,8 @@ var MagicString = class MagicString {
 		end = end + this.offset;
 		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start < 0) throw new MagicStringError(`start ${start} is out of bounds`);
 		if (end > this.original.length) throw new MagicStringError(`end ${end} is out of bounds`);
@@ -5151,8 +5199,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start === end) return this;
 		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
@@ -5175,8 +5223,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		if (start === end) return this;
 		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
@@ -5237,8 +5285,8 @@ var MagicString = class MagicString {
 		start = start + this.offset;
 		end = end + this.offset;
 		if (this.original.length !== 0) {
-			while (start < 0) start += this.original.length;
-			while (end < 0) end += this.original.length;
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
 		}
 		let result = "";
 		let chunk = this.firstChunk;
@@ -5424,27 +5472,19 @@ var MagicString = class MagicString {
 			});
 			else return replacement(match[0], ...match.slice(1), match.index, str, match.groups);
 		}
-		function matchAll(re, str) {
-			const matches = [];
-			while (true) {
-				const match = re.exec(str);
-				if (!match) break;
-				matches.push(match);
-			}
-			return matches;
-		}
-		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
-			if (match.index != null) {
-				const replacement = getReplacement(match, this.original);
-				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
-			}
-		});
-		else {
+		const replaceMatch = (match) => {
+			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;
 	}
@@ -5454,7 +5494,8 @@ var MagicString = class MagicString {
 		const index = original.indexOf(string);
 		if (index !== -1) {
 			if (typeof replacement === "function") replacement = replacement(string, index, original);
-			if (string !== replacement) this.overwrite(index, index + string.length, replacement);
+			if (string !== replacement) if (string.length === 0) this.appendRight(index, replacement);
+			else this.overwrite(index, index + string.length, replacement);
 		}
 		return this;
 	}
@@ -5469,6 +5510,13 @@ var MagicString = class MagicString {
 	_replaceAllString(string, replacement) {
 		const { original } = this;
 		const stringLength = string.length;
+		if (stringLength === 0) {
+			for (let index = 0; index <= original.length; index += 1) {
+				const _replacement = typeof replacement === "function" ? replacement("", index, original) : replacement;
+				if (_replacement !== "") this.appendRight(index, _replacement);
+			}
+			return this;
+		}
 		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
 			const previous = original.slice(index, index + stringLength);
 			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : replacement;
@@ -5613,7 +5661,7 @@ var Bundle$1 = class Bundle {
 			indentStringCounts[indentStr] += 1;
 		});
 		return Object.keys(indentStringCounts).sort((a, b) => {
-			return indentStringCounts[a] - indentStringCounts[b];
+			return indentStringCounts[b] - indentStringCounts[a];
 		})[0] || "	";
 	}
 	indent(indentStr) {
@@ -5668,27 +5716,27 @@ var Bundle$1 = class Bundle {
 	trimStart(charType) {
 		const rx = new RegExp(`^${charType || "\\s"}+`);
 		this.intro = this.intro.replace(rx, "");
-		if (!this.intro) {
-			let source;
-			let i = 0;
-			do {
-				source = this.sources[i++];
-				if (!source) break;
-			} while (!source.content.trimStartAborted(charType));
+		if (!this.intro) for (let i = 0; i < this.sources.length; i += 1) {
+			const source = this.sources[i];
+			if (i > 0) {
+				source.separator = (source.separator !== void 0 ? source.separator : this.separator).replace(rx, "");
+				if (source.separator) break;
+			}
+			if (source.content.trimStartAborted(charType)) break;
 		}
 		return this;
 	}
 	trimEnd(charType) {
 		const rx = new RegExp(`${charType || "\\s"}+$`);
-		let source;
-		let i = this.sources.length - 1;
-		do {
-			source = this.sources[i--];
-			if (!source) {
-				this.intro = this.intro.replace(rx, "");
-				break;
+		for (let i = this.sources.length - 1; i >= 0; i -= 1) {
+			const source = this.sources[i];
+			if (source.content.trimEndAborted(charType)) return this;
+			if (i > 0) {
+				source.separator = (source.separator !== void 0 ? source.separator : this.separator).replace(rx, "");
+				if (source.separator) return this;
 			}
-		} while (!source.content.trimEndAborted(charType));
+		}
+		this.intro = this.intro.replace(rx, "");
 		return this;
 	}
 };
@@ -6202,17 +6250,8 @@ class ExpressionEntity {
         return true;
     }
 }
-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_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
+})();
 const UNKNOWN_RETURN_EXPRESSION = [
     UNKNOWN_EXPRESSION,
     false
@@ -6942,7 +6981,11 @@ function isExpressionStatementNode(node) {
 function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
     return Object.create(inheritedDescriptions, memberDescriptions);
 }
-const UNDEFINED_EXPRESSION = new LiteralExpression(undefined);
+const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
+    getLiteralValueAtPath(path) {
+        return path.length > 0 ? UnknownValue : undefined;
+    }
+})();
 const returnsUnknown = {
     value: {
         hasEffectsWhenCalled: null,
@@ -7123,7 +7166,7 @@ function getLiteralMembersForValue(value) {
             return literalStringMembers;
         }
     }
-    return parseAst_js.BLANK;
+    return Object.create(null);
 }
 function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
     if (typeof memberName !== 'string' || !members[memberName]) {
@@ -7423,8 +7466,6 @@ 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;
         }
@@ -10125,156 +10166,6 @@ 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);
@@ -10484,12 +10375,8 @@ class ReturnValueScope extends ParameterScope {
         }
     }
     getReturnExpression() {
-        if (!this.returnExpression) {
-            this.returnExpression =
-                this.returnExpressions.length === 1
-                    ? this.returnExpressions[0]
-                    : new MultiExpression(this.returnExpressions);
-        }
+        if (this.returnExpression === null)
+            this.updateReturnExpression();
         return this.returnExpression;
     }
     deoptimizeAllParameters() {
@@ -10508,6 +10395,17 @@ 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 {
@@ -10569,10 +10467,6 @@ 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 */);
     }
@@ -10588,13 +10482,7 @@ class BlockStatement extends NodeBase {
     addImplicitReturnExpressionToScope() {
         const lastStatement = this.body[this.body.length - 1];
         if (!lastStatement || lastStatement.type !== parseAst_js.ReturnStatement) {
-            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;
+            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
         }
     }
     createScope(parentScope) {
@@ -10605,15 +10493,13 @@ class BlockStatement extends NodeBase {
     hasEffects(context) {
         if (this.deoptimizeBody)
             return true;
-        let hasEffect = false;
         for (const node of this.body) {
-            if (context.brokenFlow || (hasEffect = node.hasEffects(context)))
+            if (context.brokenFlow)
                 break;
+            if (node.hasEffects(context))
+                return true;
         }
-        if (!context.brokenFlow) {
-            hasEffect ||= !!this.virtualReturnStatement?.hasEffects(context);
-        }
-        return hasEffect;
+        return false;
     }
     include(context, includeChildrenRecursively) {
         if (!(this.deoptimizeBody && this.directlyIncluded)) {
@@ -10625,8 +10511,6 @@ class BlockStatement extends NodeBase {
                 if (includeChildrenRecursively || node.shouldBeIncluded(context))
                     node.include(context, includeChildrenRecursively);
             }
-            if (includeChildrenRecursively || !context.brokenFlow)
-                this.virtualReturnStatement?.include(context, includeChildrenRecursively);
         }
     }
     initialise() {
@@ -11639,7 +11523,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([
@@ -13847,10 +13731,11 @@ const binaryOperators = {
     // in: () => UnknownValue,
     // instanceof: () => UnknownValue,
 };
+const UNASSIGNED$1 = Symbol('Unassigned');
 class BinaryExpression extends NodeBase {
     constructor() {
         super(...arguments);
-        this.renderedLiteralValue = UNASSIGNED;
+        this.renderedLiteralValue = UNASSIGNED$1;
     }
     deoptimizeCache() {
         this.renderedLiteralValue = UnknownValue;
@@ -13883,7 +13768,7 @@ class BinaryExpression extends NodeBase {
         if (this.operator !== 'in' || !(this.right.variable instanceof NamespaceVariable)) {
             return UnknownValue;
         }
-        if (this.renderedLiteralValue !== UNASSIGNED)
+        if (this.renderedLiteralValue !== UNASSIGNED$1)
             return this.renderedLiteralValue;
         return (this.renderedLiteralValue = getRenderedLiteralValue(this.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this)));
     }
@@ -14018,10 +13903,10 @@ class CallExpressionBase extends NodeBase {
     }
     deoptimizeCache() {
         if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
-            this.returnExpression = null;
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
             const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = new Set();
-            this.deoptimizableDependentExpressions = [];
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
+            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
             for (const expression of deoptimizableDependentExpressions) {
                 expression.deoptimizeCache();
             }
@@ -14047,7 +13932,7 @@ class CallExpressionBase extends NodeBase {
         }
         return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
             this.deoptimizableDependentExpressions.push(origin);
-            return returnExpression.getLiteralValueAtPath(path, recursionTracker, this);
+            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
         }, UnknownValue);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
@@ -14159,6 +14044,11 @@ 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 &&
@@ -14190,13 +14080,12 @@ class CallExpression extends CallExpressionBase {
     }
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
-            this.returnExpression = UNKNOWN_RETURN_EXPRESSION; // In case of recursion
-            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this);
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
         }
         return this.returnExpression;
     }
 }
-CallExpression.prototype.includeNode = onlyIncludeSelf;
 
 class CatchClause extends NodeBase {
     createScope(parentScope) {
@@ -14296,6 +14185,31 @@ 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);
@@ -14799,13 +14713,14 @@ class TrackingScope extends BlockScope {
     }
 }
 
+const unset = Symbol('unset');
 class IfStatement extends NodeBase {
     constructor() {
         super(...arguments);
-        this.testValue = UNASSIGNED;
+        this.testValue = unset;
     }
     deoptimizeCache() {
-        this.testValue = UNASSIGNED;
+        this.testValue = UnknownValue;
     }
     hasEffects(context) {
         if (this.test.hasEffects(context)) {
@@ -14894,8 +14809,8 @@ class IfStatement extends NodeBase {
         this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
     }
     getTestValue() {
-        if (this.testValue === UNASSIGNED) {
-            this.testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        if (this.testValue === unset) {
+            return (this.testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this)));
         }
         return this.testValue;
     }
@@ -16549,6 +16464,38 @@ 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);
@@ -17072,6 +17019,7 @@ const unaryOperators = {
     void: () => undefined,
     '~': value => ~value
 };
+const UNASSIGNED = Symbol('Unassigned');
 class UnaryExpression extends NodeBase {
     constructor() {
         super(...arguments);