rollup 2.77.4-0 → 2.77.4-1

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/dist/shared/mergeOptions.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.77.4-0";
+var version$1 = "2.77.4-1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -15794,39 +15794,15 @@ function getChunkAssignments(entryModules, manualChunkAliasByEntry) {
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
-    const assignedEntryPointsByModule = new Map();
-    const { allModules, dependentEntryPointsByModule, dynamicallyDependentEntryPointsByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entryModules);
-    const alreadyLoadedModulesByDynamicEntry = getAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry);
-    function assignEntryToStaticDependencies(entry, alreadyLoadedModules) {
-        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 === null || alreadyLoadedModules === void 0 ? void 0 : alreadyLoadedModules.has(module)) {
-                continue;
-            }
-            else {
-                assignedEntryPoints.add(entry);
-            }
-            for (const dependency of module.getDependenciesToBeIncluded()) {
-                if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                    modulesToHandle.add(dependency);
-                }
-            }
-        }
-    }
-    for (const entry of entryModules) {
+    const { dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicEntryModules } = analyzeModuleGraph(entryModules);
+    const staticEntries = new Set(entryModules);
+    const assignedEntriesByModule = new Map();
+    for (const entry of [...entryModules, ...dynamicEntryModules]) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
+            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry);
         }
     }
-    for (const entry of dynamicallyDependentEntryPointsByDynamicEntry.keys()) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, alreadyLoadedModulesByDynamicEntry.get(entry) || null);
-        }
-    }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicallyDependentEntryPointsByDynamicEntry.keys()], assignedEntryPointsByModule));
+    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntriesByModule));
     return chunkDefinitions;
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
@@ -15842,76 +15818,102 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
     }
 }
 function analyzeModuleGraph(entryModules) {
-    const allModules = new Set(entryModules);
-    const dependentEntryPointsByModule = new Map();
-    const dynamicImportsByEntry = new Map();
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
+    const dynamicEntryModules = new Set();
+    const dependentEntriesByModule = 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);
+            getOrCreate(dependentEntriesByModule, 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) {
-                    dynamicImports.add(resolution);
-                    getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, resolution, () => new Set()).add(currentEntry);
+                if (resolution instanceof Module &&
+                    resolution.includedDynamicImporters.length > 0 &&
+                    !entriesToHandle.has(resolution)) {
+                    dynamicEntryModules.add(resolution);
                     entriesToHandle.add(resolution);
-                    allModules.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicImports.add(dependency);
-                getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dependency, () => new Set()).add(currentEntry);
-                entriesToHandle.add(dependency);
-                allModules.add(dependency);
+                if (!entriesToHandle.has(dependency)) {
+                    dynamicEntryModules.add(dependency);
+                    entriesToHandle.add(dependency);
+                }
             }
         }
     }
     return {
-        allModules,
-        dependentEntryPointsByModule,
-        dynamicallyDependentEntryPointsByDynamicEntry,
-        dynamicImportsByEntry
+        dependentEntriesByModule,
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntryModules),
+        dynamicEntryModules
     };
 }
-function getAlreadyLoadedModulesByDynamicEntry(allModules, dependentEntryPointsByModule, dynamicImportsByEntry, dynamicallyDependentEntryPointsByDynamicEntry) {
-    var _a, _b;
-    const alreadyLoadedModulesByEntry = new Map();
-    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) {
-                if ((_a = alreadyLoadedModulesByEntry.get(dynamicEntry)) === null || _a === void 0 ? void 0 : _a.has(module)) {
-                    continue;
-                }
-                for (const siblingDependentEntry of dynamicallyDependentEntryPointsByDynamicEntry.get(dynamicEntry)) {
-                    if (!(dependentEntryPoints.has(siblingDependentEntry) ||
-                        ((_b = alreadyLoadedModulesByEntry.get(siblingDependentEntry)) === null || _b === void 0 ? void 0 : _b.has(module)))) {
-                        continue nextDynamicEntry;
-                    }
-                }
-                getOrCreate(alreadyLoadedModulesByEntry, dynamicEntry, () => new Set()).add(module);
-                dynamicEntriesToHandle.push(...dynamicImportsByEntry.get(dynamicEntry));
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntryModules) {
+    const dynamicallyDependentEntriesByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicEntryModules) {
+        const dynamicDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, () => new Set());
+        for (const importer of [
+            ...dynamicEntry.includedDynamicImporters,
+            ...dynamicEntry.implicitlyLoadedAfter
+        ]) {
+            for (const entry of dependentEntriesByModule.get(importer)) {
+                dynamicDependentEntries.add(entry);
             }
         }
     }
-    return alreadyLoadedModulesByEntry;
+    return dynamicallyDependentEntriesByDynamicEntry;
+}
+function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    const dynamicDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        const assignedEntries = getOrCreate(assignedEntriesByModule, module, () => new Set());
+        if (dynamicDependentEntries &&
+            areEntriesContainedOrDynamicallyDependent(dynamicDependentEntries, 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;
+function areEntriesContainedOrDynamicallyDependent(entries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+    if (entries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+        return false;
+    }
+    const entriesToCheck = new Set(entries);
+    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 true;
 }
-function createChunks(allEntryPoints, assignedEntryPointsByModule) {
+function createChunks(allEntries, assignedEntriesByModule) {
     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) ? 'X' : '_';
+        for (const entry of allEntries) {
+            chunkSignature += assignedEntries.has(entry) ? 'X' : '_';
         }
         const chunk = chunkModules[chunkSignature];
         if (chunk) {

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.4-0
-	Sun, 04 Dec 2022 18:27:04 GMT - commit 43b5e1cddb8a5b9ae0aa6349112523b5b89db783
+	Rollup.js v2.77.4-1
+	Wed, 07 Dec 2022 12:27:15 GMT - commit 79225a51c2fbbc44fe3ea7bb63aa31536c2f2a66
 
 	https://github.com/rollup/rollup
 

package/package.json

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