rollup 3.6.0-0 → 3.6.0-1

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 
@@ -16,7 +16,7 @@ import { promises } from 'node:fs';
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.6.0-0";
+var version$1 = "3.6.0-1";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1681,7 +1681,7 @@ function formatAssertions$1(assertions, { getObject }) {
 
 function getOrCreate(map, key, init) {
     const existing = map.get(key);
-    if (existing) {
+    if (existing !== undefined) {
         return existing;
     }
     const value = init();
@@ -15831,7 +15831,7 @@ function* concatLazy(iterables) {
     }
 }
 
-function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize) {
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
@@ -15841,53 +15841,19 @@ function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
+    const alreadyLoadedModulesByDynamicEntry = getAlreadyLoadedModulesByDynamicEntry(entries);
     const assignedEntryPointsByModule = new Map();
-    const { dependentEntryPointsByModule, dynamicEntryModules } = analyzeModuleGraph(entryModules);
-    const dynamicallyDependentEntryPointsByDynamicEntry = getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules);
-    const staticEntries = new Set(entryModules);
-    function assignEntryToStaticDependencies(entry, dynamicDependentEntryPoints) {
-        const modulesToHandle = new Set([entry]);
-        for (const module of modulesToHandle) {
-            const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
-            if (dynamicDependentEntryPoints &&
-                areEntryPointsContainedOrDynamicallyDependent(dynamicDependentEntryPoints, dependentEntryPointsByModule.get(module))) {
-                continue;
-            }
-            else {
-                assignedEntryPoints.add(entry);
-            }
-            for (const dependency of module.getDependenciesToBeIncluded()) {
-                if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                    modulesToHandle.add(dependency);
-                }
-            }
-        }
-    }
-    function areEntryPointsContainedOrDynamicallyDependent(entryPoints, containedIn) {
-        const entriesToCheck = new Set(entryPoints);
-        for (const entry of entriesToCheck) {
-            if (!containedIn.has(entry)) {
-                if (staticEntries.has(entry))
-                    return false;
-                const dynamicallyDependentEntryPoints = dynamicallyDependentEntryPointsByDynamicEntry.get(entry);
-                for (const dependentEntry of dynamicallyDependentEntryPoints) {
-                    entriesToCheck.add(dependentEntry);
-                }
-            }
-        }
-        return true;
-    }
-    for (const entry of entryModules) {
+    for (const entry of entries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
+            assignEntryToStaticDependencies(entry, undefined, assignedEntryPointsByModule, modulesInManualChunks);
         }
     }
-    for (const entry of dynamicEntryModules) {
+    for (const entry of alreadyLoadedModulesByDynamicEntry.keys()) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
+            assignEntryToStaticDependencies(entry, alreadyLoadedModulesByDynamicEntry.get(entry), assignedEntryPointsByModule, modulesInManualChunks);
         }
     }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule, minChunkSize));
+    chunkDefinitions.push(...createChunks([...entries, ...alreadyLoadedModulesByDynamicEntry.keys()], assignedEntryPointsByModule, minChunkSize));
     return chunkDefinitions;
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
@@ -15902,47 +15868,87 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
         }
     }
 }
-function analyzeModuleGraph(entryModules) {
-    const dynamicEntryModules = new Set();
+function getAlreadyLoadedModulesByDynamicEntry(entryModules) {
+    const allModules = new Set(entryModules);
     const dependentEntryPointsByModule = new Map();
+    const dynamicImportsByEntry = new Map();
+    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
     const entriesToHandle = new Set(entryModules);
     for (const currentEntry of entriesToHandle) {
         const modulesToHandle = new Set([currentEntry]);
+        const dynamicImports = new Set();
+        dynamicImportsByEntry.set(currentEntry, dynamicImports);
         for (const module of modulesToHandle) {
             getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
             for (const dependency of module.getDependenciesToBeIncluded()) {
                 if (!(dependency instanceof ExternalModule)) {
                     modulesToHandle.add(dependency);
+                    allModules.add(dependency);
                 }
             }
             for (const { resolution } of module.dynamicImports) {
                 if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
-                    dynamicEntryModules.add(resolution);
+                    dynamicImports.add(resolution);
+                    getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, resolution, () => new Set()).add(currentEntry);
                     entriesToHandle.add(resolution);
+                    allModules.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicEntryModules.add(dependency);
+                dynamicImports.add(dependency);
+                getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dependency, () => new Set()).add(currentEntry);
                 entriesToHandle.add(dependency);
+                allModules.add(dependency);
             }
         }
     }
-    return { dependentEntryPointsByModule, dynamicEntryModules };
+    return buildAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry);
 }
-function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntryModules) {
-        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
-        for (const importer of [
-            ...dynamicEntry.includedDynamicImporters,
-            ...dynamicEntry.implicitlyLoadedAfter
-        ]) {
-            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
-                dynamicDependentEntryPoints.add(entryPoint);
+function buildAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry) {
+    const alreadyLoadedModulesByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicallyDependentEntryPointsByDynamicEntry.keys()) {
+        alreadyLoadedModulesByDynamicEntry.set(dynamicEntry, new Set());
+    }
+    for (const module of allModules) {
+        const dependentEntryPoints = dependentEntryPointsByModule.get(module);
+        for (const entry of dependentEntryPoints) {
+            const dynamicEntriesToHandle = [...dynamicImportsByEntry.get(entry)];
+            nextDynamicEntry: for (const dynamicEntry of dynamicEntriesToHandle) {
+                const alreadyLoadedModules = alreadyLoadedModulesByDynamicEntry.get(dynamicEntry);
+                if (alreadyLoadedModules.has(module)) {
+                    continue;
+                }
+                for (const siblingDependentEntry of dynamicallyDependentEntryPointsByDynamicEntry.get(dynamicEntry)) {
+                    if (!(dependentEntryPoints.has(siblingDependentEntry) ||
+                        alreadyLoadedModulesByDynamicEntry.get(siblingDependentEntry)?.has(module))) {
+                        continue nextDynamicEntry;
+                    }
+                }
+                alreadyLoadedModules.add(module);
+                dynamicEntriesToHandle.push(...dynamicImportsByEntry.get(dynamicEntry));
+            }
+        }
+    }
+    return alreadyLoadedModulesByDynamicEntry;
+}
+function assignEntryToStaticDependencies(entry, alreadyLoadedModules, assignedEntryPointsByModule, modulesInManualChunks) {
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
+        // If the module is "already loaded" for this dynamic entry, we do not need
+        // to mark it for this dynamic entry
+        if (alreadyLoadedModules?.has(module)) {
+            continue;
+        }
+        else {
+            assignedEntryPoints.add(entry);
+        }
+        for (const dependency of module.getDependenciesToBeIncluded()) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
             }
         }
     }
-    return dynamicallyDependentEntryPointsByDynamicEntry;
 }
 function createChunks(allEntryPoints, assignedEntryPointsByModule, minChunkSize) {
     const chunkModulesBySignature = getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints);
@@ -16023,9 +16029,24 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
         let size = 0;
         let pure = true;
+        const dependencies = new Set();
+        const transitiveDependencies = new Set();
         for (const module of modules) {
             pure && (pure = !module.hasEffects());
             size += module.magicString.toString().length;
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    dependencies.add(dependency);
+                    transitiveDependencies.add(dependency);
+                }
+            }
+        }
+        for (const module of transitiveDependencies) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    transitiveDependencies.add(dependency);
+                }
+            }
         }
         (size < minChunkSize
             ? pure
@@ -16033,7 +16054,7 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
                 : smallSideEffectChunks
             : pure
                 ? bigPureChunks
-                : bigSideEffectChunks).push({ modules, pure, signature, size });
+                : bigSideEffectChunks).push({ dependencies, modules, pure, signature, size, transitiveDependencies });
     }
     for (const chunks of [
         bigPureChunks,
@@ -16062,11 +16083,11 @@ function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartitio
             const distance = pure
                 ? getSignatureDistance(signature, targetChunk.signature, !targetChunk.pure)
                 : getSignatureDistance(targetChunk.signature, signature, true);
-            if (distance === 1) {
-                closestChunk = targetChunk;
-                break;
-            }
-            else if (distance < closestChunkDistance) {
+            if (distance < closestChunkDistance && isValidMerge(mergedChunk, targetChunk)) {
+                if (distance === 1) {
+                    closestChunk = targetChunk;
+                    break;
+                }
                 closestChunk = targetChunk;
                 closestChunkDistance = distance;
             }
@@ -16078,10 +16099,30 @@ function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartitio
             closestChunk.size += size;
             closestChunk.pure && (closestChunk.pure = pure);
             closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
+            const { dependencies, transitiveDependencies } = closestChunk;
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+            }
+            for (const dependency of mergedChunk.transitiveDependencies) {
+                transitiveDependencies.add(dependency);
+            }
             getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
         }
     }
 }
+// If a module is a transitive but not a direct dependency of the other chunk,
+// merging is prohibited as that would create a new cyclic dependency.
+function isValidMerge(mergedChunk, targetChunk) {
+    for (const module of mergedChunk.modules) {
+        if (targetChunk.transitiveDependencies.has(module) && !targetChunk.dependencies.has(module))
+            return false;
+    }
+    for (const module of targetChunk.modules) {
+        if (mergedChunk.transitiveDependencies.has(module) && !mergedChunk.dependencies.has(module))
+            return false;
+    }
+    return true;
+}
 function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
     const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
     return chunk.pure ? subPartition.pure : subPartition.sideEffect;

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/rollup.d.ts

@@ -927,3 +927,8 @@ interface AcornNode {
 
 export function defineConfig(options: RollupOptions): RollupOptions;
 export function defineConfig(options: RollupOptions[]): RollupOptions[];
+export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction;
+
+export type RollupOptionsFunction = (
+	commandLineArguments: Record<string, any>
+) => MaybePromise<RollupOptions | RollupOptions[]>;

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.6.0-0";
+var version$1 = "3.6.0-1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -2828,7 +2828,7 @@ function formatAssertions(assertions, { getObject }) {
 
 function getOrCreate(map, key, init) {
     const existing = map.get(key);
-    if (existing) {
+    if (existing !== undefined) {
         return existing;
     }
     const value = init();
@@ -16346,7 +16346,7 @@ function* concatLazy(iterables) {
     }
 }
 
-function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize) {
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
@@ -16356,53 +16356,19 @@ function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
+    const alreadyLoadedModulesByDynamicEntry = getAlreadyLoadedModulesByDynamicEntry(entries);
     const assignedEntryPointsByModule = new Map();
-    const { dependentEntryPointsByModule, dynamicEntryModules } = analyzeModuleGraph(entryModules);
-    const dynamicallyDependentEntryPointsByDynamicEntry = getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules);
-    const staticEntries = new Set(entryModules);
-    function assignEntryToStaticDependencies(entry, dynamicDependentEntryPoints) {
-        const modulesToHandle = new Set([entry]);
-        for (const module of modulesToHandle) {
-            const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
-            if (dynamicDependentEntryPoints &&
-                areEntryPointsContainedOrDynamicallyDependent(dynamicDependentEntryPoints, dependentEntryPointsByModule.get(module))) {
-                continue;
-            }
-            else {
-                assignedEntryPoints.add(entry);
-            }
-            for (const dependency of module.getDependenciesToBeIncluded()) {
-                if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                    modulesToHandle.add(dependency);
-                }
-            }
-        }
-    }
-    function areEntryPointsContainedOrDynamicallyDependent(entryPoints, containedIn) {
-        const entriesToCheck = new Set(entryPoints);
-        for (const entry of entriesToCheck) {
-            if (!containedIn.has(entry)) {
-                if (staticEntries.has(entry))
-                    return false;
-                const dynamicallyDependentEntryPoints = dynamicallyDependentEntryPointsByDynamicEntry.get(entry);
-                for (const dependentEntry of dynamicallyDependentEntryPoints) {
-                    entriesToCheck.add(dependentEntry);
-                }
-            }
-        }
-        return true;
-    }
-    for (const entry of entryModules) {
+    for (const entry of entries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
+            assignEntryToStaticDependencies(entry, undefined, assignedEntryPointsByModule, modulesInManualChunks);
         }
     }
-    for (const entry of dynamicEntryModules) {
+    for (const entry of alreadyLoadedModulesByDynamicEntry.keys()) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
+            assignEntryToStaticDependencies(entry, alreadyLoadedModulesByDynamicEntry.get(entry), assignedEntryPointsByModule, modulesInManualChunks);
         }
     }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule, minChunkSize));
+    chunkDefinitions.push(...createChunks([...entries, ...alreadyLoadedModulesByDynamicEntry.keys()], assignedEntryPointsByModule, minChunkSize));
     return chunkDefinitions;
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
@@ -16417,47 +16383,87 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
         }
     }
 }
-function analyzeModuleGraph(entryModules) {
-    const dynamicEntryModules = new Set();
+function getAlreadyLoadedModulesByDynamicEntry(entryModules) {
+    const allModules = new Set(entryModules);
     const dependentEntryPointsByModule = new Map();
+    const dynamicImportsByEntry = new Map();
+    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
     const entriesToHandle = new Set(entryModules);
     for (const currentEntry of entriesToHandle) {
         const modulesToHandle = new Set([currentEntry]);
+        const dynamicImports = new Set();
+        dynamicImportsByEntry.set(currentEntry, dynamicImports);
         for (const module of modulesToHandle) {
             getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
             for (const dependency of module.getDependenciesToBeIncluded()) {
                 if (!(dependency instanceof ExternalModule)) {
                     modulesToHandle.add(dependency);
+                    allModules.add(dependency);
                 }
             }
             for (const { resolution } of module.dynamicImports) {
                 if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
-                    dynamicEntryModules.add(resolution);
+                    dynamicImports.add(resolution);
+                    getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, resolution, () => new Set()).add(currentEntry);
                     entriesToHandle.add(resolution);
+                    allModules.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicEntryModules.add(dependency);
+                dynamicImports.add(dependency);
+                getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dependency, () => new Set()).add(currentEntry);
                 entriesToHandle.add(dependency);
+                allModules.add(dependency);
             }
         }
     }
-    return { dependentEntryPointsByModule, dynamicEntryModules };
+    return buildAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry);
 }
-function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntryModules) {
-        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
-        for (const importer of [
-            ...dynamicEntry.includedDynamicImporters,
-            ...dynamicEntry.implicitlyLoadedAfter
-        ]) {
-            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
-                dynamicDependentEntryPoints.add(entryPoint);
+function buildAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry) {
+    const alreadyLoadedModulesByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicallyDependentEntryPointsByDynamicEntry.keys()) {
+        alreadyLoadedModulesByDynamicEntry.set(dynamicEntry, new Set());
+    }
+    for (const module of allModules) {
+        const dependentEntryPoints = dependentEntryPointsByModule.get(module);
+        for (const entry of dependentEntryPoints) {
+            const dynamicEntriesToHandle = [...dynamicImportsByEntry.get(entry)];
+            nextDynamicEntry: for (const dynamicEntry of dynamicEntriesToHandle) {
+                const alreadyLoadedModules = alreadyLoadedModulesByDynamicEntry.get(dynamicEntry);
+                if (alreadyLoadedModules.has(module)) {
+                    continue;
+                }
+                for (const siblingDependentEntry of dynamicallyDependentEntryPointsByDynamicEntry.get(dynamicEntry)) {
+                    if (!(dependentEntryPoints.has(siblingDependentEntry) ||
+                        alreadyLoadedModulesByDynamicEntry.get(siblingDependentEntry)?.has(module))) {
+                        continue nextDynamicEntry;
+                    }
+                }
+                alreadyLoadedModules.add(module);
+                dynamicEntriesToHandle.push(...dynamicImportsByEntry.get(dynamicEntry));
+            }
+        }
+    }
+    return alreadyLoadedModulesByDynamicEntry;
+}
+function assignEntryToStaticDependencies(entry, alreadyLoadedModules, assignedEntryPointsByModule, modulesInManualChunks) {
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
+        // If the module is "already loaded" for this dynamic entry, we do not need
+        // to mark it for this dynamic entry
+        if (alreadyLoadedModules?.has(module)) {
+            continue;
+        }
+        else {
+            assignedEntryPoints.add(entry);
+        }
+        for (const dependency of module.getDependenciesToBeIncluded()) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
             }
         }
     }
-    return dynamicallyDependentEntryPointsByDynamicEntry;
 }
 function createChunks(allEntryPoints, assignedEntryPointsByModule, minChunkSize) {
     const chunkModulesBySignature = getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints);
@@ -16538,9 +16544,24 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
         let size = 0;
         let pure = true;
+        const dependencies = new Set();
+        const transitiveDependencies = new Set();
         for (const module of modules) {
             pure && (pure = !module.hasEffects());
             size += module.magicString.toString().length;
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    dependencies.add(dependency);
+                    transitiveDependencies.add(dependency);
+                }
+            }
+        }
+        for (const module of transitiveDependencies) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    transitiveDependencies.add(dependency);
+                }
+            }
         }
         (size < minChunkSize
             ? pure
@@ -16548,7 +16569,7 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
                 : smallSideEffectChunks
             : pure
                 ? bigPureChunks
-                : bigSideEffectChunks).push({ modules, pure, signature, size });
+                : bigSideEffectChunks).push({ dependencies, modules, pure, signature, size, transitiveDependencies });
     }
     for (const chunks of [
         bigPureChunks,
@@ -16577,11 +16598,11 @@ function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartitio
             const distance = pure
                 ? getSignatureDistance(signature, targetChunk.signature, !targetChunk.pure)
                 : getSignatureDistance(targetChunk.signature, signature, true);
-            if (distance === 1) {
-                closestChunk = targetChunk;
-                break;
-            }
-            else if (distance < closestChunkDistance) {
+            if (distance < closestChunkDistance && isValidMerge(mergedChunk, targetChunk)) {
+                if (distance === 1) {
+                    closestChunk = targetChunk;
+                    break;
+                }
                 closestChunk = targetChunk;
                 closestChunkDistance = distance;
             }
@@ -16593,10 +16614,30 @@ function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartitio
             closestChunk.size += size;
             closestChunk.pure && (closestChunk.pure = pure);
             closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
+            const { dependencies, transitiveDependencies } = closestChunk;
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+            }
+            for (const dependency of mergedChunk.transitiveDependencies) {
+                transitiveDependencies.add(dependency);
+            }
             getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
         }
     }
 }
+// If a module is a transitive but not a direct dependency of the other chunk,
+// merging is prohibited as that would create a new cyclic dependency.
+function isValidMerge(mergedChunk, targetChunk) {
+    for (const module of mergedChunk.modules) {
+        if (targetChunk.transitiveDependencies.has(module) && !targetChunk.dependencies.has(module))
+            return false;
+    }
+    for (const module of targetChunk.modules) {
+        if (mergedChunk.transitiveDependencies.has(module) && !mergedChunk.dependencies.has(module))
+            return false;
+    }
+    return true;
+}
 function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
     const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
     return chunk.pure ? subPartition.pure : subPartition.sideEffect;

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.6.0-0
-	Sun, 27 Nov 2022 06:53:45 GMT - commit 03fdcc007bd49a4c88579d93053248ebe03dcef9
+	Rollup.js v3.6.0-1
+	Mon, 05 Dec 2022 08:32:45 GMT - commit ae777941edd1a39ab3007c6c6fffee0c17c96b2f
 
 	https://github.com/rollup/rollup
 

package/package.json

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