@rollup/wasm-node 4.24.2 → 4.24.4

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.24.2
-	Sun, 27 Oct 2024 15:39:37 GMT - commit 32d0e7dae85121ac0850ec28576a10a6302f84a9
+	Rollup.js v4.24.4
+	Mon, 04 Nov 2024 08:46:36 GMT - commit cdf34ab5411aac6ac3f6cd21b10d2e58427e88ec
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.24.2";
+var version = "4.24.4";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -4045,208 +4045,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 = {
@@ -4488,11 +4286,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 {
@@ -4559,6 +4359,215 @@ 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;
+        }
+        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];
+}
+
 class SpreadElement extends NodeBase {
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         if (path.length > 0) {
@@ -5516,7 +5525,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,
@@ -9623,14 +9654,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(`,${_}`)}${_}};`);
@@ -12951,9 +12984,10 @@ class ClassBody extends NodeBase {
         }
     }
     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);
     }
@@ -16016,14 +16050,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;
@@ -16501,10 +16538,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;
 }
@@ -19381,14 +19418,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 };
 }
@@ -19407,12 +19446,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);
@@ -19457,13 +19496,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 };
 }
@@ -19568,9 +19608,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;
@@ -19608,7 +19649,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;
@@ -20504,16 +20545,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();

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.24.2
-	Sun, 27 Oct 2024 15:39:37 GMT - commit 32d0e7dae85121ac0850ec28576a10a6302f84a9
+	Rollup.js v4.24.4
+	Mon, 04 Nov 2024 08:46:36 GMT - commit cdf34ab5411aac6ac3f6cd21b10d2e58427e88ec
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.24.2
-	Sun, 27 Oct 2024 15:39:37 GMT - commit 32d0e7dae85121ac0850ec28576a10a6302f84a9
+	Rollup.js v4.24.4
+	Mon, 04 Nov 2024 08:46:36 GMT - commit cdf34ab5411aac6ac3f6cd21b10d2e58427e88ec
 
 	https://github.com/rollup/rollup