rollup 3.21.8 → 3.22.0

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 
@@ -16,7 +16,7 @@ import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/pr
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.21.8";
+var version$1 = "3.22.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -13451,6 +13451,16 @@ class Module {
         this.addLocationToLogProps(properties, pos);
         return error(properties);
     }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
     getAllExportNames() {
         if (this.allExportNames) {
             return this.allExportNames;
@@ -15488,13 +15498,18 @@ class Chunk {
     }
     canModuleBeFacade(module, exposedVariables) {
         const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
                 return false;
             }
         }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
         for (const exposedVariable of exposedVariables) {
-            if (!(moduleExportNamesByVariable.has(exposedVariable) || exposedVariable.module === module)) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
                 return false;
             }
         }
@@ -15549,7 +15564,10 @@ class Chunk {
         for (const module of entryModules) {
             if (module.preserveSignature) {
                 for (const exportedVariable of module.getExportNamesByVariable().keys()) {
-                    exposedVariables.add(exportedVariable);
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
                 }
             }
         }
@@ -16526,11 +16544,14 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = Object.values(getChunksBySignature(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks)));
+    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
     // This mutates initialChunks but also clears
     // dynamicallyDependentEntriesByDynamicEntry as side effect
     removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...createChunks(allEntries, getChunksBySignature(initialChunks), minChunkSize));
+    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
     return chunkDefinitions;
 }
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
@@ -16636,7 +16657,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksBySignature(modulesWithDependentEntries) {
+function getChunksFromDependentEntries(modulesWithDependentEntries) {
     var _a;
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
@@ -16649,7 +16670,7 @@ function getChunksBySignature(modulesWithDependentEntries) {
             modules: []
         })).modules.push(...modules);
     }
-    return chunkModules;
+    return Object.values(chunkModules);
 }
 function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
     for (const [module, dependentEntries] of dependentEntriesByModule) {
@@ -16707,17 +16728,6 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
         chunkMask <<= 1n;
     }
 }
-function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
-    return minChunkSize === 0
-        ? Object.values(chunkModulesBySignature).map(({ modules }) => ({
-            alias: null,
-            modules
-        }))
-        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
-}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -16760,239 +16770,270 @@ function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
  * dependency side effects are AF.
  * For entry chunks, dependency and correlated side effects are the same.
  *
- * With these concepts, merging chunks is allowed if the correlated side effects
- * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
  * a) the dependency side effects of each chunk are a subset of the correlated
  *    side effects of the other chunk, so no additional side effects are
  *    triggered for any entry, or
- * b) The signature of chunk A is a subset of the signature of chunk B while the
- *    dependency side effects of A are a subset of the correlated side effects
- *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
- *    But there are cases when B is loaded where A is not loaded. So if we merge
- *    the chunks, all dependency side effects of A will be added to the
- *    correlated side effects of B, and as the latter is not allowed to change,
- *    the former need to be a subset of the latter.
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
  *
- * Another consideration when merging small chunks into other chunks is to avoid
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
  * that too much additional code is loaded. This is achieved when the dependent
- * entries of the small chunk are a subset of the dependent entries of the other
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
  * chunk. Because then when the small chunk is loaded, the other chunk was
  * loaded/in memory anyway, so at most when the other chunk is loaded, the
  * additional size of the small chunk is loaded unnecessarily.
  *
  * So the algorithm performs merges in two passes:
+ *
  * 1. First we try to merge small chunks A only into other chunks B if the
  *    dependent entries of A are a subset of the dependent entries of B and the
  *    dependency side effects of A are a subset of the correlated side effects
  *    of B.
  * 2. Only then for all remaining small chunks, we look for arbitrary merges
- *    following the above rules (a) and (b), starting with the smallest chunks
- *    to look for possible merge targets.
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
  */
-// TODO instead of picking the "closest" chunk, we could actually use a
-//  technique similar to what we do for side effects to compare the size of the
-//  static dependencies that are not part of the correlated dependencies
-function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
-    console.log('Before eliminating small chunks, there were\n', Object.keys(chunkModulesBySignature).length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
-    if (chunkPartition.small.size > 0) {
-        mergeChunks(chunkPartition, minChunkSize);
-    }
-    console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
+    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return initialChunks; // the actual modules
+    }
+    minChunkSize > 1 &&
+        console.log('Before eliminating small chunks, there were\n', initialChunks.length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
+    mergeChunks(chunkPartition, minChunkSize);
+    minChunkSize > 1 &&
+        console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
     const chunkByModule = new Map();
-    const sideEffectsByEntry = [];
-    for (let index = 0; index < numberOfEntries; index++) {
-        sideEffectsByEntry.push(new Set());
-    }
-    for (const [signature, { dependentEntries, modules }] of Object.entries(chunkModulesBySignature)) {
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let containedAtoms = 1n;
+    for (const { dependentEntries, modules } of initialChunks) {
         const chunkDescription = {
-            correlatedSideEffects: new Set(),
+            containedAtoms,
+            correlatedAtoms: 0n,
             dependencies: new Set(),
             dependentChunks: new Set(),
             dependentEntries,
             modules,
             pure: true,
-            sideEffects: new Set(),
             size: 0
         };
         let size = 0;
         let pure = true;
         for (const module of modules) {
             chunkByModule.set(module, chunkDescription);
-            pure && (pure = !module.hasEffects());
             // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet
-            size += module.originalCode.length;
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure && (pure = !module.hasEffects());
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                size += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
+        sizeByAtom.push(size);
         if (!pure) {
-            for (const entryIndex of dependentEntries) {
-                sideEffectsByEntry[entryIndex].add(signature);
-            }
-            // In the beginning, each chunk is only its own side effect. After
-            // merging, additional side effects can accumulate.
-            chunkDescription.sideEffects.add(signature);
+            sideEffectAtoms |= containedAtoms;
         }
         (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+        containedAtoms <<= 1n;
     }
-    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
+    // If there are no small chunks, we will not optimize
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
     return {
         big: new Set(bigChunks),
+        sideEffectAtoms,
+        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure && (bestTargetChunk.pure = pure);
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
+    const signatureByExternalModule = new Map();
+    let sideEffectAtoms = 0n;
+    const atomsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        atomsByEntry.push(0n);
+    }
     for (const chunks of chunkLists) {
         chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
+            const { dependencies, dependentEntries, modules } = chunk;
             for (const module of modules) {
                 for (const dependency of module.getDependenciesToBeIncluded()) {
-                    const dependencyChunk = chunkByModule.get(dependency);
-                    if (dependencyChunk && dependencyChunk !== chunk) {
-                        dependencies.add(dependencyChunk);
-                        dependencyChunk.dependentChunks.add(chunk);
-                    }
-                }
-            }
-            let firstEntry = true;
-            // Correlated side effects is the intersection of all entry side effects
-            for (const entryIndex of dependentEntries) {
-                const entryEffects = sideEffectsByEntry[entryIndex];
-                if (firstEntry) {
-                    for (const sideEffect of entryEffects) {
-                        correlatedSideEffects.add(sideEffect);
+                    if (dependency instanceof ExternalModule) {
+                        if (dependency.info.moduleSideEffects) {
+                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
+                                const signature = nextAtomSignature;
+                                nextAtomSignature <<= 1n;
+                                sideEffectAtoms |= signature;
+                                return signature;
+                            });
+                        }
                     }
-                    firstEntry = false;
-                }
-                else {
-                    for (const sideEffect of correlatedSideEffects) {
-                        if (!entryEffects.has(sideEffect)) {
-                            correlatedSideEffects.delete(sideEffect);
+                    else {
+                        const dependencyChunk = chunkByModule.get(dependency);
+                        if (dependencyChunk && dependencyChunk !== chunk) {
+                            dependencies.add(dependencyChunk);
+                            dependencyChunk.dependentChunks.add(chunk);
                         }
                     }
                 }
             }
+            const { containedAtoms } = chunk;
+            for (const entryIndex of dependentEntries) {
+                atomsByEntry[entryIndex] |= containedAtoms;
+            }
         }
     }
-}
-function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
-function mergeChunks(chunkPartition, minChunkSize) {
-    for (const allowArbitraryMerges of [false, true]) {
-        for (const mergedChunk of chunkPartition.small) {
-            let closestChunk = null;
-            let closestChunkDistance = Infinity;
-            const { modules, pure, size } = mergedChunk;
-            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
-                if (mergedChunk === targetChunk)
-                    continue;
-                // If both chunks are small, we also allow for unrelated merges during
-                // the first pass
-                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
-                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
-                if (distance < closestChunkDistance &&
-                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
-                    closestChunk = targetChunk;
-                    closestChunkDistance = distance;
-                }
-            }
-            if (closestChunk) {
-                chunkPartition.small.delete(mergedChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
-                closestChunk.modules.push(...modules);
-                closestChunk.size += size;
-                closestChunk.pure && (closestChunk.pure = pure);
-                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
-                for (const sideEffect of correlatedSideEffects) {
-                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
-                        correlatedSideEffects.delete(sideEffect);
-                    }
-                }
-                for (const entry of mergedChunk.dependentEntries) {
-                    dependentEntries.add(entry);
-                }
-                for (const sideEffect of mergedChunk.sideEffects) {
-                    sideEffects.add(sideEffect);
-                }
-                for (const dependency of mergedChunk.dependencies) {
-                    dependencies.add(dependency);
-                    dependency.dependentChunks.delete(mergedChunk);
-                    dependency.dependentChunks.add(closestChunk);
-                }
-                for (const dependentChunk of mergedChunk.dependentChunks) {
-                    dependentChunks.add(dependentChunk);
-                    dependentChunk.dependencies.delete(mergedChunk);
-                    dependentChunk.dependencies.add(closestChunk);
-                }
-                dependencies.delete(closestChunk);
-                dependentChunks.delete(closestChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+    for (const chunks of chunkLists) {
+        for (const chunk of chunks) {
+            const { dependentEntries } = chunk;
+            // Correlated atoms are the intersection of all entry atoms
+            chunk.correlatedAtoms = -1n;
+            for (const entryIndex of dependentEntries) {
+                chunk.correlatedAtoms &= atomsByEntry[entryIndex];
             }
         }
     }
+    return sideEffectAtoms;
 }
-// Merging will not produce cycles if none of the direct non-merged dependencies
-// of a chunk have the other chunk as a transitive dependency
-function isValidMerge(mergedChunk, targetChunk, onlySubsetMerge) {
-    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
-        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
-}
-function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
-    const { correlatedSideEffects } = dependencyChunk;
-    if (checkSideEffects) {
-        for (const sideEffect of dependentChunk.sideEffects) {
-            if (!correlatedSideEffects.has(sideEffect)) {
-                return true;
-            }
+function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
         }
     }
+    return bestTargetChunk;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * Merging will not produce cycles if none of the direct non-merged
+ * dependencies of a chunk have the other chunk as a transitive dependency.
+ */
+function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies, sideEffects } of chunksToCheck) {
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
-                return true;
+                return Infinity;
             }
             chunksToCheck.add(dependency);
         }
-        if (checkSideEffects) {
-            for (const sideEffect of sideEffects) {
-                if (!correlatedSideEffects.has(sideEffect)) {
-                    return true;
-                }
-            }
-        }
     }
-    return false;
-}
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
 }
-function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
-    let distance = 0;
-    for (const entryIndex of targetEntries) {
-        if (!sourceEntries.has(entryIndex)) {
-            distance++;
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
         }
-    }
-    for (const entryIndex of sourceEntries) {
-        if (!targetEntries.has(entryIndex)) {
-            if (enforceSubest) {
-                return Infinity;
-            }
-            distance++;
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
         }
     }
-    return distance;
+    return size;
 }
 
 // ported from https://github.com/substack/node-commondir
@@ -25465,7 +25506,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
         experimentalDeepDynamicChunkOptimization: getExperimentalDeepDynamicChunkOptimization(config, inputOptions),
-        experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
         externalImportAssertions: config.externalImportAssertions ?? true,

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/fsevents-importer.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.21.8";
+var version$1 = "3.22.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -13946,6 +13946,16 @@ class Module {
         this.addLocationToLogProps(properties, pos);
         return error(properties);
     }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
     getAllExportNames() {
         if (this.allExportNames) {
             return this.allExportNames;
@@ -15983,13 +15993,18 @@ class Chunk {
     }
     canModuleBeFacade(module, exposedVariables) {
         const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
                 return false;
             }
         }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
         for (const exposedVariable of exposedVariables) {
-            if (!(moduleExportNamesByVariable.has(exposedVariable) || exposedVariable.module === module)) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
                 return false;
             }
         }
@@ -16044,7 +16059,10 @@ class Chunk {
         for (const module of entryModules) {
             if (module.preserveSignature) {
                 for (const exportedVariable of module.getExportNamesByVariable().keys()) {
-                    exposedVariables.add(exportedVariable);
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
                 }
             }
         }
@@ -17021,11 +17039,14 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = Object.values(getChunksBySignature(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks)));
+    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
     // This mutates initialChunks but also clears
     // dynamicallyDependentEntriesByDynamicEntry as side effect
     removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...createChunks(allEntries, getChunksBySignature(initialChunks), minChunkSize));
+    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
     return chunkDefinitions;
 }
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
@@ -17131,7 +17152,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksBySignature(modulesWithDependentEntries) {
+function getChunksFromDependentEntries(modulesWithDependentEntries) {
     var _a;
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
@@ -17144,7 +17165,7 @@ function getChunksBySignature(modulesWithDependentEntries) {
             modules: []
         })).modules.push(...modules);
     }
-    return chunkModules;
+    return Object.values(chunkModules);
 }
 function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
     for (const [module, dependentEntries] of dependentEntriesByModule) {
@@ -17202,17 +17223,6 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
         chunkMask <<= 1n;
     }
 }
-function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
-    return minChunkSize === 0
-        ? Object.values(chunkModulesBySignature).map(({ modules }) => ({
-            alias: null,
-            modules
-        }))
-        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
-}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -17255,239 +17265,270 @@ function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
  * dependency side effects are AF.
  * For entry chunks, dependency and correlated side effects are the same.
  *
- * With these concepts, merging chunks is allowed if the correlated side effects
- * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
  * a) the dependency side effects of each chunk are a subset of the correlated
  *    side effects of the other chunk, so no additional side effects are
  *    triggered for any entry, or
- * b) The signature of chunk A is a subset of the signature of chunk B while the
- *    dependency side effects of A are a subset of the correlated side effects
- *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
- *    But there are cases when B is loaded where A is not loaded. So if we merge
- *    the chunks, all dependency side effects of A will be added to the
- *    correlated side effects of B, and as the latter is not allowed to change,
- *    the former need to be a subset of the latter.
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
  *
- * Another consideration when merging small chunks into other chunks is to avoid
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
  * that too much additional code is loaded. This is achieved when the dependent
- * entries of the small chunk are a subset of the dependent entries of the other
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
  * chunk. Because then when the small chunk is loaded, the other chunk was
  * loaded/in memory anyway, so at most when the other chunk is loaded, the
  * additional size of the small chunk is loaded unnecessarily.
  *
  * So the algorithm performs merges in two passes:
+ *
  * 1. First we try to merge small chunks A only into other chunks B if the
  *    dependent entries of A are a subset of the dependent entries of B and the
  *    dependency side effects of A are a subset of the correlated side effects
  *    of B.
  * 2. Only then for all remaining small chunks, we look for arbitrary merges
- *    following the above rules (a) and (b), starting with the smallest chunks
- *    to look for possible merge targets.
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
  */
-// TODO instead of picking the "closest" chunk, we could actually use a
-//  technique similar to what we do for side effects to compare the size of the
-//  static dependencies that are not part of the correlated dependencies
-function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
-    console.log('Before eliminating small chunks, there were\n', Object.keys(chunkModulesBySignature).length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
-    if (chunkPartition.small.size > 0) {
-        mergeChunks(chunkPartition, minChunkSize);
-    }
-    console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
+    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return initialChunks; // the actual modules
+    }
+    minChunkSize > 1 &&
+        console.log('Before eliminating small chunks, there were\n', initialChunks.length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
+    mergeChunks(chunkPartition, minChunkSize);
+    minChunkSize > 1 &&
+        console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
     const chunkByModule = new Map();
-    const sideEffectsByEntry = [];
-    for (let index = 0; index < numberOfEntries; index++) {
-        sideEffectsByEntry.push(new Set());
-    }
-    for (const [signature, { dependentEntries, modules }] of Object.entries(chunkModulesBySignature)) {
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let containedAtoms = 1n;
+    for (const { dependentEntries, modules } of initialChunks) {
         const chunkDescription = {
-            correlatedSideEffects: new Set(),
+            containedAtoms,
+            correlatedAtoms: 0n,
             dependencies: new Set(),
             dependentChunks: new Set(),
             dependentEntries,
             modules,
             pure: true,
-            sideEffects: new Set(),
             size: 0
         };
         let size = 0;
         let pure = true;
         for (const module of modules) {
             chunkByModule.set(module, chunkDescription);
-            pure && (pure = !module.hasEffects());
             // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet
-            size += module.originalCode.length;
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure && (pure = !module.hasEffects());
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                size += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
+        sizeByAtom.push(size);
         if (!pure) {
-            for (const entryIndex of dependentEntries) {
-                sideEffectsByEntry[entryIndex].add(signature);
-            }
-            // In the beginning, each chunk is only its own side effect. After
-            // merging, additional side effects can accumulate.
-            chunkDescription.sideEffects.add(signature);
+            sideEffectAtoms |= containedAtoms;
         }
         (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+        containedAtoms <<= 1n;
     }
-    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
+    // If there are no small chunks, we will not optimize
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
     return {
         big: new Set(bigChunks),
+        sideEffectAtoms,
+        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure && (bestTargetChunk.pure = pure);
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
+    const signatureByExternalModule = new Map();
+    let sideEffectAtoms = 0n;
+    const atomsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        atomsByEntry.push(0n);
+    }
     for (const chunks of chunkLists) {
         chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
+            const { dependencies, dependentEntries, modules } = chunk;
             for (const module of modules) {
                 for (const dependency of module.getDependenciesToBeIncluded()) {
-                    const dependencyChunk = chunkByModule.get(dependency);
-                    if (dependencyChunk && dependencyChunk !== chunk) {
-                        dependencies.add(dependencyChunk);
-                        dependencyChunk.dependentChunks.add(chunk);
-                    }
-                }
-            }
-            let firstEntry = true;
-            // Correlated side effects is the intersection of all entry side effects
-            for (const entryIndex of dependentEntries) {
-                const entryEffects = sideEffectsByEntry[entryIndex];
-                if (firstEntry) {
-                    for (const sideEffect of entryEffects) {
-                        correlatedSideEffects.add(sideEffect);
+                    if (dependency instanceof ExternalModule) {
+                        if (dependency.info.moduleSideEffects) {
+                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
+                                const signature = nextAtomSignature;
+                                nextAtomSignature <<= 1n;
+                                sideEffectAtoms |= signature;
+                                return signature;
+                            });
+                        }
                     }
-                    firstEntry = false;
-                }
-                else {
-                    for (const sideEffect of correlatedSideEffects) {
-                        if (!entryEffects.has(sideEffect)) {
-                            correlatedSideEffects.delete(sideEffect);
+                    else {
+                        const dependencyChunk = chunkByModule.get(dependency);
+                        if (dependencyChunk && dependencyChunk !== chunk) {
+                            dependencies.add(dependencyChunk);
+                            dependencyChunk.dependentChunks.add(chunk);
                         }
                     }
                 }
             }
+            const { containedAtoms } = chunk;
+            for (const entryIndex of dependentEntries) {
+                atomsByEntry[entryIndex] |= containedAtoms;
+            }
         }
     }
-}
-function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
-function mergeChunks(chunkPartition, minChunkSize) {
-    for (const allowArbitraryMerges of [false, true]) {
-        for (const mergedChunk of chunkPartition.small) {
-            let closestChunk = null;
-            let closestChunkDistance = Infinity;
-            const { modules, pure, size } = mergedChunk;
-            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
-                if (mergedChunk === targetChunk)
-                    continue;
-                // If both chunks are small, we also allow for unrelated merges during
-                // the first pass
-                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
-                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
-                if (distance < closestChunkDistance &&
-                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
-                    closestChunk = targetChunk;
-                    closestChunkDistance = distance;
-                }
-            }
-            if (closestChunk) {
-                chunkPartition.small.delete(mergedChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
-                closestChunk.modules.push(...modules);
-                closestChunk.size += size;
-                closestChunk.pure && (closestChunk.pure = pure);
-                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
-                for (const sideEffect of correlatedSideEffects) {
-                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
-                        correlatedSideEffects.delete(sideEffect);
-                    }
-                }
-                for (const entry of mergedChunk.dependentEntries) {
-                    dependentEntries.add(entry);
-                }
-                for (const sideEffect of mergedChunk.sideEffects) {
-                    sideEffects.add(sideEffect);
-                }
-                for (const dependency of mergedChunk.dependencies) {
-                    dependencies.add(dependency);
-                    dependency.dependentChunks.delete(mergedChunk);
-                    dependency.dependentChunks.add(closestChunk);
-                }
-                for (const dependentChunk of mergedChunk.dependentChunks) {
-                    dependentChunks.add(dependentChunk);
-                    dependentChunk.dependencies.delete(mergedChunk);
-                    dependentChunk.dependencies.add(closestChunk);
-                }
-                dependencies.delete(closestChunk);
-                dependentChunks.delete(closestChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+    for (const chunks of chunkLists) {
+        for (const chunk of chunks) {
+            const { dependentEntries } = chunk;
+            // Correlated atoms are the intersection of all entry atoms
+            chunk.correlatedAtoms = -1n;
+            for (const entryIndex of dependentEntries) {
+                chunk.correlatedAtoms &= atomsByEntry[entryIndex];
             }
         }
     }
+    return sideEffectAtoms;
 }
-// Merging will not produce cycles if none of the direct non-merged dependencies
-// of a chunk have the other chunk as a transitive dependency
-function isValidMerge(mergedChunk, targetChunk, onlySubsetMerge) {
-    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
-        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
-}
-function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
-    const { correlatedSideEffects } = dependencyChunk;
-    if (checkSideEffects) {
-        for (const sideEffect of dependentChunk.sideEffects) {
-            if (!correlatedSideEffects.has(sideEffect)) {
-                return true;
-            }
+function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
         }
     }
+    return bestTargetChunk;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * Merging will not produce cycles if none of the direct non-merged
+ * dependencies of a chunk have the other chunk as a transitive dependency.
+ */
+function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies, sideEffects } of chunksToCheck) {
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
-                return true;
+                return Infinity;
             }
             chunksToCheck.add(dependency);
         }
-        if (checkSideEffects) {
-            for (const sideEffect of sideEffects) {
-                if (!correlatedSideEffects.has(sideEffect)) {
-                    return true;
-                }
-            }
-        }
     }
-    return false;
-}
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
 }
-function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
-    let distance = 0;
-    for (const entryIndex of targetEntries) {
-        if (!sourceEntries.has(entryIndex)) {
-            distance++;
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
         }
-    }
-    for (const entryIndex of sourceEntries) {
-        if (!targetEntries.has(entryIndex)) {
-            if (enforceSubest) {
-                return Infinity;
-            }
-            distance++;
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
         }
     }
-    return distance;
+    return size;
 }
 
 // ported from https://github.com/substack/node-commondir
@@ -25864,7 +25905,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
         experimentalDeepDynamicChunkOptimization: getExperimentalDeepDynamicChunkOptimization(config, inputOptions),
-        experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
         externalImportAssertions: config.externalImportAssertions ?? true,

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch-proxy.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.8
-	Tue, 16 May 2023 07:30:04 GMT - commit 67f2416afb73734887d37e12ce5d7f00a511ac27
+	Rollup.js v3.22.0
+	Wed, 17 May 2023 04:19:47 GMT - commit 9f05b91e5e1862f7ea7a728fb63fb2750dfe7392
 
 	https://github.com/rollup/rollup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "3.21.8",
+  "version": "3.22.0",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",