rollup 3.7.1 → 3.7.2

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	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.7.1";
+var version$1 = "3.7.2";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1681,13 +1681,19 @@ 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();
     map.set(key, value);
     return value;
 }
+function getNewSet() {
+    return new Set();
+}
+function getNewArray() {
+    return [];
+}
 
 const UnknownKey = Symbol('Unknown Key');
 const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
@@ -1749,7 +1755,7 @@ class DiscriminatedPathTracker {
                 currentPaths[pathSegment] ||
                     Object.create(null, { [EntitiesKey]: { value: new Map() } });
         }
-        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, () => new Set());
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, getNewSet);
         if (trackedEntities.has(entity))
             return true;
         trackedEntities.add(entity);
@@ -12754,7 +12760,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
-    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, () => new Set());
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, getNewSet);
     let currentVariable = variable;
     const referencedVariables = new Set([currentVariable]);
     while (true) {
@@ -13093,7 +13099,7 @@ class Module {
                 searchedNamesAndModules
             });
             if (importerForSideEffects) {
-                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, () => new Set()).add(this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, getNewSet).add(this);
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
             return [variable];
@@ -15321,7 +15327,7 @@ class Chunk {
                 dependency = this.chunkByModule.get(module);
                 imported = dependency.getVariableExportName(variable);
             }
-            getOrCreate(importsByDependency, dependency, () => []).push({
+            getOrCreate(importsByDependency, dependency, getNewArray).push({
                 imported,
                 local: variable.getName(this.snippets.getPropertyAccess)
             });
@@ -15433,7 +15439,7 @@ class Chunk {
                             (imported !== 'default' || isDefaultAProperty(interop(module.id), true));
                 }
             }
-            getOrCreate(reexportSpecifiers, dependency, () => []).push({
+            getOrCreate(reexportSpecifiers, dependency, getNewArray).push({
                 imported,
                 needsLiveBinding,
                 reexported: exportName
@@ -15734,7 +15740,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);
@@ -15744,53 +15750,15 @@ function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
-    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) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
-        }
-    }
-    for (const entry of dynamicEntryModules) {
+    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry } = analyzeModuleGraph(entries);
+    const staticEntries = new Set(entries);
+    const assignedEntriesByModule = new Map();
+    for (const entry of allEntries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
+            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry);
         }
     }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule, minChunkSize));
+    chunkDefinitions.push(...createChunks(allEntries, assignedEntriesByModule, minChunkSize));
     return chunkDefinitions;
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
@@ -15805,50 +15773,103 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
         }
     }
 }
-function analyzeModuleGraph(entryModules) {
-    const dynamicEntryModules = new Set();
-    const dependentEntryPointsByModule = new Map();
-    const entriesToHandle = new Set(entryModules);
-    for (const currentEntry of entriesToHandle) {
+function analyzeModuleGraph(entries) {
+    const dynamicEntries = new Set();
+    const dependentEntriesByModule = new Map();
+    const allEntries = new Set(entries);
+    for (const currentEntry of allEntries) {
         const modulesToHandle = new Set([currentEntry]);
         for (const module of modulesToHandle) {
-            getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
+            getOrCreate(dependentEntriesByModule, module, getNewSet).add(currentEntry);
             for (const dependency of module.getDependenciesToBeIncluded()) {
                 if (!(dependency instanceof ExternalModule)) {
                     modulesToHandle.add(dependency);
                 }
             }
             for (const { resolution } of module.dynamicImports) {
-                if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
-                    dynamicEntryModules.add(resolution);
-                    entriesToHandle.add(resolution);
+                if (resolution instanceof Module &&
+                    resolution.includedDynamicImporters.length > 0 &&
+                    !allEntries.has(resolution)) {
+                    dynamicEntries.add(resolution);
+                    allEntries.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicEntryModules.add(dependency);
-                entriesToHandle.add(dependency);
+                if (!allEntries.has(dependency)) {
+                    dynamicEntries.add(dependency);
+                    allEntries.add(dependency);
+                }
             }
         }
     }
-    return { dependentEntryPointsByModule, dynamicEntryModules };
+    return {
+        allEntries,
+        dependentEntriesByModule,
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries)
+    };
 }
-function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntryModules) {
-        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries) {
+    const dynamicallyDependentEntriesByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicEntries) {
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, getNewSet);
         for (const importer of [
             ...dynamicEntry.includedDynamicImporters,
             ...dynamicEntry.implicitlyLoadedAfter
         ]) {
-            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
-                dynamicDependentEntryPoints.add(entryPoint);
+            for (const entry of dependentEntriesByModule.get(importer)) {
+                dynamicallyDependentEntries.add(entry);
+            }
+        }
+    }
+    return dynamicallyDependentEntriesByDynamicEntry;
+}
+function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        const assignedEntries = getOrCreate(assignedEntriesByModule, module, getNewSet);
+        if (dynamicallyDependentEntries &&
+            isModuleAlreadyLoaded(dynamicallyDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry)) {
+            continue;
+        }
+        else {
+            assignedEntries.add(entry);
+        }
+        for (const dependency of module.getDependenciesToBeIncluded()) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
+            }
+        }
+    }
+}
+const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
+// An approach to further speed this up might be
+// - first, create chunks without looking for modules already in memory
+// - all modules that are in the same chunk after this will behave the same
+//   -> Do not iterate by module but by equivalence group and merge chunks
+function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+        return false;
+    }
+    const entriesToCheck = new Set(dynamicallyDependentEntries);
+    for (const entry of entriesToCheck) {
+        if (!containedIn.has(entry)) {
+            if (staticEntries.has(entry)) {
+                return false;
+            }
+            const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+            if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+                return false;
+            }
+            for (const dependentEntry of dynamicallyDependentEntries) {
+                entriesToCheck.add(dependentEntry);
             }
         }
     }
-    return dynamicallyDependentEntryPointsByDynamicEntry;
+    return true;
 }
-function createChunks(allEntryPoints, assignedEntryPointsByModule, minChunkSize) {
-    const chunkModulesBySignature = getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints);
+function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
+    const chunkModulesBySignature = getChunkModulesBySignature(assignedEntriesByModule, allEntries);
     return minChunkSize === 0
         ? Object.values(chunkModulesBySignature).map(modules => ({
             alias: null,
@@ -15895,12 +15916,12 @@ function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
 const CHAR_DEPENDENT = 'X';
 const CHAR_INDEPENDENT = '_';
 const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
-function getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints) {
+function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     const chunkModules = Object.create(null);
-    for (const [module, assignedEntryPoints] of assignedEntryPointsByModule) {
+    for (const [module, assignedEntries] of assignedEntriesByModule) {
         let chunkSignature = '';
-        for (const entry of allEntryPoints) {
-            chunkSignature += assignedEntryPoints.has(entry) ? CHAR_DEPENDENT : CHAR_INDEPENDENT;
+        for (const entry of allEntries) {
+            chunkSignature += assignedEntries.has(entry) ? CHAR_DEPENDENT : CHAR_INDEPENDENT;
         }
         const chunk = chunkModules[chunkSignature];
         if (chunk) {

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 
@@ -24,7 +24,7 @@ function batchWarnings() {
             count += 1;
             warningOccurred = true;
             if (warning.code in deferredHandlers) {
-                rollup.getOrCreate(deferredWarnings, warning.code, () => []).push(warning);
+                rollup.getOrCreate(deferredWarnings, warning.code, rollup.getNewArray).push(warning);
             }
             else if (warning.code in immediateHandlers) {
                 immediateHandlers[warning.code](warning);
@@ -169,7 +169,7 @@ const deferredHandlers = {
         info('https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency');
         const dependencies = new Map();
         for (const warning of warnings) {
-            rollup.getOrCreate(dependencies, rollup.relativeId(warning.exporter), () => []).push(rollup.relativeId(warning.id));
+            rollup.getOrCreate(dependencies, rollup.relativeId(warning.exporter), rollup.getNewArray).push(rollup.relativeId(warning.id));
         }
         for (const [dependency, importers] of dependencies) {
             rollup.stderr(`${rollup.bold(dependency)} (imported by ${rollup.printQuotedStringList(importers)})`);

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.7.1";
+var version$1 = "3.7.2";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -2829,13 +2829,19 @@ function formatAssertions(assertions, { getObject }) {
 
 function getOrCreate(map, key, init) {
     const existing = map.get(key);
-    if (existing) {
+    if (existing !== undefined) {
         return existing;
     }
     const value = init();
     map.set(key, value);
     return value;
 }
+function getNewSet() {
+    return new Set();
+}
+function getNewArray() {
+    return [];
+}
 
 const UnknownKey = Symbol('Unknown Key');
 const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
@@ -2897,7 +2903,7 @@ class DiscriminatedPathTracker {
                 currentPaths[pathSegment] ||
                     Object.create(null, { [EntitiesKey]: { value: new Map() } });
         }
-        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, () => new Set());
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, getNewSet);
         if (trackedEntities.has(entity))
             return true;
         trackedEntities.add(entity);
@@ -13269,7 +13275,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
-    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, () => new Set());
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, getNewSet);
     let currentVariable = variable;
     const referencedVariables = new Set([currentVariable]);
     while (true) {
@@ -13608,7 +13614,7 @@ class Module {
                 searchedNamesAndModules
             });
             if (importerForSideEffects) {
-                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, () => new Set()).add(this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, getNewSet).add(this);
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
             return [variable];
@@ -15836,7 +15842,7 @@ class Chunk {
                 dependency = this.chunkByModule.get(module);
                 imported = dependency.getVariableExportName(variable);
             }
-            getOrCreate(importsByDependency, dependency, () => []).push({
+            getOrCreate(importsByDependency, dependency, getNewArray).push({
                 imported,
                 local: variable.getName(this.snippets.getPropertyAccess)
             });
@@ -15948,7 +15954,7 @@ class Chunk {
                             (imported !== 'default' || isDefaultAProperty(interop(module.id), true));
                 }
             }
-            getOrCreate(reexportSpecifiers, dependency, () => []).push({
+            getOrCreate(reexportSpecifiers, dependency, getNewArray).push({
                 imported,
                 needsLiveBinding,
                 reexported: exportName
@@ -16249,7 +16255,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);
@@ -16259,53 +16265,15 @@ function getChunkAssignments(entryModules, manualChunkAliasByEntry, minChunkSize
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
-    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) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
-        }
-    }
-    for (const entry of dynamicEntryModules) {
+    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry } = analyzeModuleGraph(entries);
+    const staticEntries = new Set(entries);
+    const assignedEntriesByModule = new Map();
+    for (const entry of allEntries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
+            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry);
         }
     }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule, minChunkSize));
+    chunkDefinitions.push(...createChunks(allEntries, assignedEntriesByModule, minChunkSize));
     return chunkDefinitions;
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
@@ -16320,50 +16288,103 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
         }
     }
 }
-function analyzeModuleGraph(entryModules) {
-    const dynamicEntryModules = new Set();
-    const dependentEntryPointsByModule = new Map();
-    const entriesToHandle = new Set(entryModules);
-    for (const currentEntry of entriesToHandle) {
+function analyzeModuleGraph(entries) {
+    const dynamicEntries = new Set();
+    const dependentEntriesByModule = new Map();
+    const allEntries = new Set(entries);
+    for (const currentEntry of allEntries) {
         const modulesToHandle = new Set([currentEntry]);
         for (const module of modulesToHandle) {
-            getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
+            getOrCreate(dependentEntriesByModule, module, getNewSet).add(currentEntry);
             for (const dependency of module.getDependenciesToBeIncluded()) {
                 if (!(dependency instanceof ExternalModule)) {
                     modulesToHandle.add(dependency);
                 }
             }
             for (const { resolution } of module.dynamicImports) {
-                if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
-                    dynamicEntryModules.add(resolution);
-                    entriesToHandle.add(resolution);
+                if (resolution instanceof Module &&
+                    resolution.includedDynamicImporters.length > 0 &&
+                    !allEntries.has(resolution)) {
+                    dynamicEntries.add(resolution);
+                    allEntries.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicEntryModules.add(dependency);
-                entriesToHandle.add(dependency);
+                if (!allEntries.has(dependency)) {
+                    dynamicEntries.add(dependency);
+                    allEntries.add(dependency);
+                }
             }
         }
     }
-    return { dependentEntryPointsByModule, dynamicEntryModules };
+    return {
+        allEntries,
+        dependentEntriesByModule,
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries)
+    };
 }
-function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntryModules) {
-        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries) {
+    const dynamicallyDependentEntriesByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicEntries) {
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, getNewSet);
         for (const importer of [
             ...dynamicEntry.includedDynamicImporters,
             ...dynamicEntry.implicitlyLoadedAfter
         ]) {
-            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
-                dynamicDependentEntryPoints.add(entryPoint);
+            for (const entry of dependentEntriesByModule.get(importer)) {
+                dynamicallyDependentEntries.add(entry);
+            }
+        }
+    }
+    return dynamicallyDependentEntriesByDynamicEntry;
+}
+function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        const assignedEntries = getOrCreate(assignedEntriesByModule, module, getNewSet);
+        if (dynamicallyDependentEntries &&
+            isModuleAlreadyLoaded(dynamicallyDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry)) {
+            continue;
+        }
+        else {
+            assignedEntries.add(entry);
+        }
+        for (const dependency of module.getDependenciesToBeIncluded()) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
+            }
+        }
+    }
+}
+const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
+// An approach to further speed this up might be
+// - first, create chunks without looking for modules already in memory
+// - all modules that are in the same chunk after this will behave the same
+//   -> Do not iterate by module but by equivalence group and merge chunks
+function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+        return false;
+    }
+    const entriesToCheck = new Set(dynamicallyDependentEntries);
+    for (const entry of entriesToCheck) {
+        if (!containedIn.has(entry)) {
+            if (staticEntries.has(entry)) {
+                return false;
+            }
+            const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+            if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+                return false;
+            }
+            for (const dependentEntry of dynamicallyDependentEntries) {
+                entriesToCheck.add(dependentEntry);
             }
         }
     }
-    return dynamicallyDependentEntryPointsByDynamicEntry;
+    return true;
 }
-function createChunks(allEntryPoints, assignedEntryPointsByModule, minChunkSize) {
-    const chunkModulesBySignature = getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints);
+function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
+    const chunkModulesBySignature = getChunkModulesBySignature(assignedEntriesByModule, allEntries);
     return minChunkSize === 0
         ? Object.values(chunkModulesBySignature).map(modules => ({
             alias: null,
@@ -16410,12 +16431,12 @@ function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
 const CHAR_DEPENDENT = 'X';
 const CHAR_INDEPENDENT = '_';
 const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
-function getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints) {
+function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     const chunkModules = Object.create(null);
-    for (const [module, assignedEntryPoints] of assignedEntryPointsByModule) {
+    for (const [module, assignedEntries] of assignedEntriesByModule) {
         let chunkSignature = '';
-        for (const entry of allEntryPoints) {
-            chunkSignature += assignedEntryPoints.has(entry) ? CHAR_DEPENDENT : CHAR_INDEPENDENT;
+        for (const entry of allEntries) {
+            chunkSignature += assignedEntries.has(entry) ? CHAR_DEPENDENT : CHAR_INDEPENDENT;
         }
         const chunk = chunkModules[chunkSignature];
         if (chunk) {
@@ -25273,6 +25294,7 @@ exports.errorOnlyInlineSourcemapsForStdout = errorOnlyInlineSourcemapsForStdout;
 exports.fseventsImporter = fseventsImporter;
 exports.getAliasName = getAliasName;
 exports.getAugmentedNamespace = getAugmentedNamespace;
+exports.getNewArray = getNewArray;
 exports.getOrCreate = getOrCreate;
 exports.gray = gray;
 exports.green = green;

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1
-	Fri, 09 Dec 2022 19:58:22 GMT - commit cc54a2439bb274d91c74cc74a70e4c25e3dbb206
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/package.json

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