@rollup/wasm-node 4.25.0-0 → 4.25.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.25.0-0
-	Tue, 29 Oct 2024 06:14:37 GMT - commit b7fcaba12e863db516f39de74c1eacfe5329a5c3
+	Rollup.js v4.25.0
+	Sat, 09 Nov 2024 08:36:52 GMT - commit 42e587e0e37bc0661aa39fe7ad6f1d7fd33f825c
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.25.0-0";
+var version = "4.25.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1379,6 +1379,7 @@ async function mergeOutputOptions(config, overrides, log) {
         sanitizeFileName: getOption('sanitizeFileName'),
         sourcemap: getOption('sourcemap'),
         sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
+        sourcemapDebugIds: getOption('sourcemapDebugIds'),
         sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
         sourcemapFile: getOption('sourcemapFile'),
         sourcemapFileNames: getOption('sourcemapFileNames'),
@@ -3594,7 +3595,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() }
@@ -3619,14 +3620,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, {
@@ -3636,9 +3637,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))
@@ -3647,55 +3648,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, false);
-    }
-    const keys = Object.keys(currentPaths);
-    if (keys.length === 0) {
-        return entity.includePath(basePath, context, false);
-    }
-    for (const key of keys) {
-        includeAllPaths(entity, context, [...basePath, key], currentPaths[key]);
-    }
-}
 
 function isFlagSet(flags, flag) {
     return (flags & flag) !== 0;
@@ -3734,12 +3686,12 @@ class ExpressionEntity {
     hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
         return true;
     }
-    includePath(_path, _context, _includeChildrenRecursively, _options) {
+    include(_context, _includeChildrenRecursively, _options) {
         this.included = true;
     }
-    includeCallArguments(context, interaction) {
-        for (const argument of interaction.args) {
-            argument?.includePath(UNKNOWN_PATH, context, false);
+    includeCallArguments(context, parameters) {
+        for (const argument of parameters) {
+            argument.include(context, false);
         }
     }
     shouldBeIncluded(_context) {
@@ -3854,9 +3806,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
@@ -3888,8 +3840,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;
     }
 }
@@ -4094,208 +4046,6 @@ function markModuleAndImpureDependenciesAsExecuted(baseModule) {
     }
 }
 
-function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
-    return Object.create(inheritedDescriptions, memberDescriptions);
-}
-const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
-    getLiteralValueAtPath() {
-        return undefined;
-    }
-})();
-const returnsUnknown = {
-    value: {
-        hasEffectsWhenCalled: null,
-        returns: UNKNOWN_EXPRESSION
-    }
-};
-const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
-        }
-        return UNKNOWN_RETURN_EXPRESSION;
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (interaction.type === INTERACTION_ACCESSED) {
-            return path.length > 1;
-        }
-        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
-            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], interaction, context);
-        }
-        return true;
-    }
-})();
-const returnsBoolean = {
-    value: {
-        hasEffectsWhenCalled: null,
-        returns: UNKNOWN_LITERAL_BOOLEAN
-    }
-};
-const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
-        }
-        return UNKNOWN_RETURN_EXPRESSION;
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (interaction.type === INTERACTION_ACCESSED) {
-            return path.length > 1;
-        }
-        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
-            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], interaction, context);
-        }
-        return true;
-    }
-})();
-const returnsNumber = {
-    value: {
-        hasEffectsWhenCalled: null,
-        returns: UNKNOWN_LITERAL_NUMBER
-    }
-};
-const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
-        }
-        return UNKNOWN_RETURN_EXPRESSION;
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (interaction.type === INTERACTION_ACCESSED) {
-            return path.length > 1;
-        }
-        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
-            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
-        }
-        return true;
-    }
-})();
-const returnsString = {
-    value: {
-        hasEffectsWhenCalled: null,
-        returns: UNKNOWN_LITERAL_STRING
-    }
-};
-const stringReplace = {
-    value: {
-        hasEffectsWhenCalled({ args }, context) {
-            const argument1 = args[2];
-            return (args.length < 3 ||
-                (typeof argument1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
-                    deoptimizeCache() { }
-                }) === 'symbol' &&
-                    argument1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
-        },
-        returns: UNKNOWN_LITERAL_STRING
-    }
-};
-const objectMembers = assembleMemberDescriptions({
-    hasOwnProperty: returnsBoolean,
-    isPrototypeOf: returnsBoolean,
-    propertyIsEnumerable: returnsBoolean,
-    toLocaleString: returnsString,
-    toString: returnsString,
-    valueOf: returnsUnknown
-});
-const literalBooleanMembers = assembleMemberDescriptions({
-    valueOf: returnsBoolean
-}, objectMembers);
-const literalNumberMembers = assembleMemberDescriptions({
-    toExponential: returnsString,
-    toFixed: returnsString,
-    toLocaleString: returnsString,
-    toPrecision: returnsString,
-    valueOf: returnsNumber
-}, objectMembers);
-/**
- * RegExp are stateful when they have the global or sticky flags set.
- * But if we actually don't use them, the side effect does not matter.
- * the check logic in `hasEffectsOnInteractionAtPath`.
- */
-const literalRegExpMembers = assembleMemberDescriptions({
-    exec: returnsUnknown,
-    test: returnsBoolean
-}, objectMembers);
-const literalStringMembers = assembleMemberDescriptions({
-    anchor: returnsString,
-    at: returnsUnknown,
-    big: returnsString,
-    blink: returnsString,
-    bold: returnsString,
-    charAt: returnsString,
-    charCodeAt: returnsNumber,
-    codePointAt: returnsUnknown,
-    concat: returnsString,
-    endsWith: returnsBoolean,
-    fixed: returnsString,
-    fontcolor: returnsString,
-    fontsize: returnsString,
-    includes: returnsBoolean,
-    indexOf: returnsNumber,
-    italics: returnsString,
-    lastIndexOf: returnsNumber,
-    link: returnsString,
-    localeCompare: returnsNumber,
-    match: returnsUnknown,
-    matchAll: returnsUnknown,
-    normalize: returnsString,
-    padEnd: returnsString,
-    padStart: returnsString,
-    repeat: returnsString,
-    replace: stringReplace,
-    replaceAll: stringReplace,
-    search: returnsNumber,
-    slice: returnsString,
-    small: returnsString,
-    split: returnsUnknown,
-    startsWith: returnsBoolean,
-    strike: returnsString,
-    sub: returnsString,
-    substr: returnsString,
-    substring: returnsString,
-    sup: returnsString,
-    toLocaleLowerCase: returnsString,
-    toLocaleUpperCase: returnsString,
-    toLowerCase: returnsString,
-    toString: returnsString, // overrides the toString() method of the Object object; it does not inherit Object.prototype.toString()
-    toUpperCase: returnsString,
-    trim: returnsString,
-    trimEnd: returnsString,
-    trimLeft: returnsString,
-    trimRight: returnsString,
-    trimStart: returnsString,
-    valueOf: returnsString
-}, objectMembers);
-function getLiteralMembersForValue(value) {
-    if (value instanceof RegExp) {
-        return literalRegExpMembers;
-    }
-    switch (typeof value) {
-        case 'boolean': {
-            return literalBooleanMembers;
-        }
-        case 'number': {
-            return literalNumberMembers;
-        }
-        case 'string': {
-            return literalStringMembers;
-        }
-    }
-    return Object.create(null);
-}
-function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
-    if (typeof memberName !== 'string' || !members[memberName]) {
-        return true;
-    }
-    return members[memberName].hasEffectsWhenCalled?.(interaction, context) || false;
-}
-function getMemberReturnExpressionWhenCalled(members, memberName) {
-    if (typeof memberName !== 'string' || !members[memberName])
-        return UNKNOWN_RETURN_EXPRESSION;
-    return [members[memberName].returns, false];
-}
-
 // This file is generated by scripts/generate-child-node-keys.js.
 // Do not edit this file directly.
 const childNodeKeys = {
@@ -4401,8 +4151,8 @@ function createInclusionContext() {
 }
 function createHasEffectsContext() {
     return {
-        accessed: new EntityPathTracker(),
-        assigned: new EntityPathTracker(),
+        accessed: new PathTracker(),
+        assigned: new PathTracker(),
         brokenFlow: false,
         called: new DiscriminatedPathTracker(),
         hasBreak: false,
@@ -4488,7 +4238,7 @@ class NodeBase extends ExpressionEntity {
         return (this.hasEffects(context) ||
             this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
     }
-    includePath(_path, context, includeChildrenRecursively, _options) {
+    include(context, includeChildrenRecursively, _options) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
@@ -4498,16 +4248,16 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    child?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                    child?.include(context, includeChildrenRecursively);
                 }
             }
             else {
-                value.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                value.include(context, includeChildrenRecursively);
             }
         }
     }
     includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
-        this.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.include(context, includeChildrenRecursively);
     }
     /**
      * Override to perform special initialisation steps after the scope is
@@ -4537,11 +4287,13 @@ class NodeBase extends ExpressionEntity {
                 this[key] = value;
             }
             else if (Array.isArray(value)) {
-                this[key] = [];
+                this[key] = new Array(value.length);
+                let index = 0;
                 for (const child of value) {
-                    this[key].push(child === null
-                        ? null
-                        : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child));
+                    this[key][index++] =
+                        child === null
+                            ? null
+                            : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child);
                 }
             }
             else {
@@ -4553,59 +4305,268 @@ class NodeBase extends ExpressionEntity {
         this.initialise();
         return this;
     }
-    removeAnnotations(code) {
-        if (this.annotations) {
-            for (const annotation of this.annotations) {
-                code.remove(annotation.start, annotation.end);
-            }
+    removeAnnotations(code) {
+        if (this.annotations) {
+            for (const annotation of this.annotations) {
+                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
+    render(code, options) {
+        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?.render(code, options);
+                }
+            }
+            else {
+                value.render(code, options);
+            }
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
+    }
+    shouldBeIncluded(context) {
+        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
+    }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = 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?.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+function createChildNodeKeysForNode(esTreeNode) {
+    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+}
+
+function isObjectExpressionNode(node) {
+    return node instanceof NodeBase && node.type === parseAst_js.ObjectExpression;
+}
+function isPropertyNode(node) {
+    return node.type === parseAst_js.Property;
+}
+
+function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
+    return Object.create(inheritedDescriptions, memberDescriptions);
+}
+const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+})();
+const returnsUnknown = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_EXPRESSION
+    }
+};
+const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsBoolean = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_BOOLEAN
+    }
+};
+const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsNumber = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_NUMBER
+    }
+};
+const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsString = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const stringReplace = {
+    value: {
+        hasEffectsWhenCalled({ args }, context) {
+            const argument1 = args[2];
+            return (args.length < 3 ||
+                (typeof argument1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                    deoptimizeCache() { }
+                }) === 'symbol' &&
+                    argument1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
+        },
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const objectMembers = assembleMemberDescriptions({
+    hasOwnProperty: returnsBoolean,
+    isPrototypeOf: returnsBoolean,
+    propertyIsEnumerable: returnsBoolean,
+    toLocaleString: returnsString,
+    toString: returnsString,
+    valueOf: returnsUnknown
+});
+const literalBooleanMembers = assembleMemberDescriptions({
+    valueOf: returnsBoolean
+}, objectMembers);
+const literalNumberMembers = assembleMemberDescriptions({
+    toExponential: returnsString,
+    toFixed: returnsString,
+    toLocaleString: returnsString,
+    toPrecision: returnsString,
+    valueOf: returnsNumber
+}, objectMembers);
+/**
+ * RegExp are stateful when they have the global or sticky flags set.
+ * But if we actually don't use them, the side effect does not matter.
+ * the check logic in `hasEffectsOnInteractionAtPath`.
+ */
+const literalRegExpMembers = assembleMemberDescriptions({
+    exec: returnsUnknown,
+    test: returnsBoolean
+}, objectMembers);
+const literalStringMembers = assembleMemberDescriptions({
+    anchor: returnsString,
+    at: returnsUnknown,
+    big: returnsString,
+    blink: returnsString,
+    bold: returnsString,
+    charAt: returnsString,
+    charCodeAt: returnsNumber,
+    codePointAt: returnsUnknown,
+    concat: returnsString,
+    endsWith: returnsBoolean,
+    fixed: returnsString,
+    fontcolor: returnsString,
+    fontsize: returnsString,
+    includes: returnsBoolean,
+    indexOf: returnsNumber,
+    italics: returnsString,
+    lastIndexOf: returnsNumber,
+    link: returnsString,
+    localeCompare: returnsNumber,
+    match: returnsUnknown,
+    matchAll: returnsUnknown,
+    normalize: returnsString,
+    padEnd: returnsString,
+    padStart: returnsString,
+    repeat: returnsString,
+    replace: stringReplace,
+    replaceAll: stringReplace,
+    search: returnsNumber,
+    slice: returnsString,
+    small: returnsString,
+    split: returnsUnknown,
+    startsWith: returnsBoolean,
+    strike: returnsString,
+    sub: returnsString,
+    substr: returnsString,
+    substring: returnsString,
+    sup: returnsString,
+    toLocaleLowerCase: returnsString,
+    toLocaleUpperCase: returnsString,
+    toLowerCase: returnsString,
+    toString: returnsString, // overrides the toString() method of the Object object; it does not inherit Object.prototype.toString()
+    toUpperCase: returnsString,
+    trim: returnsString,
+    trimEnd: returnsString,
+    trimLeft: returnsString,
+    trimRight: returnsString,
+    trimStart: returnsString,
+    valueOf: returnsString
+}, objectMembers);
+function getLiteralMembersForValue(value) {
+    if (value instanceof RegExp) {
+        return literalRegExpMembers;
+    }
+    switch (typeof value) {
+        case 'boolean': {
+            return literalBooleanMembers;
         }
-    }
-    render(code, options) {
-        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?.render(code, options);
-                }
-            }
-            else {
-                value.render(code, options);
-            }
+        case 'number': {
+            return literalNumberMembers;
         }
-    }
-    setAssignedValue(value) {
-        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
-    }
-    shouldBeIncluded(context) {
-        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
-    }
-    /**
-     * Just deoptimize everything by default so that when e.g. we do not track
-     * something properly, it is deoptimized.
-     * @protected
-     */
-    applyDeoptimizations() {
-        this.deoptimized = 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?.deoptimizePath(UNKNOWN_PATH);
-                }
-            }
-            else {
-                value.deoptimizePath(UNKNOWN_PATH);
-            }
+        case 'string': {
+            return literalStringMembers;
         }
-        this.scope.context.requestTreeshakingPass();
     }
+    return Object.create(null);
 }
-function createChildNodeKeysForNode(esTreeNode) {
-    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
+    if (typeof memberName !== 'string' || !members[memberName]) {
+        return true;
+    }
+    return members[memberName].hasEffectsWhenCalled?.(interaction, context) || false;
+}
+function getMemberReturnExpressionWhenCalled(members, memberName) {
+    if (typeof memberName !== 'string' || !members[memberName])
+        return UNKNOWN_RETURN_EXPRESSION;
+    return [members[memberName].returns, false];
 }
 
 class SpreadElement extends NodeBase {
@@ -4758,7 +4719,6 @@ class ObjectEntity extends ExpressionEntity {
         this.unknownIntegerProps = [];
         this.unmatchableGetters = [];
         this.unmatchablePropertiesAndGetters = [];
-        this.unmatchablePropertiesAndSetters = [];
         this.unmatchableSetters = [];
         if (Array.isArray(properties)) {
             this.buildPropertyMaps(properties);
@@ -4993,37 +4953,9 @@ class ObjectEntity extends ExpressionEntity {
         }
         return false;
     }
-    includePath(path, context, includeChildrenRecursively) {
-        this.included = true;
-        const [key, ...subPath] = path;
-        if (key == null || includeChildrenRecursively) {
-            for (const property of this.allProperties) {
-                if (includeChildrenRecursively || property.shouldBeIncluded(context)) {
-                    property.includePath(EMPTY_PATH, context, includeChildrenRecursively);
-                }
-            }
-            this.prototypeExpression?.includePath(EMPTY_PATH, context, includeChildrenRecursively);
-        }
-        else {
-            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, includeChildrenRecursively);
-            }
-            this.prototypeExpression?.includePath(path, context, includeChildrenRecursively);
-        }
-    }
     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);
@@ -5594,7 +5526,29 @@ const knownGlobals = {
         resolve: O
     },
     propertyIsEnumerable: O,
-    Proxy: O,
+    Proxy: {
+        __proto__: null,
+        [ValueProperties]: {
+            deoptimizeArgumentsOnCall: ({ args: [, target, parameter] }) => {
+                if (isObjectExpressionNode(parameter)) {
+                    const hasSpreadElement = parameter.properties.some(property => !isPropertyNode(property));
+                    if (!hasSpreadElement) {
+                        for (const property of parameter.properties) {
+                            property.deoptimizeArgumentsOnInteractionAtPath({
+                                args: [null, target],
+                                type: INTERACTION_CALLED,
+                                withNew: false
+                            }, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+                        }
+                        return;
+                    }
+                }
+                target.deoptimizePath(UNKNOWN_PATH);
+            },
+            getLiteralValue: getTruthyLiteralValue,
+            hasEffectsWhenCalled: returnTrue
+        }
+    },
     RangeError: PC,
     ReferenceError: PC,
     Reflect: O,
@@ -6359,20 +6313,16 @@ class GlobalVariable extends Variable {
 }
 
 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);
@@ -6383,6 +6333,7 @@ class LocalVariable extends Variable {
             for (const initializer of this.additionalInitializers) {
                 initializer.deoptimizePath(UNKNOWN_PATH);
             }
+            this.additionalInitializers = null;
         }
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
@@ -6390,7 +6341,7 @@ class LocalVariable extends Variable {
             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 ||
@@ -6404,10 +6355,10 @@ 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([...this.initPath, ...path]);
+            this.init.deoptimizePath(path);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
@@ -6416,7 +6367,7 @@ class LocalVariable extends Variable {
         }
         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) {
@@ -6425,7 +6376,7 @@ class LocalVariable extends Variable {
         }
         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) {
@@ -6434,7 +6385,7 @@ class LocalVariable extends Variable {
                 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)
@@ -6444,23 +6395,23 @@ 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)) {
-            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.includePath(EMPTY_PATH, 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
@@ -6471,26 +6422,17 @@ class LocalVariable extends Variable {
                     node = node.parent;
                 }
             }
-            // We need to make sure we include the correct path of the init
-            if (path.length > 0) {
-                this.init.includePath([...this.initPath, ...path], context, false);
-                this.additionalInitializers?.forEach(initializer => initializer.includePath(UNKNOWN_PATH, context, false));
-            }
         }
     }
-    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) {
-                argument?.includePath(UNKNOWN_PATH, 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);
         }
     }
@@ -6570,21 +6512,18 @@ class IdentifierBase extends NodeBase {
             }
         }
     }
-    includePath(path, context) {
+    include() {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (!this.included) {
             this.included = true;
             if (this.variable !== null) {
-                this.scope.context.includeVariableInModule(this.variable, path);
+                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
@@ -6684,17 +6623,39 @@ class Identifier extends IdentifierBase {
             this.isVariableReference = true;
         }
     }
-    declare(kind, includedInitPath, init) {
+    declare(kind, init) {
         let variable;
         const { treeshake } = this.scope.context.options;
-        if (kind === 'parameter') {
-            variable = this.scope.addParameterDeclaration(this, includedInitPath);
-        }
-        else {
-            variable = this.scope.addDeclaration(this, this.scope.context, init, includedInitPath, 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;
+            }
+            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}.`);
             }
         }
         return [(this.variable = variable)];
@@ -6751,17 +6712,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, includedInitPath, 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, includedInitPath, context, kind);
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
         this.variables.set(name, newVariable);
         return newVariable;
     }
@@ -6963,7 +6925,7 @@ class BlockScope extends ChildScope {
     constructor(parent) {
         super(parent, parent.context);
     }
-    addDeclaration(identifier, context, init, includedInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
@@ -6975,7 +6937,7 @@ class BlockScope extends ChildScope {
                 }
                 return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
             }
-            const declaredVariable = this.parent.addDeclaration(identifier, context, init, includedInitPath, 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();
@@ -6983,7 +6945,7 @@ class BlockScope extends ChildScope {
             this.addHoistedVariable(name, declaredVariable);
             return declaredVariable;
         }
-        return super.addDeclaration(identifier, context, init, includedInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -6998,11 +6960,11 @@ class StaticBlock extends NodeBase {
         }
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         for (const node of this.body) {
             if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                node.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                node.include(context, includeChildrenRecursively);
         }
     }
     render(code, options) {
@@ -7081,22 +7043,22 @@ class ClassNode extends NodeBase {
                 false
             : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        this.superClass?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-        this.body.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.superClass?.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
         for (const decorator of this.decorators)
-            decorator.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+            decorator.include(context, includeChildrenRecursively);
         if (this.id) {
             this.id.markDeclarationReached();
-            this.id.includePath(UNKNOWN_PATH, createInclusionContext());
+            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;
@@ -7211,7 +7173,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) {
@@ -7225,8 +7187,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);
         }
@@ -7237,28 +7199,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);
                 }
@@ -7268,30 +7229,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) {
-                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();
@@ -7308,7 +7266,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
@@ -7324,7 +7282,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();
         }
@@ -7346,25 +7304,20 @@ class ParameterVariable extends LocalVariable {
             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) {
+        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) ||
@@ -7373,10 +7326,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
@@ -7397,17 +7350,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) {
@@ -7422,14 +7375,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);
@@ -7441,7 +7391,7 @@ class CatchBodyScope extends ChildScope {
         super(parent, parent.context);
         this.parent = parent;
     }
-    addDeclaration(identifier, context, init, includedInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         if (kind === 'var') {
             const name = identifier.name;
             const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
@@ -7454,7 +7404,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, includedInitPath, 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
@@ -7473,7 +7423,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, includedInitPath, 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();
@@ -7481,7 +7431,7 @@ class CatchBodyScope extends ChildScope {
             this.addHoistedVariable(name, declaredVariable);
             return declaredVariable;
         }
-        return super.addDeclaration(identifier, context, init, includedInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -7491,7 +7441,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, includedInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         const name = identifier.name;
         const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
         if (existingVariable) {
@@ -7503,7 +7453,7 @@ class FunctionBodyScope extends ChildScope {
             }
             context.error(parseAst_js.logRedeclarationError(name), identifier.start);
         }
-        const newVariable = new LocalVariable(identifier.name, identifier, init, includedInitPath, context, kind);
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
         this.variables.set(name, newVariable);
         return newVariable;
     }
@@ -7512,21 +7462,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
@@ -7544,54 +7494,43 @@ 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++) {
-            if (args[argumentIndex] instanceof SpreadElement && !argumentIncluded) {
-                argumentIncluded = true;
-                lastExplicitlyIncludedIndex = argumentIndex - 1;
-            }
-            if (argumentIncluded) {
-                args[argumentIndex].includePath(UNKNOWN_PATH, 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.includePath(UNKNOWN_PATH, context, true);
-                            }
-                            else {
-                                variable.includeArgumentPaths(argument, context);
-                            }
+                        }
+                        if (variable.calledFromTryStatement) {
+                            calledFromTryStatement = true;
                         }
                     }
                 }
             }
-            if (!argument.included && (argumentIncluded || argument.shouldBeIncluded(context))) {
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
                 argumentIncluded = true;
-                argument.includePath(EMPTY_PATH, context, calledFromTryStatement);
+            }
+            if (argumentIncluded) {
+                argument.include(context, calledFromTryStatement);
             }
         }
     }
@@ -7606,61 +7545,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);
-            }
-        }
-        for (; position < parameters.length; 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];
@@ -7676,26 +7565,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++) {
-                args[argumentIndex]?.includePath(UNKNOWN_PATH, context, false);
+            for (const argument of parameters) {
+                if (!argument.included) {
+                    argument.include(context, false);
+                }
             }
         }
     }
-    addArgumentToBeDeoptimized(argument) {
-        this.argumentsVariable.addArgumentToBeDeoptimized(argument);
-    }
 }
 
 class ExpressionStatement extends NodeBase {
@@ -7761,7 +7648,7 @@ class BlockStatement extends NodeBase {
         }
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!(this.deoptimizeBody && this.directlyIncluded)) {
             this.included = true;
             this.directlyIncluded = true;
@@ -7769,7 +7656,7 @@ class BlockStatement extends NodeBase {
                 includeChildrenRecursively = true;
             for (const node of this.body) {
                 if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                    node.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                    node.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -7798,9 +7685,9 @@ class RestElement extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         this.argument.addExportedVariables(variables, exportNamesByVariable);
     }
-    declare(kind, includedInitPath, init) {
+    declare(kind, init) {
         this.declarationInit = init;
-        return this.argument.declare(kind, includedInitPath.at(-1) === UnknownKey ? includedInitPath : [...includedInitPath, UnknownKey], init);
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
     }
     deoptimizePath(path) {
         if (path.length === 0) {
@@ -7811,12 +7698,6 @@ class RestElement extends NodeBase {
         return (path.length > 0 ||
             this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
     }
-    includePath(_path, context, includeChildrenRecursively) {
-        this.included = true;
-        // This should just include the identifier, its properties should be
-        // included where the variable is used.
-        this.argument.includePath(EMPTY_PATH, context, includeChildrenRecursively);
-    }
     markDeclarationReached() {
         this.argument.markDeclarationReached();
     }
@@ -7832,8 +7713,8 @@ class RestElement extends NodeBase {
 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 */);
@@ -7853,9 +7734,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);
@@ -7867,7 +7792,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) {
@@ -7924,19 +7854,22 @@ class FunctionBase extends NodeBase {
         }
         return variable?.getOnlyFunctionCallUsed() ?? false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
-        if (!(this.parameterVariableValuesDeoptimized || this.onlyFunctionCallUsed())) {
+    include(context, includeChildrenRecursively) {
+        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.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
         context.brokenFlow = brokenFlow;
     }
+    includeCallArguments(context, parameters) {
+        this.scope.includeCallArguments(context, parameters);
+    }
     initialise() {
         super.initialise();
         if (this.body instanceof BlockStatement) {
@@ -7958,10 +7891,11 @@ 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;
@@ -7976,13 +7910,13 @@ 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) {
@@ -8023,19 +7957,22 @@ class FunctionNode extends FunctionBase {
         }
         return false;
     }
-    includePath(path, context, includeChildrenRecursively) {
-        super.includePath(path, context, includeChildrenRecursively);
-        this.id?.includePath(UNKNOWN_PATH, createInclusionContext());
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        this.id?.include();
         const hasArguments = this.scope.argumentsVariable.included;
         for (const parameter of this.params) {
             if (!(parameter instanceof Identifier) || hasArguments) {
-                parameter.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                parameter.include(context, includeChildrenRecursively);
             }
         }
     }
     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) {
@@ -8084,11 +8021,10 @@ function getFunctionIdInsertPosition(code, start) {
     return declarationEnd + generatorStarPos + 1;
 }
 class ExportDefaultDeclaration extends NodeBase {
-    includePath(path, context, includeChildrenRecursively) {
-        this.included = true;
-        this.declaration.includePath(path, context, includeChildrenRecursively);
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively) {
-            this.scope.context.includeVariableInModule(this.variable, path);
+            this.scope.context.includeVariableInModule(this.variable);
         }
     }
     initialise() {
@@ -8661,27 +8597,27 @@ class MemberExpression extends NodeBase {
         }
         return true;
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        this.includeProperties(path, [this.getPropertyKey(), ...path], context, includeChildrenRecursively);
+        this.includeProperties(context, includeChildrenRecursively);
     }
     includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
         if (!this.assignmentDeoptimized)
             this.applyAssignmentDeoptimization();
         if (deoptimizeAccess) {
-            this.includePath([this.getPropertyKey()], context, includeChildrenRecursively);
+            this.include(context, includeChildrenRecursively);
         }
         else {
-            this.includeProperties(EMPTY_PATH, [this.getPropertyKey()], 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);
+            super.includeCallArguments(context, parameters);
         }
     }
     initialise() {
@@ -8750,7 +8686,7 @@ 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);
+                    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);
             }
@@ -8777,18 +8713,15 @@ class MemberExpression extends NodeBase {
             (propertyReadSideEffects === 'always' ||
                 this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
     }
-    includeProperties(includedPath, objectPath, context, includeChildrenRecursively) {
+    includeProperties(context, includeChildrenRecursively) {
         if (!this.included) {
             this.included = true;
             if (this.variable) {
-                this.scope.context.includeVariableInModule(this.variable, includedPath);
+                this.scope.context.includeVariableInModule(this.variable);
             }
         }
-        else if (includedPath.length > 0) {
-            this.variable?.includePath(includedPath, context);
-        }
-        this.object.includePath(objectPath, context, includeChildrenRecursively);
-        this.property.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
     }
 }
 function resolveNamespaceVariables(baseVariable, path, astContext) {
@@ -8831,7 +8764,7 @@ class MetaProperty extends NodeBase {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return path.length > 1 || type !== INTERACTION_ACCESSED;
     }
-    includePath() {
+    include() {
         if (!this.included) {
             this.included = true;
             if (this.meta.name === IMPORT) {
@@ -8950,7 +8883,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;
@@ -9099,8 +9032,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) {
@@ -9193,9 +9126,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);
+    include() {
+        super.include();
+        this.context.includeVariableInModule(this.syntheticNamespace);
     }
     setRenderNames(baseName, name) {
         super.setRenderNames(baseName, name);
@@ -9722,14 +9655,16 @@ function getImportBlock(dependencies, importAttributesKey, { _ }) {
 }
 function getExportBlock(exports, { _, cnst }) {
     const exportBlock = [];
-    const exportDeclaration = [];
+    const exportDeclaration = new Array(exports.length);
+    let index = 0;
     for (const specifier of exports) {
         if (specifier.expression) {
             exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
         }
-        exportDeclaration.push(specifier.exported === specifier.local
-            ? specifier.local
-            : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
+        exportDeclaration[index++] =
+            specifier.exported === specifier.local
+                ? specifier.local
+                : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`;
     }
     if (exportDeclaration.length > 0) {
         exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
@@ -12392,14 +12327,11 @@ class ArrayPattern extends NodeBase {
             element?.addExportedVariables(variables, exportNamesByVariable);
         }
     }
-    declare(kind, includedInitPath, init) {
+    declare(kind) {
         const variables = [];
-        const includedPatternPath = includedInitPath.at(-1) === UnknownKey
-            ? includedInitPath
-            : [...includedInitPath, UnknownInteger];
         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;
@@ -12472,11 +12404,11 @@ class ArrowFunctionExpression extends FunctionBase {
             this.parent.callee === this;
         return isIIFE || super.onlyFunctionCallUsed();
     }
-    includePath(_path, context, includeChildrenRecursively) {
-        super.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
         for (const parameter of this.params) {
             if (!(parameter instanceof Identifier)) {
-                parameter.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                parameter.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -12499,10 +12431,10 @@ class ObjectPattern extends NodeBase {
             }
         }
     }
-    declare(kind, includedInitPath, init) {
+    declare(kind, init) {
         const variables = [];
         for (const property of this.properties) {
-            variables.push(...property.declare(kind, includedInitPath, init));
+            variables.push(...property.declare(kind, init));
         }
         return variables;
     }
@@ -12523,22 +12455,11 @@ class ObjectPattern extends NodeBase {
         }
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
-        this.included = true;
-        for (const property of this.properties) {
-            // Including a pattern should not deeply include its children as that
-            // would include all children of nested variable references. Their paths
-            // will be included via their usages instead, and we store the path in
-            // the pattern when declaring the variables.
-            property.includePath(EMPTY_PATH, context, includeChildrenRecursively);
-        }
-    }
     markDeclarationReached() {
         for (const property of this.properties) {
             property.markDeclarationReached();
         }
     }
-    applyDeoptimizations() { }
 }
 
 class AssignmentExpression extends NodeBase {
@@ -12553,7 +12474,7 @@ class AssignmentExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         const { deoptimized, left, right, operator } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
@@ -12564,7 +12485,7 @@ class AssignmentExpression extends NodeBase {
             left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
             left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
         }
-        right.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        right.include(context, includeChildrenRecursively);
     }
     initialise() {
         super.initialise();
@@ -12636,8 +12557,8 @@ class AssignmentPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         this.left.addExportedVariables(variables, exportNamesByVariable);
     }
-    declare(kind, includedInitPath, init) {
-        return this.left.declare(kind, includedInitPath, init);
+    declare(kind, init) {
+        return this.left.declare(kind, init);
     }
     deoptimizePath(path) {
         if (path.length === 0) {
@@ -12668,7 +12589,7 @@ class AwaitExpression extends NodeBase {
             this.applyDeoptimizations();
         return true;
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (!this.included) {
@@ -12682,7 +12603,7 @@ class AwaitExpression extends NodeBase {
                 this.scope.context.usesTopLevelAwait = true;
             }
         }
-        this.argument.includePath(path, context, includeChildrenRecursively);
+        this.argument.include(context, includeChildrenRecursively);
     }
 }
 
@@ -12764,10 +12685,10 @@ class BreakStatement extends NodeBase {
         context.brokenFlow = true;
         return false;
     }
-    includePath(_, context) {
+    include(context) {
         this.included = true;
         if (this.label) {
-            this.label.includePath(UNKNOWN_PATH, createInclusionContext());
+            this.label.include();
             context.includedLabels.add(this.label.name);
         }
         else {
@@ -12961,11 +12882,11 @@ class CallExpression extends CallExpressionBase {
             (calleeHasEffects ||
                 this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context)));
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (includeChildrenRecursively) {
-            super.includePath(path, context, includeChildrenRecursively);
+            super.include(context, includeChildrenRecursively);
             if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
                 this.callee instanceof Identifier &&
                 this.callee.variable) {
@@ -12974,18 +12895,9 @@ class CallExpression extends CallExpressionBase {
         }
         else {
             this.included = true;
-            // 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.includePath(UNKNOWN_PATH, context, false);
-            }
-            else {
-                this.callee.includePath(UNKNOWN_PATH, context, false);
-            }
-            this.callee.includeCallArguments(context, this.interaction);
+            this.callee.include(context, false);
         }
+        this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
         super.initialise();
@@ -13024,7 +12936,7 @@ 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);
@@ -13052,7 +12964,7 @@ 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));
     }
@@ -13065,17 +12977,18 @@ class ClassBody extends NodeBase {
     createScope(parentScope) {
         this.scope = new ClassBodyScope(parentScope, this.parent);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.scope.context.includeVariableInModule(this.scope.thisVariable, UNKNOWN_PATH);
+        this.scope.context.includeVariableInModule(this.scope.thisVariable);
         for (const definition of this.body) {
-            definition.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+            definition.include(context, includeChildrenRecursively);
         }
     }
     parseNode(esTreeNode) {
-        const body = (this.body = []);
+        const body = (this.body = new Array(esTreeNode.body.length));
+        let index = 0;
         for (const definition of esTreeNode.body) {
-            body.push(new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition));
+            body[index++] = new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition);
         }
         return super.parseNode(esTreeNode);
     }
@@ -13192,26 +13105,26 @@ class ConditionalExpression extends NodeBase {
         }
         return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         const usedBranch = this.getUsedBranch();
         if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
-            this.test.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-            this.consequent.includePath(path, context, includeChildrenRecursively);
-            this.alternate.includePath(path, context, includeChildrenRecursively);
+            this.test.include(context, includeChildrenRecursively);
+            this.consequent.include(context, includeChildrenRecursively);
+            this.alternate.include(context, includeChildrenRecursively);
         }
         else {
-            usedBranch.includePath(path, context, includeChildrenRecursively);
+            usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    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) {
@@ -13272,10 +13185,10 @@ class ContinueStatement extends NodeBase {
         context.brokenFlow = true;
         return false;
     }
-    includePath(_, context) {
+    include(context) {
         this.included = true;
         if (this.label) {
-            this.label.includePath(UNKNOWN_PATH, createInclusionContext());
+            this.label.include();
             context.includedLabels.add(this.label.name);
         }
         else {
@@ -13318,7 +13231,7 @@ function includeLoopBody(context, body, includeChildrenRecursively) {
     const { brokenFlow, hasBreak, hasContinue } = context;
     context.hasBreak = false;
     context.hasContinue = false;
-    body.includePath(UNKNOWN_PATH, context, includeChildrenRecursively, { asSingleStatement: true });
+    body.include(context, includeChildrenRecursively, { asSingleStatement: true });
     context.hasBreak = hasBreak;
     context.hasContinue = hasContinue;
     context.brokenFlow = brokenFlow;
@@ -13330,9 +13243,9 @@ class DoWhileStatement extends NodeBase {
             return true;
         return hasLoopBodyEffects(context, this.body);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.test.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.test.include(context, includeChildrenRecursively);
         includeLoopBody(context, this.body, includeChildrenRecursively);
     }
 }
@@ -13403,13 +13316,13 @@ class ForInStatement extends NodeBase {
             return true;
         return hasLoopBodyEffects(context, body);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         const { body, deoptimized, left, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
         left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
-        right.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        right.include(context, includeChildrenRecursively);
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
@@ -13448,13 +13361,13 @@ class ForOfStatement extends NodeBase {
         // Placeholder until proper Symbol.Iterator support
         return true;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         const { body, deoptimized, left, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
         left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
-        right.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        right.include(context, includeChildrenRecursively);
         includeLoopBody(context, body, includeChildrenRecursively);
     }
     initialise() {
@@ -13490,13 +13403,11 @@ class ForStatement extends NodeBase {
         }
         return hasLoopBodyEffects(context, this.body);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.init?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively, {
-            asSingleStatement: true
-        });
-        this.test?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-        this.update?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        this.test?.include(context, includeChildrenRecursively);
+        this.update?.include(context, includeChildrenRecursively);
         includeLoopBody(context, this.body, includeChildrenRecursively);
     }
     render(code, options) {
@@ -13537,9 +13448,9 @@ class TrackingScope extends BlockScope {
         super(...arguments);
         this.hoistedDeclarations = [];
     }
-    addDeclaration(identifier, context, init, includedInitPath, kind) {
+    addDeclaration(identifier, context, init, kind) {
         this.hoistedDeclarations.push(identifier);
-        return super.addDeclaration(identifier, context, init, includedInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -13572,7 +13483,7 @@ class IfStatement extends NodeBase {
         }
         return testValue ? this.consequent.hasEffects(context) : !!this.alternate?.hasEffects(context);
     }
-    includePath(_, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         if (includeChildrenRecursively) {
             this.includeRecursively(includeChildrenRecursively, context);
@@ -13647,31 +13558,31 @@ class IfStatement extends NodeBase {
     }
     includeKnownTest(context, testValue) {
         if (this.test.shouldBeIncluded(context)) {
-            this.test.includePath(UNKNOWN_PATH, context, false);
+            this.test.include(context, false);
         }
         if (testValue && this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includePath(UNKNOWN_PATH, context, false, { asSingleStatement: true });
+            this.consequent.include(context, false, { asSingleStatement: true });
         }
         if (!testValue && this.alternate?.shouldBeIncluded(context)) {
-            this.alternate.includePath(UNKNOWN_PATH, context, false, { asSingleStatement: true });
+            this.alternate.include(context, false, { asSingleStatement: true });
         }
     }
     includeRecursively(includeChildrenRecursively, context) {
-        this.test.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-        this.consequent.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-        this.alternate?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.test.include(context, includeChildrenRecursively);
+        this.consequent.include(context, includeChildrenRecursively);
+        this.alternate?.include(context, includeChildrenRecursively);
     }
     includeUnknownTest(context) {
-        this.test.includePath(UNKNOWN_PATH, context, false);
+        this.test.include(context, false);
         const { brokenFlow } = context;
         let consequentBrokenFlow = false;
         if (this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includePath(UNKNOWN_PATH, context, false, { asSingleStatement: true });
+            this.consequent.include(context, false, { asSingleStatement: true });
             consequentBrokenFlow = context.brokenFlow;
             context.brokenFlow = brokenFlow;
         }
         if (this.alternate?.shouldBeIncluded(context)) {
-            this.alternate.includePath(UNKNOWN_PATH, context, false, { asSingleStatement: true });
+            this.alternate.include(context, false, { asSingleStatement: true });
             context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
         }
     }
@@ -13739,7 +13650,7 @@ 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);
@@ -13751,15 +13662,15 @@ class VariableDeclarator extends NodeBase {
         this.id.markDeclarationReached();
         return initEffect || this.id.hasEffects(context) || this.isUsingDeclaration;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         const { deoptimized, id, init } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        init?.includePath(EMPTY_PATH, context, includeChildrenRecursively);
+        init?.include(context, includeChildrenRecursively);
         id.markDeclarationReached();
         if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
-            id.includePath(EMPTY_PATH, context, includeChildrenRecursively);
+            id.include(context, includeChildrenRecursively);
         }
     }
     removeAnnotations(code) {
@@ -13808,8 +13719,6 @@ 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;
@@ -13842,15 +13751,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) {
@@ -13899,23 +13805,13 @@ class ImportExpression extends NodeBase {
     hasEffects() {
         return true;
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.included) {
             this.included = true;
             this.scope.context.includeDynamicImport(this);
             this.scope.addAccessedDynamicImport(this);
-            this.source.includePath(path, context, includeChildrenRecursively);
-        }
-        if (this.hasUnknownAccessedKey)
-            return;
-        if (path[0] === UnknownKey) {
-            this.hasUnknownAccessedKey = true;
-            this.scope.context.includeDynamicImport(this);
-        }
-        else if (typeof path[0] === 'string') {
-            this.accessedPropKey.add(path[0]);
-            this.scope.context.includeDynamicImport(this);
         }
+        this.source.include(context, includeChildrenRecursively);
     }
     initialise() {
         super.initialise();
@@ -14243,7 +14139,7 @@ function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
         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, createInclusionContext());
+            globalVariable.include();
             // This excludes this variable from renaming
             factoryVariable.globalName = baseName;
         }
@@ -14251,7 +14147,7 @@ function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
     else {
         factoryVariable = node.scope.findGlobal(baseName);
     }
-    node.scope.context.includeVariableInModule(factoryVariable, UNKNOWN_PATH);
+    node.scope.context.includeVariableInModule(factoryVariable);
     if (factoryVariable instanceof LocalVariable) {
         factoryVariable.consolidateInitializers();
         factoryVariable.addUsedPlace(node);
@@ -14273,7 +14169,7 @@ class JSXElementBase extends NodeBase {
             this.scope.context.addImportSource(importSource);
         }
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.included) {
             const { factory, importSource, mode } = this.jsxMode;
             if (factory) {
@@ -14281,7 +14177,7 @@ class JSXElementBase extends NodeBase {
                 this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this);
             }
         }
-        super.includePath(path, context, includeChildrenRecursively);
+        super.include(context, includeChildrenRecursively);
     }
     applyDeoptimizations() { }
     getRenderingMode() {
@@ -14543,7 +14439,7 @@ class JSXOpeningFragment extends NodeBase {
         this.fragment = null;
         this.fragmentVariable = null;
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.included) {
             const jsx = this.scope.context.options.jsx;
             if (jsx.mode === 'automatic') {
@@ -14558,7 +14454,7 @@ class JSXOpeningFragment extends NodeBase {
                 }
             }
         }
-        super.includePath(path, context, includeChildrenRecursively);
+        super.include(context, includeChildrenRecursively);
     }
     render(code, options) {
         const { mode } = this.scope.context.options.jsx;
@@ -14615,13 +14511,13 @@ class LabeledStatement extends NodeBase {
         context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
         return bodyHasEffects;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         const { brokenFlow, includedLabels } = context;
         context.includedLabels = new Set();
-        this.body.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively || context.includedLabels.has(this.label.name)) {
-            this.label.includePath(UNKNOWN_PATH, createInclusionContext());
+            this.label.include();
             context.includedLabels.delete(this.label.name);
             context.brokenFlow = brokenFlow;
         }
@@ -14718,17 +14614,17 @@ class LogicalExpression extends NodeBase {
         }
         return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         const usedBranch = this.getUsedBranch();
         if (includeChildrenRecursively ||
             (usedBranch === this.right && this.left.shouldBeIncluded(context)) ||
             !usedBranch) {
-            this.left.includePath(path, context, includeChildrenRecursively);
-            this.right.includePath(path, context, includeChildrenRecursively);
+            this.left.include(context, includeChildrenRecursively);
+            this.right.include(context, includeChildrenRecursively);
         }
         else {
-            usedBranch.includePath(path, context, includeChildrenRecursively);
+            usedBranch.include(context, includeChildrenRecursively);
         }
     }
     removeAnnotations(code) {
@@ -14800,17 +14696,17 @@ class NewExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return path.length > 0 || type !== INTERACTION_ACCESSED;
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (includeChildrenRecursively) {
-            super.includePath(path, context, includeChildrenRecursively);
+            super.include(context, includeChildrenRecursively);
         }
         else {
             this.included = true;
-            this.callee.includePath(UNKNOWN_PATH, context, false);
+            this.callee.include(context, false);
         }
-        this.callee.includeCallArguments(context, this.interaction);
+        this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
         super.initialise();
@@ -14839,7 +14735,6 @@ class ObjectExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.objectEntity = null;
-        this.protoProp = null;
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -14859,32 +14754,13 @@ class ObjectExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(path, context, includeChildrenRecursively) {
-        this.included = true;
-        this.getObjectEntity().includePath(path, context, includeChildrenRecursively);
-        this.protoProp?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-    }
     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() {
@@ -14915,7 +14791,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
@@ -14982,11 +14857,11 @@ class Program extends NodeBase {
         }
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         for (const node of this.body) {
             if (includeChildrenRecursively || node.shouldBeIncluded(context)) {
-                node.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                node.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -15025,6 +14900,10 @@ class Program extends NodeBase {
 }
 
 class Property extends MethodBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
     //declare method: boolean;
     get method() {
         return isFlagSet(this.flags, 262144 /* Flag.method */);
@@ -15039,17 +14918,9 @@ class Property extends MethodBase {
     set shorthand(value) {
         this.flags = setFlag(this.flags, 524288 /* Flag.shorthand */, value);
     }
-    declare(kind, includedInitPath, init) {
-        const pathInProperty = includedInitPath.at(-1) === UnknownKey
-            ? includedInitPath
-            : // For now, we only consider static path as we do not know how to
-                // deoptimize the path in the dynamic case.
-                this.computed
-                    ? [...includedInitPath, UnknownKey]
-                    : this.key instanceof Identifier
-                        ? [...includedInitPath, this.key.name]
-                        : [...includedInitPath, String(this.key.value)];
-        return this.value.declare(kind, pathInProperty, init);
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.value.declare(kind, UNKNOWN_EXPRESSION);
     }
     hasEffects(context) {
         if (!this.deoptimized)
@@ -15059,11 +14930,6 @@ class Property extends MethodBase {
             this.key.hasEffects(context) ||
             this.value.hasEffects(context));
     }
-    includePath(path, context, includeChildrenRecursively) {
-        this.included = true;
-        this.key.includePath(EMPTY_PATH, context, includeChildrenRecursively);
-        this.value.includePath(path, context, includeChildrenRecursively);
-    }
     markDeclarationReached() {
         this.value.markDeclarationReached();
     }
@@ -15073,7 +14939,13 @@ class Property extends MethodBase {
         }
         this.value.render(code, options, { isShorthandProperty: this.shorthand });
     }
-    applyDeoptimizations() { }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
 }
 
 class PropertyDefinition extends NodeBase {
@@ -15117,9 +14989,9 @@ class ReturnStatement extends NodeBase {
         context.brokenFlow = true;
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.argument?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.argument?.include(context, includeChildrenRecursively);
         context.brokenFlow = true;
     }
     initialise() {
@@ -15156,14 +15028,14 @@ class SequenceExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.expressions[this.expressions.length - 1].hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
         const lastExpression = this.expressions[this.expressions.length - 1];
         for (const expression of this.expressions) {
             if (includeChildrenRecursively ||
                 (expression === lastExpression && !(this.parent instanceof ExpressionStatement)) ||
                 expression.shouldBeIncluded(context))
-                expression.includePath(path, context, includeChildrenRecursively);
+                expression.include(context, includeChildrenRecursively);
         }
     }
     removeAnnotations(code) {
@@ -15211,13 +15083,10 @@ class Super extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
-    includePath(path, context) {
+    include() {
         if (!this.included) {
             this.included = true;
-            this.scope.context.includeVariableInModule(this.variable, path);
-        }
-        else if (path.length > 0) {
-            this.variable.includePath(path, context);
+            this.scope.context.includeVariableInModule(this.variable);
         }
     }
 }
@@ -15234,12 +15103,12 @@ class SwitchCase extends NodeBase {
         }
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.test?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.test?.include(context, includeChildrenRecursively);
         for (const node of this.consequent) {
             if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                node.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                node.include(context, includeChildrenRecursively);
         }
     }
     render(code, options, nodeRenderOptions) {
@@ -15287,9 +15156,9 @@ class SwitchStatement extends NodeBase {
         context.hasBreak = hasBreak;
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.discriminant.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.discriminant.include(context, includeChildrenRecursively);
         const { brokenFlow, hasBreak } = context;
         context.hasBreak = false;
         let onlyHasBrokenFlow = true;
@@ -15306,7 +15175,7 @@ class SwitchStatement extends NodeBase {
                 isCaseIncluded = switchCase.hasEffects(hasEffectsContext);
             }
             if (isCaseIncluded) {
-                switchCase.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                switchCase.include(context, includeChildrenRecursively);
                 onlyHasBrokenFlow &&= context.brokenFlow && !context.hasBreak;
                 context.hasBreak = false;
                 context.brokenFlow = brokenFlow;
@@ -15363,21 +15232,21 @@ class TaggedTemplateExpression extends CallExpressionBase {
         return (this.tag.hasEffects(context) ||
             this.tag.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
     }
-    includePath(path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (includeChildrenRecursively) {
-            super.includePath(path, context, includeChildrenRecursively);
+            super.include(context, includeChildrenRecursively);
         }
         else {
             this.included = true;
-            this.tag.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
-            this.quasi.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+            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.includePath(UNKNOWN_PATH, context, false);
+            returnExpression.include(context, false);
         }
     }
     initialise() {
@@ -15422,7 +15291,7 @@ class TemplateElement extends NodeBase {
     hasEffects() {
         return false;
     }
-    includePath() {
+    include() {
         this.included = true;
     }
     parseNode(esTreeNode) {
@@ -15464,13 +15333,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, includedInitPath, 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, includedInitPath, kind);
+        return super.addDeclaration(identifier, context, init, kind);
     }
     addExportDefaultDeclaration(name, exportDefaultDeclaration, context) {
         const variable = new ExportDefaultVariable(name, exportDefaultDeclaration, context);
@@ -15515,13 +15384,10 @@ class ThisExpression extends NodeBase {
         }
         return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
-    includePath(path, context) {
+    include() {
         if (!this.included) {
             this.included = true;
-            this.scope.context.includeVariableInModule(this.variable, path);
-        }
-        else if (path.length > 0) {
-            this.variable.includePath(path, context);
+            this.scope.context.includeVariableInModule(this.variable);
         }
     }
     initialise() {
@@ -15548,9 +15414,9 @@ class ThrowStatement extends NodeBase {
     hasEffects() {
         return true;
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.argument.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.argument.include(context, includeChildrenRecursively);
         context.brokenFlow = true;
     }
     render(code, options) {
@@ -15572,13 +15438,13 @@ class TryStatement extends NodeBase {
             ? this.block.body.length > 0
             : this.block.hasEffects(context)) || !!this.finalizer?.hasEffects(context));
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         const tryCatchDeoptimization = this.scope.context.options.treeshake?.tryCatchDeoptimization;
         const { brokenFlow, includedLabels } = context;
         if (!this.directlyIncluded || !tryCatchDeoptimization) {
             this.included = true;
             this.directlyIncluded = true;
-            this.block.includePath(UNKNOWN_PATH, context, tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively);
+            this.block.include(context, tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively);
             if (includedLabels.size > 0) {
                 this.includedLabelsAfterBlock = [...includedLabels];
             }
@@ -15590,10 +15456,10 @@ class TryStatement extends NodeBase {
             }
         }
         if (this.handler !== null) {
-            this.handler.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+            this.handler.include(context, includeChildrenRecursively);
             context.brokenFlow = brokenFlow;
         }
-        this.finalizer?.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.finalizer?.include(context, includeChildrenRecursively);
     }
 }
 
@@ -15651,7 +15517,7 @@ class UpdateExpression extends NodeBase {
     hasEffectsOnInteractionAtPath(path, { type }) {
         return path.length > 1 || type !== INTERACTION_ACCESSED;
     }
-    includePath(_, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
@@ -15720,20 +15586,20 @@ class VariableDeclaration extends NodeBase {
     hasEffectsOnInteractionAtPath() {
         return false;
     }
-    includePath(_path, context, includeChildrenRecursively, { asSingleStatement } = parseAst_js.BLANK) {
+    include(context, includeChildrenRecursively, { asSingleStatement } = parseAst_js.BLANK) {
         this.included = true;
         for (const declarator of this.declarations) {
             if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
-                declarator.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+                declarator.include(context, includeChildrenRecursively);
             const { id, init } = declarator;
             if (asSingleStatement) {
-                id.includePath(EMPTY_PATH, context, includeChildrenRecursively);
+                id.include(context, includeChildrenRecursively);
             }
             if (init &&
                 id.included &&
                 !init.included &&
                 (id instanceof ObjectPattern || id instanceof ArrayPattern)) {
-                init.includePath(EMPTY_PATH, context, includeChildrenRecursively);
+                init.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -15805,7 +15671,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);
@@ -15882,9 +15749,9 @@ class WhileStatement extends NodeBase {
             return true;
         return hasLoopBodyEffects(context, this.body);
     }
-    includePath(_path, context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively) {
         this.included = true;
-        this.test.includePath(UNKNOWN_PATH, context, includeChildrenRecursively);
+        this.test.include(context, includeChildrenRecursively);
         includeLoopBody(context, this.body, includeChildrenRecursively);
     }
 }
@@ -16128,7 +15995,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) {
@@ -16174,7 +16041,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) {
@@ -16184,14 +16051,17 @@ const bufferParsers = [
     function classBody(node, position, buffer) {
         const { scope } = node;
         const bodyPosition = buffer[position];
-        const body = (node.body = []);
         if (bodyPosition) {
             const length = buffer[bodyPosition];
+            const body = (node.body = new Array(length));
             for (let index = 0; index < length; index++) {
                 const nodePosition = buffer[bodyPosition + 1 + index];
-                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer));
+                body[index] = convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer);
             }
         }
+        else {
+            node.body = [];
+        }
     },
     function classDeclaration(node, position, buffer) {
         const { scope } = node;
@@ -16309,7 +16179,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) {
@@ -16322,7 +16192,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) {
@@ -16669,10 +16539,10 @@ function convertNodeList(parent, parentScope, position, buffer) {
     if (position === 0)
         return parseAst_js.EMPTY_ARRAY;
     const length = buffer[position++];
-    const list = [];
+    const list = new Array(length);
     for (let index = 0; index < length; index++) {
         const nodePosition = buffer[position++];
-        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null);
+        list[index] = nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null;
     }
     return list;
 }
@@ -16681,8 +16551,8 @@ class UnknownNode extends NodeBase {
     hasEffects() {
         return true;
     }
-    includePath(path, context) {
-        super.includePath(path, context, true);
+    include(context) {
+        super.include(context, true);
     }
 }
 
@@ -16786,8 +16656,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;
     }
 }
@@ -17471,7 +17341,7 @@ class Module {
     include() {
         const context = createInclusionContext();
         if (this.ast.shouldBeIncluded(context))
-            this.ast.includePath(EMPTY_PATH, context, false);
+            this.ast.include(context, false);
     }
     includeAllExports(includeNamespaceMembers) {
         if (!this.isExecuted) {
@@ -17485,7 +17355,9 @@ class Module {
                     return parseAst_js.error(parseAst_js.logMissingEntryExport(exportName, this.id));
                 }
                 variable.deoptimizePath(UNKNOWN_PATH);
-                this.includeVariable(variable, UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
             }
         }
         for (const name of this.getReexports()) {
@@ -17493,7 +17365,7 @@ class Module {
             if (variable) {
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
-                    this.includeVariable(variable, UNKNOWN_PATH);
+                    this.includeVariable(variable);
                 }
                 if (variable instanceof ExternalVariable) {
                     variable.module.reexported = true;
@@ -17505,7 +17377,7 @@ class Module {
         }
     }
     includeAllInBundle() {
-        this.ast.includePath(UNKNOWN_PATH, createInclusionContext(), true);
+        this.ast.include(createInclusionContext(), true);
         this.includeAllExports(false);
     }
     includeExportsByNames(names) {
@@ -17519,7 +17391,7 @@ class Module {
             if (variable) {
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
-                    this.includeVariable(variable, EMPTY_PATH);
+                    this.includeVariable(variable);
                 }
             }
             if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
@@ -17961,13 +17833,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);
             }
@@ -17977,9 +17849,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;
@@ -17991,7 +17861,7 @@ class Module {
             }
         }
     }
-    includeVariable(variable, path) {
+    includeVariable(variable) {
         const variableModule = variable.module;
         if (variable.included) {
             if (variableModule instanceof Module && variableModule !== this) {
@@ -17999,6 +17869,7 @@ class Module {
             }
         }
         else {
+            variable.include();
             this.graph.needsTreeshakingPass = true;
             if (variableModule instanceof Module) {
                 if (!variableModule.isExecuted) {
@@ -18014,10 +17885,9 @@ class Module {
                 }
             }
         }
-        variable.includePath(path, createInclusionContext());
     }
-    includeVariableInModule(variable, path) {
-        this.includeVariable(variable, path);
+    includeVariableInModule(variable) {
+        this.includeVariable(variable);
         const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
             this.includedImports.add(variable);
@@ -19549,14 +19419,16 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log
     return chunkDefinitions;
 }
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
-    const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
     for (const [entry, alias] of manualChunkAliasByEntry) {
         addStaticDependenciesToManualChunk(entry, (manualChunkModulesByAlias[alias] ||= []), modulesInManualChunks);
     }
-    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
-        chunkDefinitions.push({ alias, modules });
+    const manualChunks = Object.entries(manualChunkModulesByAlias);
+    const chunkDefinitions = new Array(manualChunks.length);
+    let index = 0;
+    for (const [alias, modules] of manualChunks) {
+        chunkDefinitions[index++] = { alias, modules };
     }
     return { chunkDefinitions, modulesInManualChunks };
 }
@@ -19575,12 +19447,12 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
 function analyzeModuleGraph(entries) {
     const dynamicEntryModules = new Set();
     const dependentEntriesByModule = new Map();
-    const dynamicImportModulesByEntry = [];
     const allEntriesSet = new Set(entries);
+    const dynamicImportModulesByEntry = new Array(allEntriesSet.size);
     let entryIndex = 0;
     for (const currentEntry of allEntriesSet) {
         const dynamicImportsForCurrentEntry = new Set();
-        dynamicImportModulesByEntry.push(dynamicImportsForCurrentEntry);
+        dynamicImportModulesByEntry[entryIndex] = dynamicImportsForCurrentEntry;
         const modulesToHandle = new Set([currentEntry]);
         for (const module of modulesToHandle) {
             getOrCreate(dependentEntriesByModule, module, (getNewSet)).add(entryIndex);
@@ -19625,13 +19497,14 @@ function getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModules
             dynamicEntries.add(entryIndex);
         }
     }
-    const dynamicImportsByEntry = [];
+    const dynamicImportsByEntry = new Array(dynamicImportModulesByEntry.length);
+    let index = 0;
     for (const dynamicImportModules of dynamicImportModulesByEntry) {
         const dynamicImports = new Set();
         for (const dynamicEntry of dynamicImportModules) {
             dynamicImports.add(entryIndexByModule.get(dynamicEntry));
         }
-        dynamicImportsByEntry.push(dynamicImports);
+        dynamicImportsByEntry[index++] = dynamicImports;
     }
     return { dynamicEntries, dynamicImportsByEntry };
 }
@@ -19736,9 +19609,10 @@ function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry
 function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
     const chunksBySignature = Object.create(null);
     const chunkByModule = new Map();
-    const sizeByAtom = [];
+    const sizeByAtom = new Array(chunkAtoms.length);
     let sideEffectAtoms = 0n;
     let atomMask = 1n;
+    let index = 0;
     for (const { dependentEntries, modules } of chunkAtoms) {
         let chunkSignature = 0n;
         let correlatedAtoms = -1n;
@@ -19776,7 +19650,7 @@ function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticD
         if (!pure) {
             sideEffectAtoms |= atomMask;
         }
-        sizeByAtom.push(atomSize);
+        sizeByAtom[index++] = atomSize;
         chunk.containedAtoms |= atomMask;
         chunk.modules.push(...modules);
         chunk.pure &&= pure;
@@ -20526,6 +20400,9 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bun
         const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
         let finalSourcemapFileName = null;
         if (map) {
+            if (options.sourcemapDebugIds) {
+                updatedCode += calculateDebugIdAndGetComment(updatedCode, map);
+            }
             finalSourcemapFileName = sourcemapFileName
                 ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
                 : `${finalFileName}.map`;
@@ -20538,6 +20415,9 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bun
         let updatedCode = hashesByPlaceholder.size > 0 ? replacePlaceholders(code, hashesByPlaceholder) : code;
         let finalSourcemapFileName = null;
         if (map) {
+            if (options.sourcemapDebugIds) {
+                updatedCode += calculateDebugIdAndGetComment(updatedCode, map);
+            }
             finalSourcemapFileName = sourcemapFileName
                 ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
                 : `${fileName}.map`;
@@ -20565,6 +20445,18 @@ function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, so
     }
     return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
 }
+function calculateDebugIdAndGetComment(code, map) {
+    const hash = hasherByType.hex(code);
+    const debugId = [
+        hash.slice(0, 8),
+        hash.slice(8, 12),
+        '4' + hash.slice(12, 15),
+        ((parseInt(hash.slice(15, 16), 16) & 3) | 8).toString(16) + hash.slice(17, 20),
+        hash.slice(20, 32)
+    ].join('-');
+    map.debugId = debugId;
+    return '//# debugId=' + debugId + '\n';
+}
 
 class Bundle {
     constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
@@ -20672,16 +20564,18 @@ class Bundle {
         const includedModules = getIncludedModules(this.graph.modulesById);
         const inputBase = commondir(getAbsoluteEntryModulePaths(includedModules, preserveModules));
         const externalChunkByModule = getExternalChunkByModule(this.graph.modulesById, this.outputOptions, inputBase);
-        const chunks = [];
-        const chunkByModule = new Map();
-        for (const { alias, modules } of inlineDynamicImports
+        const executableModule = inlineDynamicImports
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
-                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog);
+        const chunks = new Array(executableModule.length);
+        const chunkByModule = new Map();
+        let index = 0;
+        for (const { alias, modules } of executableModule) {
             sortByExecutionOrder(modules);
             const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
-            chunks.push(chunk);
+            chunks[index++] = chunk;
         }
         for (const chunk of chunks) {
             chunk.link();
@@ -21496,7 +21390,7 @@ 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;
@@ -21944,6 +21838,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
                 : sanitizeFileName,
         sourcemap: config.sourcemap || false,
         sourcemapBaseUrl: getSourcemapBaseUrl(config),
+        sourcemapDebugIds: config.sourcemapDebugIds || false,
         sourcemapExcludeSources: config.sourcemapExcludeSources || false,
         sourcemapFile: config.sourcemapFile,
         sourcemapFileNames: getSourcemapFileNames(config, unsetOptions),