@rollup/wasm-node 4.63.0 → 4.63.1

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.1
+	Fri, 28 Aug 2026 05:58:50 GMT - commit 78bfef0cb94479566f81012fafa372c84b90bd34
 
 	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.1";
 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_RIGHT_PARENTHESES) {
-	              isGlob = token.isGlob = true;
+	            if (code === CHAR_LEFT_PARENTHESES) {
+	              parens++;
+	              continue;
+	            }
+
+	            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}`;
 
@@ -6202,17 +6247,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 +6978,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 +7163,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 +7463,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 +10163,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 +10372,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 +10392,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 +10464,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 +10479,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 +10490,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 +10508,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 +11520,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 +13728,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 +13765,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 +13900,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 +13929,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 +14041,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 +14077,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 +14182,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 +14710,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 +14806,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 +16461,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 +17016,7 @@ const unaryOperators = {
     void: () => undefined,
     '~': value => ~value
 };
+const UNASSIGNED = Symbol('Unassigned');
 class UnaryExpression extends NodeBase {
     constructor() {
         super(...arguments);

package/dist/shared/watch-cli.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.1
+	Fri, 28 Aug 2026 05:58:50 GMT - commit 78bfef0cb94479566f81012fafa372c84b90bd34
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.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.1
+	Fri, 28 Aug 2026 05:58:50 GMT - commit 78bfef0cb94479566f81012fafa372c84b90bd34
 
 	https://github.com/rollup/rollup