@rollup/wasm-node 4.29.0-1 → 4.29.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.29.0-1
-	Thu, 19 Dec 2024 06:37:00 GMT - commit fa5064084196636acd98263f95ffea59f8362e32
+	Rollup.js v4.29.0
+	Fri, 20 Dec 2024 18:36:54 GMT - commit dadd4882c4984d7875af799ad56e506784d50e1c
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.29.0-1";
+var version = "4.29.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1501,8 +1501,48 @@ const createColors = ({ useColor = isColorSupported } = {}) =>
       );
 
 const {
+  reset,
+  bold: bold$1,
+  dim: dim$1,
+  italic,
+  underline: underline$1,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red: red$1,
+  green: green$1,
+  yellow: yellow$1,
   blue,
-  cyan: cyan$1} = createColors();
+  magenta,
+  cyan: cyan$1,
+  white,
+  gray: gray$1,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright,
+} = createColors();
 
 // @see https://no-color.org
 // @see https://www.npmjs.com/package/chalk
@@ -1862,7 +1902,7 @@ let Chunk$1 = class Chunk {
 			// '  test'.trim()
 			//     split   -> '  ' + 'test'
 			//   ✔️ edit    -> '' + 'test'
-			//   ✖️ edit    -> 'test' + '' 
+			//   ✖️ edit    -> 'test' + ''
 			// TODO is this block necessary?...
 			newChunk.edit('', false);
 			this.content = '';
@@ -2109,6 +2149,7 @@ class Mappings {
 				this.raw[this.generatedCodeLine] = this.rawSegments = [];
 				this.generatedCodeColumn = 0;
 				first = true;
+				charInHiresBoundary = false;
 			} else {
 				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
 					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
@@ -2186,6 +2227,7 @@ class MagicString {
 			storedNames: { writable: true, value: {} },
 			indentStr: { writable: true, value: undefined },
 			ignoreList: { writable: true, value: options.ignoreList },
+			offset: { writable: true, value: options.offset || 0 },
 		});
 
 		this.byStart[0] = chunk;
@@ -2204,6 +2246,8 @@ class MagicString {
 	}
 
 	appendLeft(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -2219,6 +2263,8 @@ class MagicString {
 	}
 
 	appendRight(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -2234,7 +2280,7 @@ class MagicString {
 	}
 
 	clone() {
-		const cloned = new MagicString(this.original, { filename: this.filename });
+		const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });
 
 		let originalChunk = this.firstChunk;
 		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
@@ -2432,7 +2478,7 @@ class MagicString {
 		if (!warned.insertLeft) {
 			console.warn(
 				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
-			); // eslint-disable-line no-console
+			);
 			warned.insertLeft = true;
 		}
 
@@ -2443,7 +2489,7 @@ class MagicString {
 		if (!warned.insertRight) {
 			console.warn(
 				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
-			); // eslint-disable-line no-console
+			);
 			warned.insertRight = true;
 		}
 
@@ -2451,6 +2497,10 @@ class MagicString {
 	}
 
 	move(start, end, index) {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+
 		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
 
 		this._split(start);
@@ -2493,6 +2543,9 @@ 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 (this.original.length !== 0) {
@@ -2513,7 +2566,7 @@ class MagicString {
 			if (!warned.storeName) {
 				console.warn(
 					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
-				); // eslint-disable-line no-console
+				);
 				warned.storeName = true;
 			}
 
@@ -2564,6 +2617,8 @@ class MagicString {
 	}
 
 	prependLeft(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -2579,6 +2634,8 @@ class MagicString {
 	}
 
 	prependRight(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -2594,6 +2651,9 @@ class MagicString {
 	}
 
 	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -2620,6 +2680,9 @@ class MagicString {
 	}
 
 	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -2684,7 +2747,10 @@ class MagicString {
 		return this.intro + lineStr;
 	}
 
-	slice(start = 0, end = this.original.length) {
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -2920,11 +2986,7 @@ class MagicString {
 				if (match.index != null) {
 					const replacement = getReplacement(match, this.original);
 					if (replacement !== match[0]) {
-						this.overwrite(
-							match.index,
-							match.index + match[0].length,
-							replacement
-						);
+						this.overwrite(match.index, match.index + match[0].length, replacement);
 					}
 				}
 			});
@@ -2933,11 +2995,7 @@ class MagicString {
 			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
-					);
+					this.overwrite(match.index, match.index + match[0].length, replacement);
 				}
 			}
 		}
@@ -2972,8 +3030,7 @@ class MagicString {
 			index = original.indexOf(string, index + stringLength)
 		) {
 			const previous = original.slice(index, index + stringLength);
-			if (previous !== replacement)
-				this.overwrite(index, index + stringLength, replacement);
+			if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
 		}
 
 		return this;
@@ -3482,6 +3539,71 @@ function renderSystemExportSequenceBeforeExpression(exportedVariable, expression
     }
 }
 
+/** @import { Node } from 'estree' */
+
+/**
+ * @param {Node} node
+ * @param {Node} parent
+ * @returns {boolean}
+ */
+function is_reference(node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
+
+	if (node.type !== 'Identifier') return false;
+
+	switch (parent?.type) {
+		// disregard `bar` in `foo.bar`
+		case 'MemberExpression':
+			return parent.computed || node === parent.object;
+
+		// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+		case 'MethodDefinition':
+			return parent.computed;
+
+		// disregard the `meta` in `import.meta`
+		case 'MetaProperty':
+			return parent.meta === node;
+
+		// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+		case 'PropertyDefinition':
+			return parent.computed || node === parent.value;
+
+		// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+		case 'Property':
+			return parent.computed || node === parent.value;
+
+		// disregard the `bar` in `export { foo as bar }` or
+		// the foo in `import { foo as bar }`
+		case 'ExportSpecifier':
+		case 'ImportSpecifier':
+			return node === parent.local;
+
+		// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+		case 'LabeledStatement':
+		case 'BreakStatement':
+		case 'ContinueStatement':
+			return false;
+
+		default:
+			return true;
+	}
+}
+
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
+        }
+        currentFunctions[PureFunctionKey] = true;
+    }
+    return pureFunctions;
+};
+
 const UnknownKey = Symbol('Unknown Key');
 const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
 const UnknownInteger = Symbol('Unknown Integer');
@@ -3496,7 +3618,7 @@ const UNKNOWN_PATH = [UnknownKey];
 const UNKNOWN_NON_ACCESSOR_PATH = [UnknownNonAccessorKey];
 const UNKNOWN_INTEGER_PATH = [UnknownInteger];
 const EntitiesKey = Symbol('Entities');
-class EntityPathTracker {
+class PathTracker {
     constructor() {
         this.entityPaths = Object.create(null, {
             [EntitiesKey]: { value: new Set() }
@@ -3521,14 +3643,14 @@ class EntityPathTracker {
     getEntities(path) {
         let currentPaths = this.entityPaths;
         for (const pathSegment of path) {
-            currentPaths = currentPaths[pathSegment] ||= Object.create(null, {
-                [EntitiesKey]: { value: new Set() }
-            });
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Set() } });
         }
         return currentPaths[EntitiesKey];
     }
 }
-const SHARED_RECURSION_TRACKER = new EntityPathTracker();
+const SHARED_RECURSION_TRACKER = new PathTracker();
 class DiscriminatedPathTracker {
     constructor() {
         this.entityPaths = Object.create(null, {
@@ -3538,9 +3660,9 @@ class DiscriminatedPathTracker {
     trackEntityAtPathAndGetIfTracked(path, discriminator, entity) {
         let currentPaths = this.entityPaths;
         for (const pathSegment of path) {
-            currentPaths = currentPaths[pathSegment] ||= Object.create(null, {
-                [EntitiesKey]: { value: new Map() }
-            });
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Map() } });
         }
         const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, (getNewSet));
         if (trackedEntities.has(entity))
@@ -3549,137 +3671,6 @@ class DiscriminatedPathTracker {
         return false;
     }
 }
-const UNKNOWN_INCLUDED_PATH = Object.freeze({ [UnknownKey]: parseAst_js.EMPTY_OBJECT });
-class IncludedPathTracker {
-    constructor() {
-        this.includedPaths = null;
-    }
-    includePathAndGetIfIncluded(path) {
-        let included = true;
-        let parent = this;
-        let parentSegment = 'includedPaths';
-        let currentPaths = (this.includedPaths ||=
-            ((included = false), Object.create(null)));
-        for (const pathSegment of path) {
-            // This means from here, all paths are included
-            if (currentPaths[UnknownKey]) {
-                return true;
-            }
-            // Including UnknownKey automatically includes all nested paths.
-            // From above, we know that UnknownKey is not included yet.
-            if (typeof pathSegment === 'symbol') {
-                // Hopefully, this saves some memory over just setting
-                // currentPaths[UnknownKey] = EMPTY_OBJECT
-                parent[parentSegment] = UNKNOWN_INCLUDED_PATH;
-                return false;
-            }
-            parent = currentPaths;
-            parentSegment = pathSegment;
-            currentPaths = currentPaths[pathSegment] ||= ((included = false), Object.create(null));
-        }
-        return included;
-    }
-    includeAllPaths(entity, context, basePath) {
-        const { includedPaths } = this;
-        if (includedPaths) {
-            includeAllPaths(entity, context, basePath, includedPaths);
-        }
-    }
-}
-function includeAllPaths(entity, context, basePath, currentPaths) {
-    if (currentPaths[UnknownKey]) {
-        return entity.includePath([...basePath, UnknownKey], context);
-    }
-    const keys = Object.keys(currentPaths);
-    if (keys.length === 0) {
-        return entity.includePath(basePath, context);
-    }
-    for (const key of keys) {
-        includeAllPaths(entity, context, [...basePath, key], currentPaths[key]);
-    }
-}
-
-/** @import { Node } from 'estree' */
-
-/**
- * @param {Node} node
- * @param {Node} parent
- * @returns {boolean}
- */
-function is_reference(node, parent) {
-	if (node.type === 'MemberExpression') {
-		return !node.computed && is_reference(node.object, node);
-	}
-
-	if (node.type !== 'Identifier') return false;
-
-	switch (parent?.type) {
-		// disregard `bar` in `foo.bar`
-		case 'MemberExpression':
-			return parent.computed || node === parent.object;
-
-		// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
-		case 'MethodDefinition':
-			return parent.computed;
-
-		// disregard the `meta` in `import.meta`
-		case 'MetaProperty':
-			return parent.meta === node;
-
-		// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
-		case 'PropertyDefinition':
-			return parent.computed || node === parent.value;
-
-		// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-		case 'Property':
-			return parent.computed || node === parent.value;
-
-		// disregard the `bar` in `export { foo as bar }` or
-		// the foo in `import { foo as bar }`
-		case 'ExportSpecifier':
-		case 'ImportSpecifier':
-			return node === parent.local;
-
-		// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
-		case 'LabeledStatement':
-		case 'BreakStatement':
-		case 'ContinueStatement':
-			return false;
-
-		default:
-			return true;
-	}
-}
-
-function createInclusionContext() {
-    return {
-        brokenFlow: false,
-        hasBreak: false,
-        hasContinue: false,
-        includedCallArguments: new Set(),
-        includedLabels: new Set()
-    };
-}
-function createHasEffectsContext() {
-    return {
-        accessed: new EntityPathTracker(),
-        assigned: new EntityPathTracker(),
-        brokenFlow: false,
-        called: new DiscriminatedPathTracker(),
-        hasBreak: false,
-        hasContinue: false,
-        ignore: {
-            breaks: false,
-            continues: false,
-            labels: new Set(),
-            returnYield: false,
-            this: false
-        },
-        includedLabels: new Set(),
-        instantiated: new DiscriminatedPathTracker(),
-        replacedVariableInits: new Map()
-    };
-}
 
 function isFlagSet(flags, flag) {
     return (flags & flag) !== 0;
@@ -3690,6 +3681,7 @@ function setFlag(flags, flag, value) {
 
 const UnknownValue = Symbol('Unknown Value');
 const UnknownTruthyValue = Symbol('Unknown Truthy Value');
+const UnknownFalsyValue = Symbol('Unknown Falsy Value');
 class ExpressionEntity {
     constructor() {
         this.flags = 0;
@@ -3718,25 +3710,12 @@ class ExpressionEntity {
     hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
         return true;
     }
-    include(context, _includeChildrenRecursively, _options) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    includeNode(_context) {
+    include(_context, _includeChildrenRecursively, _options) {
         this.included = true;
     }
-    includePath(_path, context) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    /* We are both including and including an unknown path here as the former
-     * ensures that nested nodes are included while the latter ensures that all
-     * paths of the expression are included.
-     * */
-    includeCallArguments(context, interaction) {
-        for (const argument of interaction.args) {
-            argument?.includePath(UNKNOWN_PATH, context);
-            argument?.include(context, false);
+    includeCallArguments(context, parameters) {
+        for (const argument of parameters) {
+            argument.include(context, false);
         }
     }
     shouldBeIncluded(_context) {
@@ -3775,19 +3754,6 @@ const NODE_INTERACTION_UNKNOWN_CALL = {
     withNew: false
 };
 
-const PureFunctionKey = Symbol('PureFunction');
-const getPureFunctions = ({ treeshake }) => {
-    const pureFunctions = Object.create(null);
-    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
-        let currentFunctions = pureFunctions;
-        for (const pathSegment of functionName.split('.')) {
-            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
-        }
-        currentFunctions[PureFunctionKey] = true;
-    }
-    return pureFunctions;
-};
-
 class Variable extends ExpressionEntity {
     markReassigned() {
         this.isReassigned = true;
@@ -3864,9 +3830,9 @@ class Variable extends ExpressionEntity {
      * has not been included previously. Once a variable is included, it should
      * take care all its declarations are included.
      */
-    includePath(path, context) {
+    include() {
         this.included = true;
-        this.renderedLikeHoisted?.includePath(path, context);
+        this.renderedLikeHoisted?.include();
     }
     /**
      * Links the rendered name of this variable to another variable and includes
@@ -3898,8 +3864,8 @@ class ExternalVariable extends Variable {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return type !== INTERACTION_ACCESSED || path.length > (this.isNamespace ? 1 : 0);
     }
-    includePath(path, context) {
-        super.includePath(path, context);
+    include() {
+        super.include();
         this.module.used = true;
     }
 }
@@ -4198,6 +4164,36 @@ const childNodeKeys = {
     YieldExpression: ['argument']
 };
 
+function createInclusionContext() {
+    return {
+        brokenFlow: false,
+        hasBreak: false,
+        hasContinue: false,
+        includedCallArguments: new Set(),
+        includedLabels: new Set()
+    };
+}
+function createHasEffectsContext() {
+    return {
+        accessed: new PathTracker(),
+        assigned: new PathTracker(),
+        brokenFlow: false,
+        called: new DiscriminatedPathTracker(),
+        hasBreak: false,
+        hasContinue: false,
+        ignore: {
+            breaks: false,
+            continues: false,
+            labels: new Set(),
+            returnYield: false,
+            this: false
+        },
+        includedLabels: new Set(),
+        instantiated: new DiscriminatedPathTracker(),
+        replacedVariableInits: new Map()
+    };
+}
+
 const INCLUDE_PARAMETERS = 'variables';
 const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
 class NodeBase extends ExpressionEntity {
@@ -4267,37 +4263,20 @@ class NodeBase extends ExpressionEntity {
             this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
     }
     include(context, includeChildrenRecursively, _options) {
-        if (!this.included)
-            this.includeNode(context);
-        for (const key of childNodeKeys[this.type]) {
-            const value = this[key];
-            if (value === null)
-                continue;
-            if (Array.isArray(value)) {
-                for (const child of value) {
-                    child?.include(context, includeChildrenRecursively);
-                }
-            }
-            else {
-                value.include(context, includeChildrenRecursively);
-            }
-        }
-    }
-    includeNode(context) {
-        this.included = true;
         if (!this.deoptimized)
             this.applyDeoptimizations();
+        this.included = true;
         for (const key of childNodeKeys[this.type]) {
             const value = this[key];
             if (value === null)
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    child?.includePath(UNKNOWN_PATH, context);
+                    child?.include(context, includeChildrenRecursively);
                 }
             }
             else {
-                value.includePath(UNKNOWN_PATH, context);
+                value.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -4404,17 +4383,6 @@ class NodeBase extends ExpressionEntity {
 function createChildNodeKeysForNode(esTreeNode) {
     return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
 }
-function onlyIncludeSelf() {
-    this.included = true;
-    if (!this.deoptimized)
-        this.applyDeoptimizations();
-}
-function onlyIncludeSelfNoDeoptimize() {
-    this.included = true;
-}
-function doNotDeoptimize() {
-    this.deoptimized = true;
-}
 
 function isObjectExpressionNode(node) {
     return node instanceof NodeBase && node.type === parseAst_js.ObjectExpression;
@@ -4427,8 +4395,8 @@ function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions =
     return Object.create(inheritedDescriptions, memberDescriptions);
 }
 const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
-    getLiteralValueAtPath(path) {
-        return path.length > 0 ? UnknownValue : undefined;
+    getLiteralValueAtPath() {
+        return undefined;
     }
 })();
 const returnsUnknown = {
@@ -4625,6 +4593,31 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
     return [members[memberName].returns, false];
 }
 
+class SpreadElement extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 0) {
+            this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, UNKNOWN_PATH, recursionTracker);
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (this.argument.hasEffects(context) ||
+            (propertyReadSideEffects &&
+                (propertyReadSideEffects === 'always' ||
+                    this.argument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context))));
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        // Only properties of properties of the argument could become subject to reassignment
+        // This will also reassign the return values of iterators
+        this.argument.deoptimizePath([UnknownKey, UnknownKey]);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
 class Method extends ExpressionEntity {
     constructor(description) {
         super();
@@ -4750,7 +4743,6 @@ class ObjectEntity extends ExpressionEntity {
         this.unknownIntegerProps = [];
         this.unmatchableGetters = [];
         this.unmatchablePropertiesAndGetters = [];
-        this.unmatchablePropertiesAndSetters = [];
         this.unmatchableSetters = [];
         if (Array.isArray(properties)) {
             this.buildPropertyMaps(properties);
@@ -4985,38 +4977,9 @@ class ObjectEntity extends ExpressionEntity {
         }
         return false;
     }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        for (const property of this.allProperties) {
-            if (includeChildrenRecursively || property.shouldBeIncluded(context)) {
-                property.include(context, includeChildrenRecursively);
-            }
-        }
-        this.prototypeExpression?.include(context, includeChildrenRecursively);
-    }
-    includePath(path, context) {
-        this.included = true;
-        if (path.length === 0)
-            return;
-        const [key, ...subPath] = path;
-        const [includedMembers, includedPath] = typeof key === 'string'
-            ? [
-                [
-                    ...new Set([
-                        ...(this.propertiesAndGettersByKey[key] || this.unmatchablePropertiesAndGetters),
-                        ...(this.propertiesAndSettersByKey[key] || this.unmatchablePropertiesAndSetters)
-                    ])
-                ],
-                subPath
-            ]
-            : [this.allProperties, UNKNOWN_PATH];
-        for (const property of includedMembers) {
-            property.includePath(includedPath, context);
-        }
-        this.prototypeExpression?.includePath(path, context);
-    }
     buildPropertyMaps(properties) {
-        const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchablePropertiesAndSetters, unmatchableGetters, unmatchableSetters } = this;
+        const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchableGetters, unmatchableSetters } = this;
+        const unmatchablePropertiesAndSetters = [];
         for (let index = properties.length - 1; index >= 0; index--) {
             const { key, kind, property } = properties[index];
             allProperties.push(property);
@@ -5286,37 +5249,6 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
 }, OBJECT_PROTOTYPE, true);
 
-class SpreadElement extends NodeBase {
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (path.length > 0) {
-            this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, UNKNOWN_PATH, recursionTracker);
-        }
-    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        return (this.argument.hasEffects(context) ||
-            (propertyReadSideEffects &&
-                (propertyReadSideEffects === 'always' ||
-                    this.argument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context))));
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.argument.includePath(UNKNOWN_PATH, context);
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        // Only properties of properties of the argument could become subject to reassignment
-        // This will also reassign the return values of iterators
-        this.argument.deoptimizePath([UnknownKey, UnknownKey]);
-        this.scope.context.requestTreeshakingPass();
-    }
-}
-
 class ArrayExpression extends NodeBase {
     constructor() {
         super(...arguments);
@@ -5337,16 +5269,6 @@ class ArrayExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const element of this.elements) {
-            if (element) {
-                element?.includePath(UNKNOWN_PATH, context);
-            }
-        }
-    }
     applyDeoptimizations() {
         this.deoptimized = true;
         let hasSpread = false;
@@ -5388,29 +5310,29 @@ class ArrayExpression extends NodeBase {
 
 /* eslint sort-keys: "off" */
 const ValueProperties = Symbol('Value Properties');
-const getTruthyLiteralValue = () => UnknownTruthyValue;
+const getUnknownValue = () => UnknownValue;
 const returnFalse = () => false;
 const returnTrue = () => true;
 const PURE = {
     deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
+    getLiteralValue: getUnknownValue,
     hasEffectsWhenCalled: returnFalse
 };
 const IMPURE = {
     deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
+    getLiteralValue: getUnknownValue,
     hasEffectsWhenCalled: returnTrue
 };
 const PURE_WITH_ARRAY = {
     deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
+    getLiteralValue: getUnknownValue,
     hasEffectsWhenCalled({ args }) {
         return args.length > 1 && !(args[1] instanceof ArrayExpression);
     }
 };
 const GETTER_ACCESS = {
     deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
+    getLiteralValue: getUnknownValue,
     hasEffectsWhenCalled({ args }, context) {
         const [_thisArgument, firstArgument] = args;
         return (!(firstArgument instanceof ExpressionEntity) ||
@@ -5440,7 +5362,7 @@ const MUTATES_ARG_WITHOUT_ACCESSOR = {
         deoptimizeArgumentsOnCall({ args: [, firstArgument] }) {
             firstArgument?.deoptimizePath(UNKNOWN_PATH);
         },
-        getLiteralValue: getTruthyLiteralValue,
+        getLiteralValue: getUnknownValue,
         hasEffectsWhenCalled({ args }, context) {
             return (args.length <= 1 ||
                 args[1].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
@@ -5647,7 +5569,7 @@ const knownGlobals = {
                 }
                 target.deoptimizePath(UNKNOWN_PATH);
             },
-            getLiteralValue: getTruthyLiteralValue,
+            getLiteralValue: getUnknownValue,
             hasEffectsWhenCalled: returnTrue
         }
     },
@@ -5837,7 +5759,7 @@ const knownGlobals = {
             deoptimizeArgumentsOnCall({ args }) {
                 args[2]?.deoptimizePath(['detail']);
             },
-            getLiteralValue: getTruthyLiteralValue,
+            getLiteralValue: getUnknownValue,
             hasEffectsWhenCalled: returnFalse
         },
         prototype: O
@@ -6414,37 +6336,17 @@ class GlobalVariable extends Variable {
     }
 }
 
-// To avoid infinite recursions
-const MAX_PATH_DEPTH = 6;
-// If a path is longer than MAX_PATH_DEPTH, it is truncated so that it is at
-// most MAX_PATH_DEPTH long. The last element is always UnknownKey
-const limitConcatenatedPathDepth = (path1, path2) => {
-    const { length: length1 } = path1;
-    const { length: length2 } = path2;
-    return length1 === 0
-        ? path2
-        : length2 === 0
-            ? path1
-            : length1 + length2 > MAX_PATH_DEPTH
-                ? [...path1, ...path2.slice(0, MAX_PATH_DEPTH - 1 - path1.length), 'UnknownKey']
-                : [...path1, ...path2];
-};
-
 class LocalVariable extends Variable {
-    constructor(name, declarator, init, 
-    /** if this is non-empty, the actual init is this path of this.init */
-    initPath, context, kind) {
+    constructor(name, declarator, init, context, kind) {
         super(name);
         this.init = init;
-        this.initPath = initPath;
-        this.kind = kind;
         this.calledFromTryStatement = false;
         this.additionalInitializers = null;
-        this.includedPathTracker = new IncludedPathTracker();
         this.expressionsToBeDeoptimized = [];
         this.declarations = declarator ? [declarator] : [];
         this.deoptimizationTracker = context.deoptimizationTracker;
         this.module = context.module;
+        this.kind = kind;
     }
     addDeclaration(identifier, init) {
         this.declarations.push(identifier);
@@ -6455,16 +6357,15 @@ class LocalVariable extends Variable {
             for (const initializer of this.additionalInitializers) {
                 initializer.deoptimizePath(UNKNOWN_PATH);
             }
+            this.additionalInitializers = null;
         }
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (this.isReassigned || path.length + this.initPath.length > MAX_PATH_DEPTH) {
+        if (this.isReassigned) {
             deoptimizeInteraction(interaction);
             return;
         }
-        recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
-            this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, [...this.initPath, ...path], recursionTracker);
-        }, undefined);
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker), undefined);
     }
     deoptimizePath(path) {
         if (this.isReassigned ||
@@ -6478,40 +6379,37 @@ class LocalVariable extends Variable {
             for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
-            this.init.deoptimizePath([...this.initPath, UnknownKey]);
+            this.init.deoptimizePath(UNKNOWN_PATH);
         }
         else {
-            this.init.deoptimizePath(limitConcatenatedPathDepth(this.initPath, path));
+            this.init.deoptimizePath(path);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned || path.length + this.initPath.length > MAX_PATH_DEPTH) {
+        if (this.isReassigned) {
             return UnknownValue;
         }
         return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
             this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getLiteralValueAtPath([...this.initPath, ...path], recursionTracker, origin);
+            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
         }, UnknownValue);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        if (this.isReassigned || path.length + this.initPath.length > MAX_PATH_DEPTH) {
+        if (this.isReassigned) {
             return UNKNOWN_RETURN_EXPRESSION;
         }
         return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
             this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getReturnExpressionWhenCalledAtPath([...this.initPath, ...path], interaction, recursionTracker, origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }, UNKNOWN_RETURN_EXPRESSION);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (path.length + this.initPath.length > MAX_PATH_DEPTH) {
-            return true;
-        }
         switch (interaction.type) {
             case INTERACTION_ACCESSED: {
                 if (this.isReassigned)
                     return true;
                 return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-                    this.init.hasEffectsOnInteractionAtPath([...this.initPath, ...path], interaction, context));
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
             case INTERACTION_ASSIGNED: {
                 if (this.included)
@@ -6521,63 +6419,44 @@ class LocalVariable extends Variable {
                 if (this.isReassigned)
                     return true;
                 return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
-                    this.init.hasEffectsOnInteractionAtPath([...this.initPath, ...path], interaction, context));
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
             case INTERACTION_CALLED: {
                 if (this.isReassigned)
                     return true;
                 return (!(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
-                    this.init.hasEffectsOnInteractionAtPath([...this.initPath, ...path], interaction, context));
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
         }
     }
-    includePath(path, context) {
-        if (!this.includedPathTracker.includePathAndGetIfIncluded(path)) {
-            this.module.scope.context.requestTreeshakingPass();
-            if (!this.included) {
-                // This will reduce the number of tree-shaking passes by eagerly
-                // including inits. By pushing this here instead of directly including
-                // we avoid deep call stacks.
-                this.module.scope.context.newlyIncludedVariableInits.add(this.init);
-            }
-            super.includePath(path, context);
+    include() {
+        if (!this.included) {
+            super.include();
             for (const declaration of this.declarations) {
                 // If node is a default export, it can save a tree-shaking run to include the full declaration now
                 if (!declaration.included)
-                    declaration.include(context, false);
+                    declaration.include(createInclusionContext(), false);
                 let node = declaration.parent;
                 while (!node.included) {
                     // We do not want to properly include parents in case they are part of a dead branch
                     // in which case .include() might pull in more dead code
-                    node.includeNode(context);
+                    node.included = true;
                     if (node.type === parseAst_js.Program)
                         break;
                     node = node.parent;
                 }
             }
-            // We need to make sure we include the correct path of the init
-            if (path.length > 0) {
-                this.init.includePath(limitConcatenatedPathDepth(this.initPath, path), context);
-                this.additionalInitializers?.forEach(initializer => initializer.includePath(UNKNOWN_PATH, context));
-            }
         }
     }
-    includeCallArguments(context, interaction) {
-        if (this.isReassigned ||
-            context.includedCallArguments.has(this.init) ||
-            // This can be removed again once we can include arguments when called at
-            // a specific path
-            this.initPath.length > 0) {
-            for (const argument of interaction.args) {
-                if (argument) {
-                    argument.includePath(UNKNOWN_PATH, context);
-                    argument.include(context, false);
-                }
+    includeCallArguments(context, parameters) {
+        if (this.isReassigned || context.includedCallArguments.has(this.init)) {
+            for (const argument of parameters) {
+                argument.include(context, false);
             }
         }
         else {
             context.includedCallArguments.add(this.init);
-            this.init.includeCallArguments(context, interaction);
+            this.init.includeCallArguments(context, parameters);
             context.includedCallArguments.delete(this.init);
         }
     }
@@ -6657,31 +6536,18 @@ class IdentifierBase extends NodeBase {
             }
         }
     }
-    include(context) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    includeNode(context) {
-        this.included = true;
+    include() {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (this.variable !== null) {
-            this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
-        }
-    }
-    includePath(path, context) {
         if (!this.included) {
             this.included = true;
             if (this.variable !== null) {
-                this.scope.context.includeVariableInModule(this.variable, path, context);
+                this.scope.context.includeVariableInModule(this.variable);
             }
         }
-        else if (path.length > 0) {
-            this.variable?.includePath(path, context);
-        }
     }
-    includeCallArguments(context, interaction) {
-        this.variable.includeCallArguments(context, interaction);
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
     }
     isPossibleTDZ() {
         // return cached value to avoid issues with the next tree-shaking pass
@@ -6764,39 +6630,10 @@ function closestParentFunctionOrProgram(node) {
     return node;
 }
 
-class ObjectMember extends ExpressionEntity {
-    constructor(object, path) {
-        super();
-        this.object = object;
-        this.path = path;
-    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [...this.path, ...path], recursionTracker);
-    }
-    deoptimizePath(path) {
-        this.object.deoptimizePath([...this.path, ...path]);
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.object.getLiteralValueAtPath([...this.path, ...path], recursionTracker, origin);
-    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.object.getReturnExpressionWhenCalledAtPath([...this.path, ...path], interaction, recursionTracker, origin);
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return this.object.hasEffectsOnInteractionAtPath([...this.path, ...path], interaction, context);
-    }
-}
-
 class Identifier extends IdentifierBase {
     constructor() {
         super(...arguments);
-        this.variable = null;
-    }
-    get isDestructuringDeoptimized() {
-        return isFlagSet(this.flags, 8388608 /* Flag.destructuringDeoptimized */);
-    }
-    set isDestructuringDeoptimized(value) {
-        this.flags = setFlag(this.flags, 8388608 /* Flag.destructuringDeoptimized */, value);
+        this.variable = null;
     }
     addExportedVariables(variables, exportNamesByVariable) {
         if (exportNamesByVariable.has(this.variable)) {
@@ -6810,52 +6647,42 @@ class Identifier extends IdentifierBase {
             this.isVariableReference = true;
         }
     }
-    declare(kind, destructuredInitPath, init) {
+    declare(kind, init) {
         let variable;
         const { treeshake } = this.scope.context.options;
-        if (kind === 'parameter') {
-            variable = this.scope.addParameterDeclaration(this, destructuredInitPath);
-        }
-        else {
-            variable = this.scope.addDeclaration(this, this.scope.context, init, destructuredInitPath, kind);
-            if (kind === 'var' && treeshake && treeshake.correctVarValueBeforeDeclaration) {
-                // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
-                variable.markInitializersForDeoptimization();
+        switch (kind) {
+            case 'var': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
             }
-        }
-        return [(this.variable = variable)];
-    }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        this.deoptimizePath(EMPTY_PATH);
-        init.deoptimizePath([...destructuredInitPath, UnknownKey]);
-    }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        return (destructuredInitPath.length > 0 &&
-            init.hasEffectsOnInteractionAtPath(destructuredInitPath, NODE_INTERACTION_UNKNOWN_ACCESS, context));
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        if (destructuredInitPath.length > 0 && !this.isDestructuringDeoptimized) {
-            this.isDestructuringDeoptimized = true;
-            init.deoptimizeArgumentsOnInteractionAtPath({
-                args: [new ObjectMember(init, destructuredInitPath.slice(0, -1))],
-                type: INTERACTION_ACCESSED
-            }, destructuredInitPath, SHARED_RECURSION_TRACKER);
-        }
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        if ((this.included ||=
-            destructuredInitPath.length > 0 &&
-                !context.brokenFlow &&
-                propertyReadSideEffects &&
-                (propertyReadSideEffects === 'always' ||
-                    init.hasEffectsOnInteractionAtPath(destructuredInitPath, NODE_INTERACTION_UNKNOWN_ACCESS, createHasEffectsContext())))) {
-            if (this.variable && !this.variable.included) {
-                this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
+            case 'function': {
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'let':
+            case 'const':
+            case 'using':
+            case 'await using':
+            case 'class': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'parameter': {
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            }
+            /* istanbul ignore next */
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
             }
-            init.includePath(destructuredInitPath, context);
-            return true;
         }
-        return false;
+        return [(this.variable = variable)];
     }
     markDeclarationReached() {
         this.variable.initReached = true;
@@ -6909,17 +6736,18 @@ class Scope {
         - then the variable is still declared in the hoisted outer scope, but the initializer is assigned to the parameter
     - const, let, class, and function except in the cases above cannot redeclare anything
      */
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         const name = identifier.name;
         const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
         if (existingVariable) {
-            if (kind === 'var' && existingVariable.kind === 'var') {
+            const existingKind = existingVariable.kind;
+            if (kind === 'var' && existingKind === 'var') {
                 existingVariable.addDeclaration(identifier, init);
                 return existingVariable;
             }
             context.error(parseAst_js.logRedeclarationError(name), identifier.start);
         }
-        const newVariable = new LocalVariable(identifier.name, identifier, init, destructuredInitPath, context, kind);
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
         this.variables.set(name, newVariable);
         return newVariable;
     }
@@ -7095,6 +6923,7 @@ class MethodBase extends NodeBase {
         }
         return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
     }
+    applyDeoptimizations() { }
     getAccessedValue() {
         if (this.accessedValue === null) {
             if (this.kind === 'get') {
@@ -7108,20 +6937,19 @@ class MethodBase extends NodeBase {
         return this.accessedValue;
     }
 }
-MethodBase.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-MethodBase.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class MethodDefinition extends MethodBase {
     hasEffects(context) {
         return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
     }
+    applyDeoptimizations() { }
 }
 
 class BlockScope extends ChildScope {
     constructor(parent) {
         super(parent, parent.context);
     }
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
@@ -7133,7 +6961,7 @@ class BlockScope extends ChildScope {
                 }
                 return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
             }
-            const declaredVariable = this.parent.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
             // Necessary to make sure the init is deoptimized for conditional declarations.
             // We cannot call deoptimizePath here.
             declaredVariable.markInitializersForDeoptimization();
@@ -7141,7 +6969,7 @@ class BlockScope extends ChildScope {
             this.addHoistedVariable(name, declaredVariable);
             return declaredVariable;
         }
-        return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -7173,12 +7001,33 @@ class StaticBlock extends NodeBase {
         }
     }
 }
-StaticBlock.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-StaticBlock.prototype.applyDeoptimizations = doNotDeoptimize;
 function isStaticBlock(statement) {
     return statement.type === parseAst_js.StaticBlock;
 }
 
+class ObjectMember extends ExpressionEntity {
+    constructor(object, key) {
+        super();
+        this.object = object;
+        this.key = key;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.object.deoptimizePath([this.key, ...path]);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
+    }
+}
+
 class ClassNode extends NodeBase {
     constructor() {
         super(...arguments);
@@ -7219,20 +7068,21 @@ class ClassNode extends NodeBase {
             : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
         this.superClass?.include(context, includeChildrenRecursively);
         this.body.include(context, includeChildrenRecursively);
         for (const decorator of this.decorators)
             decorator.include(context, includeChildrenRecursively);
         if (this.id) {
             this.id.markDeclarationReached();
-            this.id.include(context);
+            this.id.include();
         }
     }
     initialise() {
         super.initialise();
-        this.id?.declare('class', EMPTY_PATH, this);
+        this.id?.declare('class', this);
         for (const method of this.body.body) {
             if (method instanceof MethodDefinition && method.kind === 'constructor') {
                 this.classConstructor = method;
@@ -7290,12 +7140,11 @@ class ClassNode extends NodeBase {
         staticProperties.unshift({
             key: 'prototype',
             kind: 'init',
-            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, ['prototype']) : OBJECT_PROTOTYPE)
+            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, 'prototype') : OBJECT_PROTOTYPE)
         });
         return (this.objectEntity = new ObjectEntity(staticProperties, this.superClass || OBJECT_PROTOTYPE));
     }
 }
-ClassNode.prototype.includeNode = onlyIncludeSelf;
 
 class ClassDeclaration extends ClassNode {
     initialise() {
@@ -7348,7 +7197,7 @@ class ClassDeclaration extends ClassNode {
 
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
-        super('arguments', null, UNKNOWN_EXPRESSION, EMPTY_PATH, context, 'other');
+        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
         this.deoptimizedArguments = [];
     }
     addArgumentToBeDeoptimized(argument) {
@@ -7362,8 +7211,8 @@ class ArgumentsVariable extends LocalVariable {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return type !== INTERACTION_ACCESSED || path.length > 1;
     }
-    includePath(path, context) {
-        super.includePath(path, context);
+    include() {
+        super.include();
         for (const argument of this.deoptimizedArguments) {
             argument.deoptimizePath(UNKNOWN_PATH);
         }
@@ -7374,28 +7223,27 @@ class ArgumentsVariable extends LocalVariable {
 const MAX_TRACKED_INTERACTIONS = 20;
 const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
 const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
-const EMPTY_PATH_TRACKER = new EntityPathTracker();
+const EMPTY_PATH_TRACKER = new PathTracker();
 const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
 class ParameterVariable extends LocalVariable {
-    constructor(name, declarator, argumentPath, context) {
-        super(name, declarator, UNKNOWN_EXPRESSION, argumentPath, context, 'parameter');
+    constructor(name, declarator, context) {
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
         this.deoptimizationInteractions = [];
-        this.deoptimizations = new EntityPathTracker();
+        this.deoptimizations = new PathTracker();
         this.deoptimizedFields = new Set();
-        this.argumentsToBeDeoptimized = new Set();
-        this.expressionsDependingOnKnownValue = [];
+        this.entitiesToBeDeoptimized = new Set();
+        this.expressionsUseTheKnownValue = [];
         this.knownValue = null;
         this.knownValueLiteral = UnknownValue;
         this.frozenValue = null;
     }
-    addArgumentValue(entity) {
-        this.updateKnownValue(entity);
+    addEntityToBeDeoptimized(entity) {
         if (entity === UNKNOWN_EXPRESSION) {
             // As unknown expressions fully deoptimize all interactions, we can clear
             // the interaction cache at this point provided we keep this optimization
             // in mind when adding new interactions
-            if (!this.argumentsToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
-                this.argumentsToBeDeoptimized.add(UNKNOWN_EXPRESSION);
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
                 for (const { interaction } of this.deoptimizationInteractions) {
                     deoptimizeInteraction(interaction);
                 }
@@ -7405,34 +7253,27 @@ class ParameterVariable extends LocalVariable {
         else if (this.deoptimizedFields.has(UnknownKey)) {
             // This means that we already deoptimized all interactions and no longer
             // track them
-            entity.deoptimizePath([...this.initPath, UnknownKey]);
+            entity.deoptimizePath(UNKNOWN_PATH);
         }
-        else if (!this.argumentsToBeDeoptimized.has(entity)) {
-            this.argumentsToBeDeoptimized.add(entity);
+        else if (!this.entitiesToBeDeoptimized.has(entity)) {
+            this.entitiesToBeDeoptimized.add(entity);
             for (const field of this.deoptimizedFields) {
-                entity.deoptimizePath([...this.initPath, field]);
+                entity.deoptimizePath([field]);
             }
             for (const { interaction, path } of this.deoptimizationInteractions) {
-                if (this.initPath.length + path.length > MAX_PATH_DEPTH) {
-                    deoptimizeInteraction(interaction);
-                    continue;
-                }
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, [...this.initPath, ...path], SHARED_RECURSION_TRACKER);
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
             }
         }
     }
-    /** This says we should not make assumptions about the value of the parameter.
-     *  This is different from deoptimization that will also cause argument values
-     *  to be deoptimized. */
     markReassigned() {
         if (this.isReassigned) {
             return;
         }
         super.markReassigned();
-        for (const expression of this.expressionsDependingOnKnownValue) {
+        for (const expression of this.expressionsUseTheKnownValue) {
             expression.deoptimizeCache();
         }
-        this.expressionsDependingOnKnownValue = parseAst_js.EMPTY_ARRAY;
+        this.expressionsUseTheKnownValue = parseAst_js.EMPTY_ARRAY;
     }
     deoptimizeCache() {
         this.markReassigned();
@@ -7449,7 +7290,7 @@ class ParameterVariable extends LocalVariable {
         }
         if (this.knownValue === null) {
             this.knownValue = argument;
-            this.knownValueLiteral = argument.getLiteralValueAtPath(this.initPath, SHARED_RECURSION_TRACKER, this);
+            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
             return;
         }
         // the same literal or identifier, do nothing
@@ -7465,7 +7306,7 @@ class ParameterVariable extends LocalVariable {
             return;
         }
         // add tracking for the new argument
-        const newValue = argument.getLiteralValueAtPath(this.initPath, SHARED_RECURSION_TRACKER, this);
+        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
         if (newValue !== oldValue) {
             this.markReassigned();
         }
@@ -7483,31 +7324,24 @@ class ParameterVariable extends LocalVariable {
         return this.frozenValue;
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned || path.length + this.initPath.length > MAX_PATH_DEPTH) {
+        if (this.isReassigned) {
             return UnknownValue;
         }
         const knownValue = this.getKnownValue();
-        this.expressionsDependingOnKnownValue.push(origin);
-        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath([...this.initPath, ...path], recursionTracker, origin), UnknownValue);
+        this.expressionsUseTheKnownValue.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
-        const { type } = interaction;
-        if (this.isReassigned ||
-            type === INTERACTION_ASSIGNED ||
-            path.length + this.initPath.length > MAX_PATH_DEPTH) {
+        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
             return super.hasEffectsOnInteractionAtPath(path, interaction, context);
         }
-        return (!(type === INTERACTION_CALLED
-            ? (interaction.withNew
-                ? context.instantiated
-                : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this)
-            : context.accessed.trackEntityAtPathAndGetIfTracked(path, this)) &&
-            this.getKnownValue().hasEffectsOnInteractionAtPath([...this.initPath, ...path], interaction, context));
+        const knownValue = this.getKnownValue();
+        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
         // For performance reasons, we fully deoptimize all deeper interactions
         if (path.length >= 2 ||
-            this.argumentsToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
+            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
             this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
             (path.length === 1 &&
                 (this.deoptimizedFields.has(UnknownKey) ||
@@ -7516,10 +7350,10 @@ class ParameterVariable extends LocalVariable {
             return;
         }
         if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
-            for (const entity of this.argumentsToBeDeoptimized) {
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, [...this.initPath, ...path], SHARED_RECURSION_TRACKER);
+            for (const entity of this.entitiesToBeDeoptimized) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
             }
-            if (!this.argumentsToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
                 this.deoptimizationInteractions.push({
                     interaction,
                     path
@@ -7540,17 +7374,17 @@ class ParameterVariable extends LocalVariable {
             return;
         }
         this.deoptimizedFields.add(key);
-        for (const entity of this.argumentsToBeDeoptimized) {
+        for (const entity of this.entitiesToBeDeoptimized) {
             // We do not need a recursion tracker here as we already track whether
             // this field is deoptimized
-            entity.deoptimizePath([...this.initPath, key]);
+            entity.deoptimizePath([key]);
         }
         if (key === UnknownKey) {
             // save some memory
             this.deoptimizationInteractions = NO_INTERACTIONS;
             this.deoptimizations = EMPTY_PATH_TRACKER;
             this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
-            this.argumentsToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
         }
     }
     getReturnExpressionWhenCalledAtPath(path) {
@@ -7565,14 +7399,11 @@ class ParameterVariable extends LocalVariable {
         }
         return UNKNOWN_RETURN_EXPRESSION;
     }
-    includeArgumentPaths(entity, context) {
-        this.includedPathTracker.includeAllPaths(entity, context, this.initPath);
-    }
 }
 
 class ThisVariable extends ParameterVariable {
     constructor(context) {
-        super('this', null, EMPTY_PATH, context);
+        super('this', null, context);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return (context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION).hasEffectsOnInteractionAtPath(path, interaction, context);
@@ -7584,7 +7415,7 @@ class CatchBodyScope extends ChildScope {
         super(parent, parent.context);
         this.parent = parent;
     }
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
@@ -7597,7 +7428,7 @@ class CatchBodyScope extends ChildScope {
                     // the assignment actually goes to the parameter and the var is
                     // hoisted without assignment. Locally, it is shadowed by the
                     // parameter
-                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, destructuredInitPath, kind);
+                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, kind);
                     // To avoid the need to rewrite the declaration, we link the variable
                     // names. If we ever implement a logic that splits initialization and
                     // assignment for hoisted vars, the "renderLikeHoisted" logic can be
@@ -7616,7 +7447,7 @@ class CatchBodyScope extends ChildScope {
                 return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
             }
             // We only add parameters to parameter scopes
-            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, kind);
             // Necessary to make sure the init is deoptimized for conditional declarations.
             // We cannot call deoptimizePath here.
             declaredVariable.markInitializersForDeoptimization();
@@ -7624,7 +7455,7 @@ class CatchBodyScope extends ChildScope {
             this.addHoistedVariable(name, declaredVariable);
             return declaredVariable;
         }
-        return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -7634,7 +7465,7 @@ class FunctionBodyScope extends ChildScope {
     }
     // There is stuff that is only allowed in function scopes, i.e. functions can
     // be redeclared, functions and var can redeclare each other
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         const name = identifier.name;
         const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
         if (existingVariable) {
@@ -7646,7 +7477,7 @@ class FunctionBodyScope extends ChildScope {
             }
             context.error(parseAst_js.logRedeclarationError(name), identifier.start);
         }
-        const newVariable = new LocalVariable(identifier.name, identifier, init, destructuredInitPath, context, kind);
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
         this.variables.set(name, newVariable);
         return newVariable;
     }
@@ -7655,21 +7486,21 @@ class FunctionBodyScope extends ChildScope {
 class ParameterScope extends ChildScope {
     constructor(parent, isCatchScope) {
         super(parent, parent.context);
-        this.hasRest = false;
         this.parameters = [];
+        this.hasRest = false;
         this.bodyScope = isCatchScope ? new CatchBodyScope(this) : new FunctionBodyScope(this);
     }
     /**
      * Adds a parameter to this scope. Parameters must be added in the correct
      * order, i.e. from left to right.
      */
-    addParameterDeclaration(identifier, argumentPath) {
+    addParameterDeclaration(identifier) {
         const { name, start } = identifier;
         const existingParameter = this.variables.get(name);
         if (existingParameter) {
             return this.context.error(parseAst_js.logDuplicateArgumentNameError(name), start);
         }
-        const variable = new ParameterVariable(name, identifier, argumentPath, this.context);
+        const variable = new ParameterVariable(name, identifier, this.context);
         this.variables.set(name, variable);
         // We also add it to the body scope to detect name conflicts with local
         // variables. We still need the intermediate scope, though, as parameter
@@ -7687,56 +7518,42 @@ class ParameterScope extends ChildScope {
         }
         this.hasRest = hasRest;
     }
-    includeCallArguments(context, interaction) {
+    includeCallArguments(context, parameters) {
         let calledFromTryStatement = false;
         let argumentIncluded = false;
         const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
-        const { args } = interaction;
-        let lastExplicitlyIncludedIndex = args.length - 1;
-        // If there is a SpreadElement, we need to include all arguments after it
-        // because we no longer know which argument corresponds to which parameter.
-        for (let argumentIndex = 1; argumentIndex < args.length; argumentIndex++) {
-            const argument = args[argumentIndex];
-            if (argument instanceof SpreadElement && !argumentIncluded) {
-                argumentIncluded = true;
-                lastExplicitlyIncludedIndex = argumentIndex - 1;
-            }
-            if (argumentIncluded) {
-                argument.includePath(UNKNOWN_PATH, context);
-                argument.include(context, false);
+        for (const checkedArgument of parameters) {
+            if (checkedArgument instanceof SpreadElement) {
+                for (const argument of parameters) {
+                    argument.include(context, false);
+                }
+                break;
             }
         }
-        // Now we go backwards either starting from the last argument or before the
-        // first SpreadElement to ensure all arguments before are included as needed
-        for (let index = lastExplicitlyIncludedIndex; index >= 1; index--) {
-            const parameterVariables = this.parameters[index - 1] || restParameter;
-            const argument = args[index];
+        for (let index = parameters.length - 1; index >= 0; index--) {
+            const parameterVariables = this.parameters[index] || restParameter;
+            const argument = parameters[index];
             if (parameterVariables) {
                 calledFromTryStatement = false;
                 if (parameterVariables.length === 0) {
-                    // handle empty destructuring to avoid destructuring undefined
+                    // handle empty destructuring
                     argumentIncluded = true;
                 }
                 else {
                     for (const variable of parameterVariables) {
-                        if (variable.calledFromTryStatement) {
-                            calledFromTryStatement = true;
-                        }
                         if (variable.included) {
                             argumentIncluded = true;
-                            if (calledFromTryStatement) {
-                                argument.include(context, true);
-                            }
-                            else {
-                                variable.includeArgumentPaths(argument, context);
-                                argument.include(context, false);
-                            }
+                        }
+                        if (variable.calledFromTryStatement) {
+                            calledFromTryStatement = true;
                         }
                     }
                 }
             }
-            if (!argument.included && (argumentIncluded || argument.shouldBeIncluded(context))) {
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
                 argumentIncluded = true;
+            }
+            if (argumentIncluded) {
                 argument.include(context, calledFromTryStatement);
             }
         }
@@ -7752,62 +7569,11 @@ class ReturnValueScope extends ParameterScope {
     addReturnExpression(expression) {
         this.returnExpressions.push(expression);
     }
-    deoptimizeArgumentsOnCall(interaction) {
-        const { parameters } = this;
-        const { args } = interaction;
-        let position = 0;
-        for (; position < args.length - 1; position++) {
-            // Only the "this" argument arg[0] can be null
-            const argument = args[position + 1];
-            if (argument instanceof SpreadElement) {
-                // This deoptimizes the current and remaining parameters and arguments
-                for (; position < parameters.length; position++) {
-                    args[position + 1]?.deoptimizePath(UNKNOWN_PATH);
-                    parameters[position].forEach(variable => variable.markReassigned());
-                }
-                break;
-            }
-            if (this.hasRest && position >= parameters.length - 1) {
-                argument.deoptimizePath(UNKNOWN_PATH);
-            }
-            else {
-                const variables = parameters[position];
-                if (variables) {
-                    for (const variable of variables) {
-                        variable.addArgumentValue(argument);
-                    }
-                }
-                this.addArgumentToBeDeoptimized(argument);
-            }
-        }
-        const nonRestParameterLength = this.hasRest ? parameters.length - 1 : parameters.length;
-        for (; position < nonRestParameterLength; position++) {
-            for (const variable of parameters[position]) {
-                variable.addArgumentValue(UNDEFINED_EXPRESSION);
-            }
-        }
-    }
     getReturnExpression() {
         if (this.returnExpression === null)
             this.updateReturnExpression();
         return this.returnExpression;
     }
-    deoptimizeAllParameters() {
-        for (const parameter of this.parameters) {
-            for (const variable of parameter) {
-                variable.deoptimizePath(UNKNOWN_PATH);
-                variable.markReassigned();
-            }
-        }
-    }
-    reassignAllParameters() {
-        for (const parameter of this.parameters) {
-            for (const variable of parameter) {
-                variable.markReassigned();
-            }
-        }
-    }
-    addArgumentToBeDeoptimized(_argument) { }
     updateReturnExpression() {
         if (this.returnExpressions.length === 1) {
             this.returnExpression = this.returnExpressions[0];
@@ -7823,30 +7589,24 @@ class ReturnValueScope extends ParameterScope {
 
 class FunctionScope extends ReturnValueScope {
     constructor(parent) {
-        super(parent, false);
         const { context } = parent;
+        super(parent, false);
         this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
         this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
     }
     findLexicalBoundary() {
         return this;
     }
-    includeCallArguments(context, interaction) {
-        super.includeCallArguments(context, interaction);
+    includeCallArguments(context, parameters) {
+        super.includeCallArguments(context, parameters);
         if (this.argumentsVariable.included) {
-            const { args } = interaction;
-            for (let argumentIndex = 1; argumentIndex < args.length; argumentIndex++) {
-                const argument = args[argumentIndex];
-                if (argument) {
-                    argument.includePath(UNKNOWN_PATH, context);
+            for (const argument of parameters) {
+                if (!argument.included) {
                     argument.include(context, false);
                 }
             }
         }
     }
-    addArgumentToBeDeoptimized(argument) {
-        this.argumentsVariable.addArgumentToBeDeoptimized(argument);
-    }
 }
 
 class ExpressionStatement extends NodeBase {
@@ -7874,9 +7634,8 @@ class ExpressionStatement extends NodeBase {
             return this.parent.type !== parseAst_js.Program;
         return super.shouldBeIncluded(context);
     }
+    applyDeoptimizations() { }
 }
-ExpressionStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ExpressionStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class BlockStatement extends NodeBase {
     get deoptimizeBody() {
@@ -7941,8 +7700,6 @@ class BlockStatement extends NodeBase {
         }
     }
 }
-BlockStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-BlockStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class RestElement extends NodeBase {
     constructor() {
@@ -7952,12 +7709,9 @@ class RestElement extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         this.argument.addExportedVariables(variables, exportNamesByVariable);
     }
-    declare(kind, destructuredInitPath, init) {
+    declare(kind, init) {
         this.declarationInit = init;
-        return this.argument.declare(kind, getIncludedPatternPath$1(destructuredInitPath), init);
-    }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        this.argument.deoptimizeAssignment(getIncludedPatternPath$1(destructuredInitPath), init);
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
     }
     deoptimizePath(path) {
         if (path.length === 0) {
@@ -7968,20 +7722,6 @@ class RestElement extends NodeBase {
         return (path.length > 0 ||
             this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
     }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        return this.argument.hasEffectsWhenDestructuring(context, getIncludedPatternPath$1(destructuredInitPath), init);
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        return (this.included =
-            this.argument.includeDestructuredIfNecessary(context, getIncludedPatternPath$1(destructuredInitPath), init) || this.included);
-    }
-    include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        // This should just include the identifier, its properties should be
-        // included where the variable is used.
-        this.argument.include(context, includeChildrenRecursively);
-    }
     markDeclarationReached() {
         this.argument.markDeclarationReached();
     }
@@ -7993,16 +7733,12 @@ class RestElement extends NodeBase {
         }
     }
 }
-RestElement.prototype.includeNode = onlyIncludeSelf;
-const getIncludedPatternPath$1 = (destructuredInitPath) => destructuredInitPath.at(-1) === UnknownKey
-    ? destructuredInitPath
-    : [...destructuredInitPath, UnknownKey];
 
 class FunctionBase extends NodeBase {
     constructor() {
         super(...arguments);
+        this.objectEntity = null;
         this.parameterVariableValuesDeoptimized = false;
-        this.includeCallArguments = this.scope.includeCallArguments.bind(this.scope);
     }
     get async() {
         return isFlagSet(this.flags, 256 /* Flag.async */);
@@ -8022,9 +7758,53 @@ class FunctionBase extends NodeBase {
     set generator(value) {
         this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
     }
+    updateParameterVariableValues(_arguments) {
+        for (let position = 0; position < this.params.length; position++) {
+            const parameter = this.params[position];
+            if (!(parameter instanceof Identifier)) {
+                continue;
+            }
+            const parameterVariable = parameter.variable;
+            const argument = _arguments[position + 1] ?? UNDEFINED_EXPRESSION;
+            parameterVariable.updateKnownValue(argument);
+        }
+    }
+    deoptimizeParameterVariableValues() {
+        for (const parameter of this.params) {
+            if (parameter instanceof Identifier) {
+                const parameterVariable = parameter.variable;
+                parameterVariable.markReassigned();
+            }
+        }
+    }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (interaction.type === INTERACTION_CALLED && path.length === 0) {
-            this.scope.deoptimizeArgumentsOnCall(interaction);
+        if (interaction.type === INTERACTION_CALLED) {
+            const { parameters } = this.scope;
+            const { args } = interaction;
+            let hasRest = false;
+            for (let position = 0; position < args.length - 1; position++) {
+                const parameter = this.params[position];
+                // Only the "this" argument arg[0] can be null
+                const argument = args[position + 1];
+                if (argument instanceof SpreadElement) {
+                    this.deoptimizeParameterVariableValues();
+                }
+                if (hasRest || parameter instanceof RestElement) {
+                    hasRest = true;
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else if (parameter instanceof Identifier) {
+                    parameters[position][0].addEntityToBeDeoptimized(argument);
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+                else if (parameter) {
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else {
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+            }
+            this.updateParameterVariableValues(args);
         }
         else {
             this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -8036,7 +7816,12 @@ class FunctionBase extends NodeBase {
             // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
             // which means the return expression and parameters need to be reassigned
             this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-            this.scope.deoptimizeAllParameters();
+            for (const parameterList of this.scope.parameters) {
+                for (const parameter of parameterList) {
+                    parameter.deoptimizePath(UNKNOWN_PATH);
+                    parameter.markReassigned();
+                }
+            }
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
@@ -8074,13 +7859,8 @@ class FunctionBase extends NodeBase {
                 return true;
             }
         }
-        const { propertyReadSideEffects } = this.scope.context.options
-            .treeshake;
-        for (let index = 0; index < this.params.length; index++) {
-            const parameter = this.params[index];
-            if (parameter.hasEffects(context) ||
-                (propertyReadSideEffects &&
-                    parameter.hasEffectsWhenDestructuring(context, EMPTY_PATH, interaction.args[index + 1] || UNDEFINED_EXPRESSION)))
+        for (const parameter of this.params) {
+            if (parameter.hasEffects(context))
                 return true;
         }
         return false;
@@ -8099,17 +7879,21 @@ class FunctionBase extends NodeBase {
         return variable?.getOnlyFunctionCallUsed() ?? false;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        if (!(this.parameterVariableValuesDeoptimized || this.onlyFunctionCallUsed())) {
+        if (!this.parameterVariableValuesDeoptimized && !this.onlyFunctionCallUsed()) {
             this.parameterVariableValuesDeoptimized = true;
-            this.scope.reassignAllParameters();
+            this.deoptimizeParameterVariableValues();
         }
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
         const { brokenFlow } = context;
         context.brokenFlow = false;
         this.body.include(context, includeChildrenRecursively);
         context.brokenFlow = brokenFlow;
     }
+    includeCallArguments(context, parameters) {
+        this.scope.includeCallArguments(context, parameters);
+    }
     initialise() {
         super.initialise();
         if (this.body instanceof BlockStatement) {
@@ -8131,14 +7915,14 @@ class FunctionBase extends NodeBase {
         // so that the scope already knows all parameters and can detect conflicts
         // when parsing the body.
         const parameters = (this.params = params.map((parameter) => new (context.getNodeConstructor(parameter.type))(this, scope).parseNode(parameter)));
-        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
         this.body = new (context.getNodeConstructor(body.type))(this, bodyScope).parseNode(body);
         return super.parseNode(esTreeNode);
     }
+    addArgumentToBeDeoptimized(_argument) { }
+    applyDeoptimizations() { }
 }
 FunctionBase.prototype.preventChildBlockScope = true;
-FunctionBase.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-FunctionBase.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class FunctionNode extends FunctionBase {
     constructor() {
@@ -8150,16 +7934,18 @@ class FunctionNode extends FunctionBase {
         this.constructedEntity = new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE);
         // This makes sure that all deoptimizations of "this" are applied to the
         // constructed entity.
-        this.scope.thisVariable.addArgumentValue(this.constructedEntity);
+        this.scope.thisVariable.addEntityToBeDeoptimized(this.constructedEntity);
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
         if (interaction.type === INTERACTION_CALLED && path.length === 0 && interaction.args[0]) {
             // args[0] is the "this" argument
-            this.scope.thisVariable.addArgumentValue(interaction.args[0]);
+            this.scope.thisVariable.addEntityToBeDeoptimized(interaction.args[0]);
         }
     }
     hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         if (this.annotationNoSideEffects) {
             return false;
         }
@@ -8197,7 +7983,7 @@ class FunctionNode extends FunctionBase {
     }
     include(context, includeChildrenRecursively) {
         super.include(context, includeChildrenRecursively);
-        this.id?.include(context);
+        this.id?.include();
         const hasArguments = this.scope.argumentsVariable.included;
         for (const parameter of this.params) {
             if (!(parameter instanceof Identifier) || hasArguments) {
@@ -8205,18 +7991,12 @@ class FunctionNode extends FunctionBase {
             }
         }
     }
-    includeNode(context) {
-        this.included = true;
-        const hasArguments = this.scope.argumentsVariable.included;
-        for (const parameter of this.params) {
-            if (!(parameter instanceof Identifier) || hasArguments) {
-                parameter.includePath(UNKNOWN_PATH, context);
-            }
-        }
-    }
     initialise() {
         super.initialise();
-        this.id?.declare('function', EMPTY_PATH, this);
+        this.id?.declare('function', this);
+    }
+    addArgumentToBeDeoptimized(argument) {
+        this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
     }
     getObjectEntity() {
         if (this.objectEntity !== null) {
@@ -8266,16 +8046,11 @@ function getFunctionIdInsertPosition(code, start) {
 }
 class ExportDefaultDeclaration extends NodeBase {
     include(context, includeChildrenRecursively) {
-        this.included = true;
-        this.declaration.include(context, includeChildrenRecursively);
+        super.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively) {
-            this.scope.context.includeVariableInModule(this.variable, UNKNOWN_PATH, context);
+            this.scope.context.includeVariableInModule(this.variable);
         }
     }
-    includePath(path, context) {
-        this.included = true;
-        this.declaration.includePath(path, context);
-    }
     initialise() {
         super.initialise();
         const declaration = this.declaration;
@@ -8320,6 +8095,7 @@ class ExportDefaultDeclaration extends NodeBase {
         }
         this.declaration.render(code, options);
     }
+    applyDeoptimizations() { }
     renderNamedDeclaration(code, declarationStart, idInsertPosition, options) {
         const { exportNamesByVariable, format, snippets: { getPropertyAccess } } = options;
         const name = this.variable.getName(getPropertyAccess);
@@ -8350,8 +8126,6 @@ class ExportDefaultDeclaration extends NodeBase {
     }
 }
 ExportDefaultDeclaration.prototype.needsBoundaries = true;
-ExportDefaultDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ExportDefaultDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
 const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
 const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
@@ -8621,7 +8395,6 @@ class Literal extends NodeBase {
         }
     }
 }
-Literal.prototype.includeNode = onlyIncludeSelf;
 
 function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
     if ('getLiteralValueAtPathAsChainElement' in object) {
@@ -8637,6 +8410,8 @@ function getChainElementLiteralValueAtPath(element, object, path, recursionTrack
     return element.getLiteralValueAtPath(path, recursionTracker, origin);
 }
 
+// To avoid infinite recursions
+const MAX_PATH_DEPTH = 7;
 function getResolvablePropertyKey(memberExpression) {
     return memberExpression.computed
         ? getResolvableComputedPropertyKey(memberExpression.property)
@@ -8735,27 +8510,18 @@ class MemberExpression extends NodeBase {
         }
         else if (!this.isUndefined) {
             if (path.length < MAX_PATH_DEPTH) {
-                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, this.propertyKey === UnknownKey ? UNKNOWN_PATH : [this.propertyKey, ...path], recursionTracker);
+                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
             }
             else {
                 deoptimizeInteraction(interaction);
             }
         }
     }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        this.deoptimizePath(EMPTY_PATH);
-        init.deoptimizePath([...destructuredInitPath, UnknownKey]);
-    }
     deoptimizeCache() {
-        if (this.propertyKey === this.dynamicPropertyKey)
-            return;
         const { expressionsToBeDeoptimized, object } = this;
         this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
-        this.dynamicPropertyKey = this.propertyKey;
+        this.propertyKey = UnknownKey;
         object.deoptimizePath(UNKNOWN_PATH);
-        if (this.included) {
-            object.includePath(UNKNOWN_PATH, createInclusionContext());
-        }
         for (const expression of expressionsToBeDeoptimized) {
             expression.deoptimizeCache();
         }
@@ -8766,13 +8532,11 @@ class MemberExpression extends NodeBase {
         if (this.variable) {
             this.variable.deoptimizePath(path);
         }
-        else if (!this.isUndefined) {
-            const { propertyKey } = this;
+        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
+            const propertyKey = this.getPropertyKey();
             this.object.deoptimizePath([
                 propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
-                ...(path.length < MAX_PATH_DEPTH
-                    ? path
-                    : [...path.slice(0, MAX_PATH_DEPTH), UnknownKey])
+                ...path
             ]);
         }
     }
@@ -8783,11 +8547,9 @@ class MemberExpression extends NodeBase {
         if (this.isUndefined) {
             return undefined;
         }
-        const propertyKey = this.getDynamicPropertyKey();
-        if (propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
-            if (propertyKey !== this.propertyKey)
-                this.expressionsToBeDeoptimized.push(origin);
-            return this.object.getLiteralValueAtPath([propertyKey, ...path], recursionTracker, origin);
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
         }
         return UnknownValue;
     }
@@ -8807,11 +8569,9 @@ class MemberExpression extends NodeBase {
         if (this.isUndefined) {
             return [UNDEFINED_EXPRESSION, false];
         }
-        const propertyKey = this.getDynamicPropertyKey();
-        if (propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
-            if (propertyKey !== this.propertyKey)
-                this.expressionsToBeDeoptimized.push(origin);
-            return this.object.getReturnExpressionWhenCalledAtPath([propertyKey, ...path], interaction, recursionTracker, origin);
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
         }
         return UNKNOWN_RETURN_EXPRESSION;
     }
@@ -8857,45 +8617,14 @@ class MemberExpression extends NodeBase {
             return true;
         }
         if (path.length < MAX_PATH_DEPTH) {
-            return this.object.hasEffectsOnInteractionAtPath([this.getDynamicPropertyKey(), ...path], interaction, context);
+            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
         }
         return true;
     }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        return (destructuredInitPath.length > 0 &&
-            init.hasEffectsOnInteractionAtPath(destructuredInitPath, NODE_INTERACTION_UNKNOWN_ACCESS, context));
-    }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        this.object.include(context, includeChildrenRecursively);
-        this.property.include(context, includeChildrenRecursively);
-    }
-    includeNode(context) {
-        this.included = true;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (this.variable) {
-            this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
-        }
-        else if (!this.isUndefined) {
-            this.object.includePath([this.propertyKey], context);
-        }
-    }
-    includePath(path, context) {
-        if (!this.included)
-            this.includeNode(context);
-        if (this.variable) {
-            this.variable?.includePath(path, context);
-        }
-        else if (!this.isUndefined) {
-            this.object.includePath([
-                this.propertyKey,
-                ...(path.length < MAX_PATH_DEPTH
-                    ? path
-                    : [...path.slice(0, MAX_PATH_DEPTH), UnknownKey])
-            ], context);
-        }
+        this.includeProperties(context, includeChildrenRecursively);
     }
     includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
         if (!this.assignmentDeoptimized)
@@ -8904,34 +8633,20 @@ class MemberExpression extends NodeBase {
             this.include(context, includeChildrenRecursively);
         }
         else {
-            if (!this.included)
-                this.includeNode(context);
-            this.object.include(context, includeChildrenRecursively);
-            this.property.include(context, includeChildrenRecursively);
+            this.includeProperties(context, includeChildrenRecursively);
         }
     }
-    includeCallArguments(context, interaction) {
+    includeCallArguments(context, parameters) {
         if (this.variable) {
-            this.variable.includeCallArguments(context, interaction);
+            this.variable.includeCallArguments(context, parameters);
         }
         else {
-            super.includeCallArguments(context, interaction);
-        }
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        if ((this.included ||=
-            destructuredInitPath.length > 0 &&
-                !context.brokenFlow &&
-                init.hasEffectsOnInteractionAtPath(destructuredInitPath, NODE_INTERACTION_UNKNOWN_ACCESS, createHasEffectsContext()))) {
-            init.include(context, false);
-            return true;
+            super.includeCallArguments(context, parameters);
         }
-        return false;
     }
     initialise() {
         super.initialise();
-        this.dynamicPropertyKey = getResolvablePropertyKey(this);
-        this.propertyKey = this.dynamicPropertyKey === null ? UnknownKey : this.dynamicPropertyKey;
+        this.propertyKey = getResolvablePropertyKey(this);
         this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
@@ -8968,7 +8683,8 @@ class MemberExpression extends NodeBase {
         this.bound &&
             propertyReadSideEffects &&
             !(this.variable || this.isUndefined)) {
-            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [this.propertyKey], SHARED_RECURSION_TRACKER);
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
             this.scope.context.requestTreeshakingPass();
         }
         if (this.variable) {
@@ -8985,7 +8701,7 @@ class MemberExpression extends NodeBase {
         this.bound &&
             propertyReadSideEffects &&
             !(this.variable || this.isUndefined)) {
-            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.propertyKey], SHARED_RECURSION_TRACKER);
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
             this.scope.context.requestTreeshakingPass();
         }
     }
@@ -8994,24 +8710,24 @@ class MemberExpression extends NodeBase {
             const variable = this.scope.findVariable(this.object.name);
             if (variable.isNamespace) {
                 if (this.variable) {
-                    this.scope.context.includeVariableInModule(this.variable, UNKNOWN_PATH, createInclusionContext());
+                    this.scope.context.includeVariableInModule(this.variable);
                 }
                 this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logIllegalImportReassignment(this.object.name, this.scope.context.module.id), this.start);
             }
         }
     }
-    getDynamicPropertyKey() {
-        if (this.dynamicPropertyKey === null) {
-            this.dynamicPropertyKey = this.propertyKey;
+    getPropertyKey() {
+        if (this.propertyKey === null) {
+            this.propertyKey = UnknownKey;
             const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            return (this.dynamicPropertyKey =
+            return (this.propertyKey =
                 value === SymbolToStringTag
                     ? value
                     : typeof value === 'symbol'
                         ? UnknownKey
                         : String(value));
         }
-        return this.dynamicPropertyKey;
+        return this.propertyKey;
     }
     hasAccessEffect(context) {
         const { propertyReadSideEffects } = this.scope.context.options
@@ -9019,7 +8735,17 @@ class MemberExpression extends NodeBase {
         return (!(this.variable || this.isUndefined) &&
             propertyReadSideEffects &&
             (propertyReadSideEffects === 'always' ||
-                this.object.hasEffectsOnInteractionAtPath([this.getDynamicPropertyKey()], this.accessInteraction, context)));
+                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
+    includeProperties(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
     }
 }
 function resolveNamespaceVariables(baseVariable, path, astContext) {
@@ -9063,20 +8789,18 @@ class MetaProperty extends NodeBase {
         return path.length > 1 || type !== INTERACTION_ACCESSED;
     }
     include() {
-        if (!this.included)
-            this.includeNode();
-    }
-    includeNode() {
-        this.included = true;
-        if (this.meta.name === IMPORT) {
-            this.scope.context.addImportMeta(this);
-            const parent = this.parent;
-            const metaProperty = (this.metaProperty =
-                parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
-                    ? parent.propertyKey
-                    : null);
-            if (metaProperty?.startsWith(FILE_PREFIX)) {
-                this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+        if (!this.included) {
+            this.included = true;
+            if (this.meta.name === IMPORT) {
+                this.scope.context.addImportMeta(this);
+                const parent = this.parent;
+                const metaProperty = (this.metaProperty =
+                    parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
+                        ? parent.propertyKey
+                        : null);
+                if (metaProperty?.startsWith(FILE_PREFIX)) {
+                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+                }
             }
         }
     }
@@ -9183,7 +8907,7 @@ class UndefinedVariable extends Variable {
 
 class ExportDefaultVariable extends LocalVariable {
     constructor(name, exportDefaultDeclaration, context) {
-        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, EMPTY_PATH, context, 'other');
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
         this.hasId = false;
         this.originalId = null;
         this.originalVariable = null;
@@ -9332,8 +9056,8 @@ class NamespaceVariable extends Variable {
         return (!memberVariable ||
             memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
     }
-    includePath(path, context) {
-        super.includePath(path, context);
+    include() {
+        super.include();
         this.context.includeAllExports();
     }
     prepare(accessedGlobalsByScope) {
@@ -9426,9 +9150,9 @@ class SyntheticNamedExportVariable extends Variable {
     getName(getPropertyAccess) {
         return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
     }
-    includePath(path, context) {
-        super.includePath(path, context);
-        this.context.includeVariableInModule(this.syntheticNamespace, path, context);
+    include() {
+        super.include();
+        this.context.includeVariableInModule(this.syntheticNamespace);
     }
     setRenderNames(baseName, name) {
         super.setRenderNames(baseName, name);
@@ -12604,11 +12328,17 @@ const createFilter = function createFilter(include, exclude, options) {
         const pathId = normalizePath(id);
         for (let i = 0; i < excludeMatchers.length; ++i) {
             const matcher = excludeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
             if (matcher.test(pathId))
                 return false;
         }
         for (let i = 0; i < includeMatchers.length; ++i) {
             const matcher = includeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
             if (matcher.test(pathId))
                 return true;
         }
@@ -12627,37 +12357,21 @@ class ArrayPattern extends NodeBase {
             element?.addExportedVariables(variables, exportNamesByVariable);
         }
     }
-    declare(kind, destructuredInitPath, init) {
+    declare(kind) {
         const variables = [];
-        const includedPatternPath = getIncludedPatternPath(destructuredInitPath);
         for (const element of this.elements) {
             if (element !== null) {
-                variables.push(...element.declare(kind, includedPatternPath, init));
+                variables.push(...element.declare(kind, UNKNOWN_EXPRESSION));
             }
         }
         return variables;
     }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        const includedPatternPath = getIncludedPatternPath(destructuredInitPath);
-        for (const element of this.elements) {
-            element?.deoptimizeAssignment(includedPatternPath, init);
-        }
-    }
     // Patterns can only be deoptimized at the empty path at the moment
     deoptimizePath() {
         for (const element of this.elements) {
             element?.deoptimizePath(EMPTY_PATH);
         }
     }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        const includedPatternPath = getIncludedPatternPath(destructuredInitPath);
-        for (const element of this.elements) {
-            if (element?.hasEffectsWhenDestructuring(context, includedPatternPath, init)) {
-                return true;
-            }
-        }
-        return false;
-    }
     // Patterns are only checked at the empty path at the moment
     hasEffectsOnInteractionAtPath(_path, interaction, context) {
         for (const element of this.elements) {
@@ -12666,38 +12380,12 @@ class ArrayPattern extends NodeBase {
         }
         return false;
     }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        let included = false;
-        const includedPatternPath = getIncludedPatternPath(destructuredInitPath);
-        for (const element of this.elements) {
-            if (element) {
-                element.included ||= included;
-                included =
-                    element.includeDestructuredIfNecessary(context, includedPatternPath, init) || included;
-            }
-        }
-        if (included) {
-            // This is necessary so that if any pattern element is included, all are
-            // included for proper deconflicting
-            for (const element of this.elements) {
-                if (element && !element.included) {
-                    element.included = true;
-                    element.includeDestructuredIfNecessary(context, includedPatternPath, init);
-                }
-            }
-        }
-        return (this.included ||= included);
-    }
     markDeclarationReached() {
         for (const element of this.elements) {
             element?.markDeclarationReached();
         }
     }
 }
-ArrayPattern.prototype.includeNode = onlyIncludeSelf;
-const getIncludedPatternPath = (destructuredInitPath) => destructuredInitPath.at(-1) === UnknownKey
-    ? destructuredInitPath
-    : [...destructuredInitPath, UnknownInteger];
 
 class ArrowFunctionExpression extends FunctionBase {
     constructor() {
@@ -12714,6 +12402,8 @@ class ArrowFunctionExpression extends FunctionBase {
         this.scope = new ReturnValueScope(parentScope, false);
     }
     hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         return false;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
@@ -12752,15 +12442,6 @@ class ArrowFunctionExpression extends FunctionBase {
             }
         }
     }
-    includeNode(context) {
-        this.included = true;
-        this.body.includePath(UNKNOWN_PATH, context);
-        for (const parameter of this.params) {
-            if (!(parameter instanceof Identifier)) {
-                parameter.includePath(UNKNOWN_PATH, context);
-            }
-        }
-    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -12780,18 +12461,13 @@ class ObjectPattern extends NodeBase {
             }
         }
     }
-    declare(kind, destructuredInitPath, init) {
+    declare(kind, init) {
         const variables = [];
         for (const property of this.properties) {
-            variables.push(...property.declare(kind, destructuredInitPath, init));
+            variables.push(...property.declare(kind, init));
         }
         return variables;
     }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        for (const property of this.properties) {
-            property.deoptimizeAssignment(destructuredInitPath, init);
-        }
-    }
     deoptimizePath(path) {
         if (path.length === 0) {
             for (const property of this.properties) {
@@ -12809,46 +12485,12 @@ class ObjectPattern extends NodeBase {
         }
         return false;
     }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        for (const property of this.properties) {
-            if (property.hasEffectsWhenDestructuring(context, destructuredInitPath, init))
-                return true;
-        }
-        return false;
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        let included = false;
-        for (const property of this.properties) {
-            included =
-                property.includeDestructuredIfNecessary(context, destructuredInitPath, init) || included;
-        }
-        return (this.included ||= included);
-    }
     markDeclarationReached() {
         for (const property of this.properties) {
             property.markDeclarationReached();
         }
     }
-    render(code, options) {
-        if (this.properties.length > 0) {
-            const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.properties, code, this.start + 1, this.end - 1);
-            let lastSeparatorPos = null;
-            for (const { node, separator, start, end } of separatedNodes) {
-                if (!node.included) {
-                    treeshakeNode(node, code, start, end);
-                    continue;
-                }
-                lastSeparatorPos = separator;
-                node.render(code, options);
-            }
-            if (lastSeparatorPos) {
-                code.remove(lastSeparatorPos, this.end - 1);
-            }
-        }
-    }
 }
-ObjectPattern.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ObjectPattern.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class AssignmentExpression extends NodeBase {
     hasEffects(context) {
@@ -12857,9 +12499,7 @@ class AssignmentExpression extends NodeBase {
             this.applyDeoptimizations();
         // MemberExpressions do not access the property before assignments if the
         // operator is '='.
-        return (right.hasEffects(context) ||
-            left.hasEffectsAsAssignmentTarget(context, operator !== '=') ||
-            this.left.hasEffectsWhenDestructuring?.(context, EMPTY_PATH, right));
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
@@ -12868,24 +12508,15 @@ class AssignmentExpression extends NodeBase {
         const { deoptimized, left, right, operator } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
-        if (!this.included)
-            this.includeNode(context);
-        const hasEffectsContext = createHasEffectsContext();
+        this.included = true;
         if (includeChildrenRecursively ||
             operator !== '=' ||
             left.included ||
-            left.hasEffectsAsAssignmentTarget(hasEffectsContext, false) ||
-            left.hasEffectsWhenDestructuring?.(hasEffectsContext, EMPTY_PATH, right)) {
+            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
             left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
         }
         right.include(context, includeChildrenRecursively);
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.right.includePath(UNKNOWN_PATH, context);
-    }
     initialise() {
         super.initialise();
         if (this.left instanceof Identifier) {
@@ -12946,7 +12577,8 @@ class AssignmentExpression extends NodeBase {
     }
     applyDeoptimizations() {
         this.deoptimized = true;
-        this.left.deoptimizeAssignment(EMPTY_PATH, this.right);
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
         this.scope.context.requestTreeshakingPass();
     }
 }
@@ -12955,42 +12587,16 @@ class AssignmentPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         this.left.addExportedVariables(variables, exportNamesByVariable);
     }
-    declare(kind, destructuredInitPath, init) {
-        return this.left.declare(kind, destructuredInitPath, init);
-    }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        this.left.deoptimizeAssignment(destructuredInitPath, init);
+    declare(kind, init) {
+        return this.left.declare(kind, init);
     }
     deoptimizePath(path) {
         if (path.length === 0) {
             this.left.deoptimizePath(path);
-        }
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
-    }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        return this.left.hasEffectsWhenDestructuring(context, destructuredInitPath, init);
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        let included = this.left.includeDestructuredIfNecessary(context, destructuredInitPath, init) ||
-            this.included;
-        if ((included ||= this.right.shouldBeIncluded(context))) {
-            this.right.include(context, false);
-            if (!this.left.included) {
-                this.left.included = true;
-                // Unfortunately, we need to include the left side again now, so that
-                // any declared variables are properly included.
-                this.left.includeDestructuredIfNecessary(context, destructuredInitPath, init);
-            }
-        }
-        return (this.included = included);
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.right.includePath(UNKNOWN_PATH, context);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
     }
     markDeclarationReached() {
         this.left.markDeclarationReached();
@@ -13014,34 +12620,22 @@ class AwaitExpression extends NodeBase {
         return true;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        this.argument.include(context, includeChildrenRecursively);
-    }
-    includeNode(context) {
-        this.included = true;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
-            let parent = this.parent;
-            do {
-                if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
-                    break checkTopLevelAwait;
-            } while ((parent = parent.parent));
-            this.scope.context.usesTopLevelAwait = true;
+        if (!this.included) {
+            this.included = true;
+            checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
+                let parent = this.parent;
+                do {
+                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
+                        break checkTopLevelAwait;
+                } while ((parent = parent.parent));
+                this.scope.context.usesTopLevelAwait = true;
+            }
         }
-        // Thenables need to be included
-        this.argument.includePath(THEN_PATH, context);
-    }
-    includePath(path, context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included)
-            this.includeNode(context);
-        this.argument.includePath(path, context);
+        this.argument.include(context, includeChildrenRecursively);
     }
 }
-const THEN_PATH = ['then'];
 
 const binaryOperators = {
     '!=': (left, right) => left != right,
@@ -13105,8 +12699,6 @@ class BinaryExpression extends NodeBase {
         this.right.render(code, options);
     }
 }
-BinaryExpression.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-BinaryExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class BreakStatement extends NodeBase {
     hasEffects(context) {
@@ -13126,7 +12718,7 @@ class BreakStatement extends NodeBase {
     include(context) {
         this.included = true;
         if (this.label) {
-            this.label.include(context);
+            this.label.include();
             context.includedLabels.add(this.label.name);
         }
         else {
@@ -13135,8 +12727,6 @@ class BreakStatement extends NodeBase {
         context.brokenFlow = true;
     }
 }
-BreakStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-BreakStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 function renderCallArguments(code, options, node) {
     if (node.arguments.length > 0) {
@@ -13323,6 +12913,8 @@ class CallExpression extends CallExpressionBase {
                 this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context)));
     }
     include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         if (includeChildrenRecursively) {
             super.include(context, includeChildrenRecursively);
             if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
@@ -13332,26 +12924,10 @@ class CallExpression extends CallExpressionBase {
             }
         }
         else {
-            if (!this.included)
-                this.includeNode(context);
-            // If the callee is a member expression and does not have a variable, its
-            // object will already be included via the first argument of the
-            // interaction in includeCallArguments. Including it again can lead to
-            // severe performance problems.
-            if (this.callee instanceof MemberExpression && !this.callee.variable) {
-                this.callee.property.include(context, false);
-            }
-            else {
-                this.callee.include(context, false);
-            }
-            this.callee.includeCallArguments(context, this.interaction);
+            this.included = true;
+            this.callee.include(context, false);
         }
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.callee.includePath(UNKNOWN_PATH, context);
+        this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
         super.initialise();
@@ -13390,14 +12966,13 @@ class CatchClause extends NodeBase {
         this.type = type;
         if (param) {
             this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
-            this.param.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION);
+            this.param.declare('parameter', UNKNOWN_EXPRESSION);
         }
         this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
         return super.parseNode(esTreeNode);
     }
 }
 CatchClause.prototype.preventChildBlockScope = true;
-CatchClause.prototype.includeNode = onlyIncludeSelf;
 
 class ChainExpression extends NodeBase {
     // deoptimizations are not relevant as we are not caching values
@@ -13409,22 +12984,17 @@ class ChainExpression extends NodeBase {
     hasEffects(context) {
         return this.expression.hasEffectsAsChainElement(context) === true;
     }
-    includePath(path, context) {
-        this.included = true;
-        this.expression.includePath(path, context);
-    }
     removeAnnotations(code) {
         this.expression.removeAnnotations(code);
     }
+    applyDeoptimizations() { }
 }
-ChainExpression.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ChainExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ClassBodyScope extends ChildScope {
     constructor(parent, classNode) {
         const { context } = parent;
         super(parent, context);
-        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, EMPTY_PATH, context, 'other')));
+        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, 'other')));
         this.instanceScope = new ChildScope(this, context);
         this.instanceScope.variables.set('this', new ThisVariable(context));
     }
@@ -13439,7 +13009,7 @@ class ClassBody extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
-        this.scope.context.includeVariableInModule(this.scope.thisVariable, UNKNOWN_PATH, context);
+        this.scope.context.includeVariableInModule(this.scope.thisVariable);
         for (const definition of this.body) {
             definition.include(context, includeChildrenRecursively);
         }
@@ -13452,9 +13022,8 @@ class ClassBody extends NodeBase {
         }
         return super.parseNode(esTreeNode);
     }
+    applyDeoptimizations() { }
 }
-ClassBody.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ClassBody.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ClassExpression extends ClassNode {
     render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
@@ -13466,6 +13035,19 @@ class ClassExpression extends ClassNode {
     }
 }
 
+function tryCastLiteralValueToBoolean(literalValue) {
+    if (typeof literalValue === 'symbol') {
+        if (literalValue === UnknownFalsyValue) {
+            return false;
+        }
+        if (literalValue === UnknownTruthyValue) {
+            return true;
+        }
+        return UnknownValue;
+    }
+    return !!literalValue;
+}
+
 class MultiExpression extends ExpressionEntity {
     constructor(expressions) {
         super();
@@ -13512,9 +13094,6 @@ class ConditionalExpression extends NodeBase {
             const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
-            if (this.included) {
-                unusedBranch.includePath(UNKNOWN_PATH, createInclusionContext());
-            }
             const { expressionsToBeDeoptimized } = this;
             this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
@@ -13572,7 +13151,7 @@ class ConditionalExpression extends NodeBase {
     include(context, includeChildrenRecursively) {
         this.included = true;
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null || includeChildrenRecursively || this.test.shouldBeIncluded(context)) {
+        if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
             this.test.include(context, includeChildrenRecursively);
             this.consequent.include(context, includeChildrenRecursively);
             this.alternate.include(context, includeChildrenRecursively);
@@ -13581,38 +13160,27 @@ class ConditionalExpression extends NodeBase {
             usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    includePath(path, context) {
-        this.included = true;
-        const usedBranch = this.getUsedBranch();
-        if (usedBranch === null || this.test.shouldBeIncluded(context)) {
-            this.consequent.includePath(path, context);
-            this.alternate.includePath(path, context);
-        }
-        else {
-            usedBranch.includePath(path, context);
-        }
-    }
-    includeCallArguments(context, interaction) {
+    includeCallArguments(context, parameters) {
         const usedBranch = this.getUsedBranch();
         if (usedBranch) {
-            usedBranch.includeCallArguments(context, interaction);
+            usedBranch.includeCallArguments(context, parameters);
         }
         else {
-            this.consequent.includeCallArguments(context, interaction);
-            this.alternate.includeCallArguments(context, interaction);
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
         }
     }
     removeAnnotations(code) {
         this.test.removeAnnotations(code);
     }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        const usedBranch = this.getUsedBranch();
         if (this.test.included) {
             this.test.render(code, options, { renderedSurroundingElement });
             this.consequent.render(code, options);
             this.alternate.render(code, options);
         }
         else {
-            const usedBranch = this.getUsedBranch();
             const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
             const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
                 ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
@@ -13638,14 +13206,12 @@ class ConditionalExpression extends NodeBase {
             return this.usedBranch;
         }
         this.isBranchResolutionAnalysed = true;
-        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        const testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
         return typeof testValue === 'symbol'
             ? null
             : (this.usedBranch = testValue ? this.consequent : this.alternate);
     }
 }
-ConditionalExpression.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ConditionalExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ContinueStatement extends NodeBase {
     hasEffects(context) {
@@ -13665,7 +13231,7 @@ class ContinueStatement extends NodeBase {
     include(context) {
         this.included = true;
         if (this.label) {
-            this.label.include(context);
+            this.label.include();
             context.includedLabels.add(this.label.name);
         }
         else {
@@ -13674,15 +13240,12 @@ class ContinueStatement extends NodeBase {
         context.brokenFlow = true;
     }
 }
-ContinueStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ContinueStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class DebuggerStatement extends NodeBase {
     hasEffects() {
         return true;
     }
 }
-DebuggerStatement.prototype.includeNode = onlyIncludeSelf;
 
 class Decorator extends NodeBase {
     hasEffects(context) {
@@ -13690,7 +13253,6 @@ class Decorator extends NodeBase {
             this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
     }
 }
-Decorator.prototype.includeNode = onlyIncludeSelf;
 
 function hasLoopBodyEffects(context, body) {
     const { brokenFlow, hasBreak, hasContinue, ignore } = context;
@@ -13730,15 +13292,12 @@ class DoWhileStatement extends NodeBase {
         includeLoopBody(context, this.body, includeChildrenRecursively);
     }
 }
-DoWhileStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-DoWhileStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class EmptyStatement extends NodeBase {
     hasEffects() {
         return false;
     }
 }
-EmptyStatement.prototype.includeNode = onlyIncludeSelf;
 
 class ExportAllDeclaration extends NodeBase {
     hasEffects() {
@@ -13751,10 +13310,9 @@ class ExportAllDeclaration extends NodeBase {
     render(code, _options, nodeRenderOptions) {
         code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
     }
+    applyDeoptimizations() { }
 }
 ExportAllDeclaration.prototype.needsBoundaries = true;
-ExportAllDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ExportAllDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ExportNamedDeclaration extends NodeBase {
     bind() {
@@ -13781,15 +13339,13 @@ class ExportNamedDeclaration extends NodeBase {
             this.declaration.render(code, options, { end, start });
         }
     }
+    applyDeoptimizations() { }
 }
 ExportNamedDeclaration.prototype.needsBoundaries = true;
-ExportNamedDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ExportNamedDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
-ExportSpecifier.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ExportSpecifier.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ForInStatement extends NodeBase {
     createScope(parentScope) {
@@ -13807,18 +13363,11 @@ class ForInStatement extends NodeBase {
         const { body, deoptimized, left, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
-        if (!this.included)
-            this.includeNode(context);
+        this.included = true;
         left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
         right.include(context, includeChildrenRecursively);
         includeLoopBody(context, body, includeChildrenRecursively);
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.right.includePath(UNKNOWN_PATH, context);
-    }
     initialise() {
         super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
@@ -13859,18 +13408,11 @@ class ForOfStatement extends NodeBase {
         const { body, deoptimized, left, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
-        if (!this.included)
-            this.includeNode(context);
+        this.included = true;
         left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
         right.include(context, includeChildrenRecursively);
         includeLoopBody(context, body, includeChildrenRecursively);
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.right.includePath(UNKNOWN_PATH, context);
-    }
     initialise() {
         super.initialise();
         this.left.setAssignedValue(UNKNOWN_EXPRESSION);
@@ -13906,9 +13448,7 @@ class ForStatement extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
-        this.init?.include(context, includeChildrenRecursively, {
-            asSingleStatement: true
-        });
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
         this.test?.include(context, includeChildrenRecursively);
         this.update?.include(context, includeChildrenRecursively);
         includeLoopBody(context, this.body, includeChildrenRecursively);
@@ -13920,8 +13460,6 @@ class ForStatement extends NodeBase {
         this.body.render(code, options);
     }
 }
-ForStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ForStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class FunctionExpression extends FunctionNode {
     createScope(parentScope) {
@@ -13953,9 +13491,9 @@ class TrackingScope extends BlockScope {
         super(...arguments);
         this.hoistedDeclarations = [];
     }
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         this.hoistedDeclarations.push(identifier);
-        return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -14054,9 +13592,10 @@ class IfStatement extends NodeBase {
         }
         this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
     }
+    applyDeoptimizations() { }
     getTestValue() {
         if (this.testValue === unset) {
-            return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+            return (this.testValue = tryCastLiteralValueToBoolean(this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this)));
         }
         return this.testValue;
     }
@@ -14122,8 +13661,6 @@ class IfStatement extends NodeBase {
         return false;
     }
 }
-IfStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-IfStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ImportAttribute extends NodeBase {
 }
@@ -14141,15 +13678,13 @@ class ImportDeclaration extends NodeBase {
     render(code, _options, nodeRenderOptions) {
         code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
     }
+    applyDeoptimizations() { }
 }
 ImportDeclaration.prototype.needsBoundaries = true;
-ImportDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ImportDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
-ImportDefaultSpecifier.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ImportDefaultSpecifier.prototype.applyDeoptimizations = doNotDeoptimize;
 
 function isReassignedExportsMember(variable, exportNamesByVariable) {
     return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
@@ -14158,33 +13693,28 @@ function isReassignedExportsMember(variable, exportNamesByVariable) {
 class VariableDeclarator extends NodeBase {
     declareDeclarator(kind, isUsingDeclaration) {
         this.isUsingDeclaration = isUsingDeclaration;
-        this.id.declare(kind, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION);
+        this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
     }
     deoptimizePath(path) {
         this.id.deoptimizePath(path);
     }
     hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         const initEffect = this.init?.hasEffects(context);
         this.id.markDeclarationReached();
-        return (initEffect ||
-            this.isUsingDeclaration ||
-            this.id.hasEffects(context) ||
-            (this.scope.context.options.treeshake
-                .propertyReadSideEffects &&
-                this.id.hasEffectsWhenDestructuring(context, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION)));
+        return initEffect || this.id.hasEffects(context) || this.isUsingDeclaration;
     }
     include(context, includeChildrenRecursively) {
-        const { id, init } = this;
-        if (!this.included)
-            this.includeNode();
+        const { deoptimized, id, init } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
         init?.include(context, includeChildrenRecursively);
         id.markDeclarationReached();
-        if (includeChildrenRecursively) {
+        if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
             id.include(context, includeChildrenRecursively);
         }
-        else {
-            id.includeDestructuredIfNecessary(context, EMPTY_PATH, init || UNDEFINED_EXPRESSION);
-        }
     }
     removeAnnotations(code) {
         this.init?.removeAnnotations(code);
@@ -14214,8 +13744,8 @@ class VariableDeclarator extends NodeBase {
             code.appendLeft(end, `${_}=${_}void 0`);
         }
     }
-    includeNode() {
-        this.included = true;
+    applyDeoptimizations() {
+        this.deoptimized = true;
         const { id, init } = this;
         if (init && id instanceof Identifier && init instanceof ClassExpression && !init.id) {
             const { name, variable } = id;
@@ -14227,14 +13757,11 @@ class VariableDeclarator extends NodeBase {
         }
     }
 }
-VariableDeclarator.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ImportExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.inlineNamespace = null;
-        this.hasUnknownAccessedKey = false;
-        this.accessedPropKey = new Set();
         this.attributes = null;
         this.mechanism = null;
         this.namespaceExportName = undefined;
@@ -14267,15 +13794,12 @@ class ImportExpression extends NodeBase {
             if (parent2 instanceof ExpressionStatement) {
                 return parseAst_js.EMPTY_ARRAY;
             }
-            // Case 1: const { foo } / module = await import('bar')
+            // Case 1: const { foo } = await import('bar')
             if (parent2 instanceof VariableDeclarator) {
                 const declaration = parent2.id;
-                if (declaration instanceof Identifier) {
-                    return this.hasUnknownAccessedKey ? undefined : [...this.accessedPropKey];
-                }
-                if (declaration instanceof ObjectPattern) {
-                    return getDeterministicObjectDestructure(declaration);
-                }
+                return declaration instanceof ObjectPattern
+                    ? getDeterministicObjectDestructure(declaration)
+                    : undefined;
             }
             // Case 2: (await import('bar')).foo
             if (parent2 instanceof MemberExpression) {
@@ -14325,29 +13849,12 @@ class ImportExpression extends NodeBase {
         return true;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode();
-        this.source.include(context, includeChildrenRecursively);
-    }
-    includeNode() {
-        this.included = true;
-        this.scope.context.includeDynamicImport(this);
-        this.scope.addAccessedDynamicImport(this);
-    }
-    includePath(path) {
-        if (!this.included)
-            this.includeNode();
-        // Technically, this is not correct as dynamic imports return a Promise.
-        if (this.hasUnknownAccessedKey)
-            return;
-        if (path[0] === UnknownKey) {
-            this.hasUnknownAccessedKey = true;
-        }
-        else if (typeof path[0] === 'string') {
-            this.accessedPropKey.add(path[0]);
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeDynamicImport(this);
+            this.scope.addAccessedDynamicImport(this);
         }
-        // Update included paths
-        this.scope.context.includeDynamicImport(this);
+        this.source.include(context, includeChildrenRecursively);
     }
     initialise() {
         super.initialise();
@@ -14417,6 +13924,7 @@ class ImportExpression extends NodeBase {
     setInternalResolution(inlineNamespace) {
         this.inlineNamespace = inlineNamespace;
     }
+    applyDeoptimizations() { }
     getDynamicImportMechanismAndHelper(resolution, exportMode, { compact, dynamicImportInCjs, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver) {
         const mechanism = pluginDriver.hookFirstSync('renderDynamicImport', [
             {
@@ -14506,7 +14014,6 @@ class ImportExpression extends NodeBase {
         return { helper: null, mechanism: null };
     }
 }
-ImportExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 function getInteropHelper(resolution, exportMode, interop) {
     return exportMode === 'external'
         ? namespaceInteropHelpersByInteropType[interop(resolution instanceof ExternalModule ? resolution.id : null)]
@@ -14530,14 +14037,12 @@ function getDeterministicObjectDestructure(objectPattern) {
 }
 
 class ImportNamespaceSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
-ImportNamespaceSpecifier.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ImportNamespaceSpecifier.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ImportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
-ImportSpecifier.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-ImportSpecifier.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class JSXIdentifier extends IdentifierBase {
     constructor() {
@@ -14554,29 +14059,6 @@ class JSXIdentifier extends IdentifierBase {
             this.isNativeElement = true;
         }
     }
-    include(context) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (this.variable !== null) {
-            this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
-        }
-    }
-    includePath(path, context) {
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.scope.context.includeVariableInModule(this.variable, path, context);
-            }
-        }
-        else if (path.length > 0) {
-            this.variable?.includePath(path, context);
-        }
-    }
     render(code, { snippets: { getPropertyAccess }, useOriginalName }) {
         if (this.variable) {
             const name = this.variable.getName(getPropertyAccess, useOriginalName);
@@ -14638,7 +14120,6 @@ class JSXAttribute extends NodeBase {
         }
     }
 }
-JSXAttribute.prototype.includeNode = onlyIncludeSelf;
 
 class JSXClosingBase extends NodeBase {
     render(code, options) {
@@ -14651,7 +14132,6 @@ class JSXClosingBase extends NodeBase {
         }
     }
 }
-JSXClosingBase.prototype.includeNode = onlyIncludeSelf;
 
 class JSXClosingElement extends JSXClosingBase {
 }
@@ -14672,15 +14152,8 @@ class JSXSpreadAttribute extends NodeBase {
 
 class JSXEmptyExpression extends NodeBase {
 }
-JSXEmptyExpression.prototype.includeNode = onlyIncludeSelf;
 
 class JSXExpressionContainer extends NodeBase {
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.expression.includePath(UNKNOWN_PATH, context);
-    }
     render(code, options) {
         const { mode } = this.scope.context.options.jsx;
         if (mode !== 'preserve') {
@@ -14701,7 +14174,7 @@ function getRenderedJsxChildren(children) {
     return renderedChildren;
 }
 
-function getAndIncludeFactoryVariable(factory, preserve, importSource, node, context) {
+function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
     const [baseName, nestedName] = factory.split('.');
     let factoryVariable;
     if (importSource) {
@@ -14709,7 +14182,7 @@ function getAndIncludeFactoryVariable(factory, preserve, importSource, node, con
         if (preserve) {
             // This pretends we are accessing an included global variable of the same name
             const globalVariable = node.scope.findGlobal(baseName);
-            globalVariable.includePath(UNKNOWN_PATH, context);
+            globalVariable.include();
             // This excludes this variable from renaming
             factoryVariable.globalName = baseName;
         }
@@ -14717,7 +14190,7 @@ function getAndIncludeFactoryVariable(factory, preserve, importSource, node, con
     else {
         factoryVariable = node.scope.findGlobal(baseName);
     }
-    node.scope.context.includeVariableInModule(factoryVariable, UNKNOWN_PATH, context);
+    node.scope.context.includeVariableInModule(factoryVariable);
     if (factoryVariable instanceof LocalVariable) {
         factoryVariable.consolidateInitializers();
         factoryVariable.addUsedPlace(node);
@@ -14740,20 +14213,16 @@ class JSXElementBase extends NodeBase {
         }
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        for (const child of this.children) {
-            child.include(context, includeChildrenRecursively);
-        }
-    }
-    includeNode(context) {
-        this.included = true;
-        const { factory, importSource, mode } = this.jsxMode;
-        if (factory) {
-            this.factory = factory;
-            this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this, context);
+        if (!this.included) {
+            const { factory, importSource, mode } = this.jsxMode;
+            if (factory) {
+                this.factory = factory;
+                this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this);
+            }
         }
+        super.include(context, includeChildrenRecursively);
     }
+    applyDeoptimizations() { }
     getRenderingMode() {
         const jsx = this.scope.context.options.jsx;
         const { mode, factory, importSource } = jsx;
@@ -14791,14 +14260,8 @@ class JSXElementBase extends NodeBase {
         return { childrenEnd, firstChild, hasMultipleChildren };
     }
 }
-JSXElementBase.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class JSXElement extends JSXElementBase {
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively);
-        this.openingElement.include(context, includeChildrenRecursively);
-        this.closingElement?.include(context, includeChildrenRecursively);
-    }
     render(code, options) {
         switch (this.jsxMode.mode) {
             case 'classic': {
@@ -14950,11 +14413,6 @@ class JSXElement extends JSXElementBase {
 }
 
 class JSXFragment extends JSXElementBase {
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively);
-        this.openingFragment.include(context, includeChildrenRecursively);
-        this.closingFragment.include(context, includeChildrenRecursively);
-    }
     render(code, options) {
         switch (this.jsxMode.mode) {
             case 'classic': {
@@ -15004,22 +14462,10 @@ class JSXFragment extends JSXElementBase {
 }
 
 class JSXMemberExpression extends NodeBase {
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.object.includePath([this.property.name], context);
-    }
-    includePath(path, context) {
-        if (!this.included)
-            this.includeNode(context);
-        this.object.includePath([this.property.name, ...path], context);
-    }
 }
 
 class JSXNamespacedName extends NodeBase {
 }
-JSXNamespacedName.prototype.includeNode = onlyIncludeSelf;
 
 class JSXOpeningElement extends NodeBase {
     render(code, options, { jsxMode = this.scope.context.options.jsx.mode } = {}) {
@@ -15029,7 +14475,6 @@ class JSXOpeningElement extends NodeBase {
         }
     }
 }
-JSXOpeningElement.prototype.includeNode = onlyIncludeSelf;
 
 class JSXOpeningFragment extends NodeBase {
     constructor() {
@@ -15037,22 +14482,22 @@ class JSXOpeningFragment extends NodeBase {
         this.fragment = null;
         this.fragmentVariable = null;
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        const jsx = this.scope.context.options.jsx;
-        if (jsx.mode === 'automatic') {
-            this.fragment = 'Fragment';
-            this.fragmentVariable = getAndIncludeFactoryVariable('Fragment', false, jsx.jsxImportSource, this, context);
-        }
-        else {
-            const { fragment, importSource, mode } = jsx;
-            if (fragment != null) {
-                this.fragment = fragment;
-                this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === 'preserve', importSource, this, context);
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const jsx = this.scope.context.options.jsx;
+            if (jsx.mode === 'automatic') {
+                this.fragment = 'Fragment';
+                this.fragmentVariable = getAndIncludeFactoryVariable('Fragment', false, jsx.jsxImportSource, this);
+            }
+            else {
+                const { fragment, importSource, mode } = jsx;
+                if (fragment != null) {
+                    this.fragment = fragment;
+                    this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === 'preserve', importSource, this);
+                }
             }
         }
+        super.include(context, includeChildrenRecursively);
     }
     render(code, options) {
         const { mode } = this.scope.context.options.jsx;
@@ -15089,7 +14534,6 @@ class JSXText extends NodeBase {
         }
     }
 }
-JSXText.prototype.includeNode = onlyIncludeSelf;
 
 class LabeledStatement extends NodeBase {
     hasEffects(context) {
@@ -15111,22 +14555,17 @@ class LabeledStatement extends NodeBase {
         return bodyHasEffects;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        this.included = true;
         const { brokenFlow, includedLabels } = context;
         context.includedLabels = new Set();
         this.body.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively || context.includedLabels.has(this.label.name)) {
-            this.label.include(context);
+            this.label.include();
             context.includedLabels.delete(this.label.name);
             context.brokenFlow = brokenFlow;
         }
         context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
     }
-    includeNode(context) {
-        this.included = true;
-        this.body.includePath(UNKNOWN_PATH, context);
-    }
     render(code, options) {
         if (this.label.included) {
             this.label.render(code, options);
@@ -15137,7 +14576,6 @@ class LabeledStatement extends NodeBase {
         this.body.render(code, options);
     }
 }
-LabeledStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class LogicalExpression extends NodeBase {
     constructor() {
@@ -15162,10 +14600,6 @@ class LogicalExpression extends NodeBase {
             const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
-            if (this.included) {
-                // As we are not tracking inclusions, we just include everything
-                unusedBranch.includePath(UNKNOWN_PATH, createInclusionContext());
-            }
             const { scope: { context }, expressionsToBeDeoptimized } = this;
             this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
@@ -15192,21 +14626,33 @@ class LogicalExpression extends NodeBase {
             this.expressionsToBeDeoptimized.push(origin);
             return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
         }
+        else {
+            const rightValue = this.right.getLiteralValueAtPath(path, recursionTracker, origin);
+            const booleanOrUnknown = tryCastLiteralValueToBoolean(rightValue);
+            if (typeof booleanOrUnknown !== 'symbol') {
+                if (!booleanOrUnknown && this.operator === '&&') {
+                    this.expressionsToBeDeoptimized.push(origin);
+                    return UnknownFalsyValue;
+                }
+                if (booleanOrUnknown && this.operator === '||') {
+                    return UnknownTruthyValue;
+                }
+            }
+        }
         return UnknownValue;
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch) {
-            this.expressionsToBeDeoptimized.push(origin);
-            return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        }
-        return [
-            new MultiExpression([
-                this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
-                this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
-            ]),
-            false
-        ];
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         if (this.left.hasEffects(context)) {
@@ -15219,18 +14665,18 @@ class LogicalExpression extends NodeBase {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch) {
-            return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+        if (!usedBranch) {
+            return (this.left.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.right.hasEffectsOnInteractionAtPath(path, interaction, context));
         }
-        return (this.left.hasEffectsOnInteractionAtPath(path, interaction, context) ||
-            this.right.hasEffectsOnInteractionAtPath(path, interaction, context));
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
         const usedBranch = this.getUsedBranch();
         if (includeChildrenRecursively ||
-            !usedBranch ||
-            (usedBranch === this.right && this.left.shouldBeIncluded(context))) {
+            (usedBranch === this.right && this.left.shouldBeIncluded(context)) ||
+            !usedBranch) {
             this.left.include(context, includeChildrenRecursively);
             this.right.include(context, includeChildrenRecursively);
         }
@@ -15238,17 +14684,6 @@ class LogicalExpression extends NodeBase {
             usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    includePath(path, context) {
-        this.included = true;
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch || (usedBranch === this.right && this.left.shouldBeIncluded(context))) {
-            this.left.includePath(path, context);
-            this.right.includePath(path, context);
-        }
-        else {
-            usedBranch.includePath(path, context);
-        }
-    }
     removeAnnotations(code) {
         this.left.removeAnnotations(code);
     }
@@ -15285,13 +14720,14 @@ class LogicalExpression extends NodeBase {
         if (!this.isBranchResolutionAnalysed) {
             this.isBranchResolutionAnalysed = true;
             const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            if (typeof leftValue === 'symbol') {
+            const booleanOrUnknown = tryCastLiteralValueToBoolean(leftValue);
+            if (typeof booleanOrUnknown === 'symbol') {
                 return null;
             }
             else {
                 this.usedBranch =
-                    (this.operator === '||' && leftValue) ||
-                        (this.operator === '&&' && !leftValue) ||
+                    (this.operator === '||' && booleanOrUnknown) ||
+                        (this.operator === '&&' && !booleanOrUnknown) ||
                         (this.operator === '??' && leftValue != null)
                         ? this.left
                         : this.right;
@@ -15300,8 +14736,6 @@ class LogicalExpression extends NodeBase {
         return this.usedBranch;
     }
 }
-LogicalExpression.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-LogicalExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class NewExpression extends NodeBase {
     hasEffects(context) {
@@ -15321,21 +14755,16 @@ class NewExpression extends NodeBase {
         return path.length > 0 || type !== INTERACTION_ACCESSED;
     }
     include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         if (includeChildrenRecursively) {
             super.include(context, includeChildrenRecursively);
         }
         else {
-            if (!this.included)
-                this.includeNode(context);
+            this.included = true;
             this.callee.include(context, false);
         }
-        this.callee.includeCallArguments(context, this.interaction);
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.callee.includePath(UNKNOWN_PATH, context);
+        this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
         super.initialise();
@@ -15364,7 +14793,6 @@ class ObjectExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.objectEntity = null;
-        this.protoProp = null;
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -15384,43 +14812,15 @@ class ObjectExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
-        this.getObjectEntity().include(context, includeChildrenRecursively);
-        this.protoProp?.include(context, includeChildrenRecursively);
-    }
-    includeNode(context) {
-        this.included = true;
-        this.protoProp?.includePath(UNKNOWN_PATH, context);
-    }
-    includePath(path, context) {
-        if (!this.included)
-            this.includeNode(context);
-        this.getObjectEntity().includePath(path, context);
-    }
     render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
         if (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
             renderedSurroundingElement === parseAst_js.ArrowFunctionExpression) {
             code.appendRight(this.start, '(');
             code.prependLeft(this.end, ')');
         }
-        if (this.properties.length > 0) {
-            const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.properties, code, this.start + 1, this.end - 1);
-            let lastSeparatorPos = null;
-            for (const { node, separator, start, end } of separatedNodes) {
-                if (!node.included) {
-                    treeshakeNode(node, code, start, end);
-                    continue;
-                }
-                lastSeparatorPos = separator;
-                node.render(code, options);
-            }
-            if (lastSeparatorPos) {
-                code.remove(lastSeparatorPos, this.end - 1);
-            }
-        }
     }
+    applyDeoptimizations() { }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -15449,7 +14849,6 @@ class ObjectExpression extends NodeBase {
                         ? property.key.name
                         : String(property.key.value);
                 if (key === '__proto__' && property.kind === 'init') {
-                    this.protoProp = property;
                     prototype =
                         property.value instanceof Literal && property.value.value === null
                             ? null
@@ -15462,7 +14861,6 @@ class ObjectExpression extends NodeBase {
         return (this.objectEntity = new ObjectEntity(properties, prototype));
     }
 }
-ObjectExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class PanicError extends NodeBase {
     initialise() {
@@ -15489,7 +14887,6 @@ class ParseError extends NodeBase {
 
 class PrivateIdentifier extends NodeBase {
 }
-PrivateIdentifier.prototype.includeNode = onlyIncludeSelf;
 
 class Program extends NodeBase {
     constructor() {
@@ -15557,11 +14954,14 @@ class Program extends NodeBase {
             super.render(code, options);
         }
     }
+    applyDeoptimizations() { }
 }
-Program.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-Program.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class Property extends MethodBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
     //declare method: boolean;
     get method() {
         return isFlagSet(this.flags, 262144 /* Flag.method */);
@@ -15576,41 +14976,17 @@ class Property extends MethodBase {
     set shorthand(value) {
         this.flags = setFlag(this.flags, 524288 /* Flag.shorthand */, value);
     }
-    declare(kind, destructuredInitPath, init) {
-        return this.value.declare(kind, this.getPathInProperty(destructuredInitPath), init);
-    }
-    deoptimizeAssignment(destructuredInitPath, init) {
-        this.value.deoptimizeAssignment?.(this.getPathInProperty(destructuredInitPath), init);
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.value.declare(kind, UNKNOWN_EXPRESSION);
     }
     hasEffects(context) {
-        return this.key.hasEffects(context) || this.value.hasEffects(context);
-    }
-    hasEffectsWhenDestructuring(context, destructuredInitPath, init) {
-        return this.value.hasEffectsWhenDestructuring?.(context, this.getPathInProperty(destructuredInitPath), init);
-    }
-    includeDestructuredIfNecessary(context, destructuredInitPath, init) {
-        const path = this.getPathInProperty(destructuredInitPath);
-        let included = this.value.includeDestructuredIfNecessary(context, path, init) ||
-            this.included;
-        if ((included ||= this.key.hasEffects(createHasEffectsContext()))) {
-            this.key.include(context, false);
-            if (!this.value.included) {
-                this.value.included = true;
-                // Unfortunately, we need to include the value again now, so that any
-                // declared variables are properly included.
-                this.value.includeDestructuredIfNecessary(context, path, init);
-            }
-        }
-        return (this.included = included);
-    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        this.key.include(context, includeChildrenRecursively);
-        this.value.include(context, includeChildrenRecursively);
-    }
-    includePath(path, context) {
-        this.included = true;
-        this.value.includePath(path, context);
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const propertyReadSideEffects = this.scope.context.options.treeshake.propertyReadSideEffects;
+        return ((this.parent.type === 'ObjectPattern' && propertyReadSideEffects === 'always') ||
+            this.key.hasEffects(context) ||
+            this.value.hasEffects(context));
     }
     markDeclarationReached() {
         this.value.markDeclarationReached();
@@ -15621,20 +14997,14 @@ class Property extends MethodBase {
         }
         this.value.render(code, options, { isShorthandProperty: this.shorthand });
     }
-    getPathInProperty(destructuredInitPath) {
-        return destructuredInitPath.at(-1) === UnknownKey
-            ? destructuredInitPath
-            : // For now, we only consider static paths as we do not know how to
-                // deoptimize the path in the dynamic case.
-                this.computed
-                    ? [...destructuredInitPath, UnknownKey]
-                    : this.key instanceof Identifier
-                        ? [...destructuredInitPath, this.key.name]
-                        : [...destructuredInitPath, String(this.key.value)];
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
     }
 }
-Property.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-Property.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class PropertyDefinition extends NodeBase {
     get computed() {
@@ -15667,15 +15037,8 @@ class PropertyDefinition extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return !this.value || this.value.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includeNode(context) {
-        this.included = true;
-        this.value?.includePath(UNKNOWN_PATH, context);
-        for (const decorator of this.decorators) {
-            decorator.includePath(UNKNOWN_PATH, context);
-        }
-    }
+    applyDeoptimizations() { }
 }
-PropertyDefinition.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class ReturnStatement extends NodeBase {
     hasEffects(context) {
@@ -15685,15 +15048,10 @@ class ReturnStatement extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        this.included = true;
         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);
@@ -15707,7 +15065,6 @@ class ReturnStatement extends NodeBase {
         }
     }
 }
-ReturnStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class SequenceExpression extends NodeBase {
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
@@ -15735,15 +15092,10 @@ class SequenceExpression extends NodeBase {
         for (const expression of this.expressions) {
             if (includeChildrenRecursively ||
                 (expression === lastExpression && !(this.parent instanceof ExpressionStatement)) ||
-                expression.shouldBeIncluded(context)) {
+                expression.shouldBeIncluded(context))
                 expression.include(context, includeChildrenRecursively);
-            }
         }
     }
-    includePath(path, context) {
-        this.included = true;
-        this.expressions[this.expressions.length - 1].includePath(path, context);
-    }
     removeAnnotations(code) {
         this.expressions[0].removeAnnotations(code);
     }
@@ -15778,8 +15130,6 @@ class SequenceExpression extends NodeBase {
         }
     }
 }
-SequenceExpression.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-SequenceExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class Super extends NodeBase {
     bind() {
@@ -15791,15 +15141,11 @@ class Super extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
-    include(context) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeVariableInModule(this.variable);
+        }
     }
 }
 
@@ -15840,8 +15186,6 @@ class SwitchCase extends NodeBase {
     }
 }
 SwitchCase.prototype.needsBoundaries = true;
-SwitchCase.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-SwitchCase.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class SwitchStatement extends NodeBase {
     createScope(parentScope) {
@@ -15924,8 +15268,6 @@ class SwitchStatement extends NodeBase {
         }
     }
 }
-SwitchStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-SwitchStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class TaggedTemplateExpression extends CallExpressionBase {
     bind() {
@@ -15949,8 +15291,8 @@ class TaggedTemplateExpression extends CallExpressionBase {
             this.tag.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         if (includeChildrenRecursively) {
             super.include(context, includeChildrenRecursively);
         }
@@ -15959,7 +15301,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
             this.tag.include(context, includeChildrenRecursively);
             this.quasi.include(context, includeChildrenRecursively);
         }
-        this.tag.includeCallArguments(context, this.interaction);
+        this.tag.includeCallArguments(context, this.args);
         const [returnExpression] = this.getReturnExpression();
         if (!returnExpression.included) {
             returnExpression.include(context, false);
@@ -15994,7 +15336,6 @@ class TaggedTemplateExpression extends CallExpressionBase {
         return this.returnExpression;
     }
 }
-TaggedTemplateExpression.prototype.includeNode = onlyIncludeSelf;
 
 class TemplateElement extends NodeBase {
     get tail() {
@@ -16008,13 +15349,15 @@ class TemplateElement extends NodeBase {
     hasEffects() {
         return false;
     }
+    include() {
+        this.included = true;
+    }
     parseNode(esTreeNode) {
         this.value = esTreeNode.value;
         return super.parseNode(esTreeNode);
     }
     render() { }
 }
-TemplateElement.prototype.includeNode = onlyIncludeSelf;
 
 class TemplateLiteral extends NodeBase {
     deoptimizeArgumentsOnInteractionAtPath() { }
@@ -16039,14 +15382,6 @@ class TemplateLiteral extends NodeBase {
         }
         return true;
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const node of this.expressions) {
-            node.includePath(UNKNOWN_PATH, context);
-        }
-    }
     render(code, options) {
         code.indentExclusionRanges.push([this.start, this.end]);
         super.render(code, options);
@@ -16056,13 +15391,13 @@ class TemplateLiteral extends NodeBase {
 class ModuleScope extends ChildScope {
     constructor(parent, context) {
         super(parent, context);
-        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, EMPTY_PATH, context, 'other'));
+        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, 'other'));
     }
-    addDeclaration(identifier, context, init, destructuredInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         if (this.context.module.importDescriptions.has(identifier.name)) {
             context.error(parseAst_js.logRedeclarationError(identifier.name), identifier.start);
         }
-        return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
     addExportDefaultDeclaration(name, exportDefaultDeclaration, context) {
         const variable = new ExportDefaultVariable(name, exportDefaultDeclaration, context);
@@ -16107,23 +15442,10 @@ class ThisExpression extends NodeBase {
         }
         return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    include(context) {
-        if (!this.included)
-            this.includeNode(context);
-    }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.scope.context.includeVariableInModule(this.variable, EMPTY_PATH, context);
-    }
-    includePath(path, context) {
+    include() {
         if (!this.included) {
             this.included = true;
-            this.scope.context.includeVariableInModule(this.variable, path, context);
-        }
-        else if (path.length > 0) {
-            this.variable.includePath(path, context);
+            this.scope.context.includeVariableInModule(this.variable);
         }
     }
     initialise() {
@@ -16151,8 +15473,7 @@ class ThrowStatement extends NodeBase {
         return true;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        this.included = true;
         this.argument.include(context, includeChildrenRecursively);
         context.brokenFlow = true;
     }
@@ -16163,7 +15484,6 @@ class ThrowStatement extends NodeBase {
         }
     }
 }
-ThrowStatement.prototype.includeNode = onlyIncludeSelf;
 
 class TryStatement extends NodeBase {
     constructor() {
@@ -16200,8 +15520,6 @@ class TryStatement extends NodeBase {
         this.finalizer?.include(context, includeChildrenRecursively);
     }
 }
-TryStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-TryStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 const unaryOperators = {
     '!': value => !value,
@@ -16247,7 +15565,6 @@ class UnaryExpression extends NodeBase {
         }
     }
 }
-UnaryExpression.prototype.includeNode = onlyIncludeSelf;
 
 class UpdateExpression extends NodeBase {
     hasEffects(context) {
@@ -16259,8 +15576,9 @@ class UpdateExpression extends NodeBase {
         return path.length > 1 || type !== INTERACTION_ACCESSED;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included)
-            this.includeNode(context);
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
         this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
     }
     initialise() {
@@ -16299,7 +15617,6 @@ class UpdateExpression extends NodeBase {
         this.scope.context.requestTreeshakingPass();
     }
 }
-UpdateExpression.prototype.includeNode = onlyIncludeSelf;
 
 function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
     for (const declarator of declarations) {
@@ -16330,9 +15647,8 @@ class VariableDeclaration extends NodeBase {
     include(context, includeChildrenRecursively, { asSingleStatement } = parseAst_js.BLANK) {
         this.included = true;
         for (const declarator of this.declarations) {
-            if (includeChildrenRecursively || declarator.shouldBeIncluded(context)) {
+            if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
                 declarator.include(context, includeChildrenRecursively);
-            }
             const { id, init } = declarator;
             if (asSingleStatement) {
                 id.include(context, includeChildrenRecursively);
@@ -16370,6 +15686,7 @@ class VariableDeclaration extends NodeBase {
             this.renderReplacedDeclarations(code, options);
         }
     }
+    applyDeoptimizations() { }
     renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
         if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
             code.remove(this.end - 1, this.end);
@@ -16412,7 +15729,8 @@ class VariableDeclaration extends NodeBase {
         const singleSystemExport = gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports);
         for (const { node, start, separator, contentEnd, end } of separatedNodes) {
             if (!node.included) {
-                treeshakeNode(node, code, start, end);
+                code.remove(start, end);
+                node.removeAnnotations(code);
                 continue;
             }
             node.render(code, options);
@@ -16482,8 +15800,6 @@ function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregat
     }
     return singleSystemExport;
 }
-VariableDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-VariableDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class WhileStatement extends NodeBase {
     hasEffects(context) {
@@ -16497,25 +15813,13 @@ class WhileStatement extends NodeBase {
         includeLoopBody(context, this.body, includeChildrenRecursively);
     }
 }
-WhileStatement.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
-WhileStatement.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class YieldExpression extends NodeBase {
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.argument?.deoptimizePath(UNKNOWN_PATH);
-    }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         return !(context.ignore.returnYield && !this.argument?.hasEffects(context));
     }
-    includeNode(context) {
-        this.included = true;
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.argument?.includePath(UNKNOWN_PATH, context);
-    }
     render(code, options) {
         if (this.argument) {
             this.argument.render(code, options, { preventASI: true });
@@ -16749,7 +16053,7 @@ const bufferParsers = [
         const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
         node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
         const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer));
-        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
         node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer);
     },
     function assignmentExpression(node, position, buffer) {
@@ -16795,7 +16099,7 @@ const bufferParsers = [
         const parameterPosition = buffer[position];
         const parameter = (node.param =
             parameterPosition === 0 ? null : convertNode(node, scope, parameterPosition, buffer));
-        parameter?.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION);
+        parameter?.declare('parameter', UNKNOWN_EXPRESSION);
         node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer);
     },
     function chainExpression(node, position, buffer) {
@@ -16933,7 +16237,7 @@ const bufferParsers = [
         node.id =
             idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
         const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
-        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
         node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
     },
     function functionExpression(node, position, buffer) {
@@ -16946,7 +16250,7 @@ const bufferParsers = [
         const idPosition = buffer[position + 2];
         node.id = idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer);
         const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
-        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', EMPTY_PATH, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
         node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
     },
     function identifier(node, position, buffer) {
@@ -17410,8 +16714,8 @@ class ExportShimVariable extends Variable {
         super(MISSING_EXPORT_SHIM_VARIABLE);
         this.module = module;
     }
-    includePath(path, context) {
-        super.includePath(path, context);
+    include() {
+        super.include();
         this.module.needsExportShim = true;
     }
 }
@@ -18102,15 +17406,16 @@ class Module {
             markModuleAndImpureDependenciesAsExecuted(this);
             this.graph.needsTreeshakingPass = true;
         }
-        const inclusionContext = createInclusionContext();
         for (const exportName of this.exports.keys()) {
             if (includeNamespaceMembers || exportName !== this.info.syntheticNamedExports) {
                 const variable = this.getVariableForExportName(exportName)[0];
                 if (!variable) {
                     return parseAst_js.error(parseAst_js.logMissingEntryExport(exportName, this.id));
                 }
-                this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
                 variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
             }
         }
         for (const name of this.getReexports()) {
@@ -18118,7 +17423,7 @@ class Module {
             if (variable) {
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
-                    this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
+                    this.includeVariable(variable);
                 }
                 if (variable instanceof ExternalVariable) {
                     variable.module.reexported = true;
@@ -18139,12 +17444,13 @@ class Module {
             this.graph.needsTreeshakingPass = true;
         }
         let includeNamespaceMembers = false;
-        const inclusionContext = createInclusionContext();
         for (const name of names) {
             const variable = this.getVariableForExportName(name)[0];
             if (variable) {
                 variable.deoptimizePath(UNKNOWN_PATH);
-                this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
             }
             if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
                 includeNamespaceMembers = true;
@@ -18245,7 +17551,6 @@ class Module {
             manualPureFunctions: this.graph.pureFunctions,
             module: this,
             moduleContext: this.context,
-            newlyIncludedVariableInits: this.graph.newlyIncludedVariableInits,
             options: this.options,
             requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
             traceExport: (name) => this.getVariableForExportName(name)[0],
@@ -18586,13 +17891,13 @@ class Module {
         for (const module of [this, ...this.exportAllModules]) {
             if (module instanceof ExternalModule) {
                 const [externalVariable] = module.getVariableForExportName('*');
-                externalVariable.includePath(UNKNOWN_PATH, createInclusionContext());
+                externalVariable.include();
                 this.includedImports.add(externalVariable);
                 externalNamespaces.add(externalVariable);
             }
             else if (module.info.syntheticNamedExports) {
                 const syntheticNamespace = module.getSyntheticNamespace();
-                syntheticNamespace.includePath(UNKNOWN_PATH, createInclusionContext());
+                syntheticNamespace.include();
                 this.includedImports.add(syntheticNamespace);
                 syntheticNamespaces.add(syntheticNamespace);
             }
@@ -18602,9 +17907,7 @@ class Module {
     includeDynamicImport(node) {
         const resolution = this.dynamicImports.find(dynamicImport => dynamicImport.node === node).resolution;
         if (resolution instanceof Module) {
-            if (!resolution.includedDynamicImporters.includes(this)) {
-                resolution.includedDynamicImporters.push(this);
-            }
+            resolution.includedDynamicImporters.push(this);
             const importedNames = this.options.treeshake
                 ? node.getDeterministicImportedNames()
                 : undefined;
@@ -18616,15 +17919,15 @@ class Module {
             }
         }
     }
-    includeVariable(variable, path, context) {
-        const { included, module: variableModule } = variable;
-        variable.includePath(path, context);
-        if (included) {
+    includeVariable(variable) {
+        const variableModule = variable.module;
+        if (variable.included) {
             if (variableModule instanceof Module && variableModule !== this) {
                 getAndExtendSideEffectModules(variable, this);
             }
         }
         else {
+            variable.include();
             this.graph.needsTreeshakingPass = true;
             if (variableModule instanceof Module) {
                 if (!variableModule.isExecuted) {
@@ -18641,8 +17944,8 @@ class Module {
             }
         }
     }
-    includeVariableInModule(variable, path, context) {
-        this.includeVariable(variable, path, context);
+    includeVariableInModule(variable) {
+        this.includeVariable(variable);
         const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
             this.includedImports.add(variable);
@@ -22145,11 +21448,10 @@ class Graph {
         this.options = options;
         this.astLru = flru(5);
         this.cachedModules = new Map();
-        this.deoptimizationTracker = new EntityPathTracker();
+        this.deoptimizationTracker = new PathTracker();
         this.entryModules = [];
         this.modulesById = new Map();
         this.needsTreeshakingPass = false;
-        this.newlyIncludedVariableInits = new Set();
         this.phase = BuildPhase.LOAD_AND_PARSE;
         this.scope = new GlobalScope();
         this.watchFiles = Object.create(null);
@@ -22243,7 +21545,6 @@ class Graph {
         }
         if (this.options.treeshake) {
             let treeshakingPass = 1;
-            this.newlyIncludedVariableInits.clear();
             do {
                 timeStart(`treeshaking pass ${treeshakingPass}`, 3);
                 this.needsTreeshakingPass = false;
@@ -22268,10 +21569,6 @@ class Graph {
                         }
                     }
                 }
-                for (const entity of this.newlyIncludedVariableInits) {
-                    this.newlyIncludedVariableInits.delete(entity);
-                    entity.include(createInclusionContext(), false);
-                }
                 timeEnd(`treeshaking pass ${treeshakingPass++}`, 3);
             } while (this.needsTreeshakingPass);
         }