rollup 3.12.1 → 3.14.0

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	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.12.1";
+var version$1 = "3.14.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -6625,7 +6625,7 @@ class LocalVariable extends Variable {
             case INTERACTION_ACCESSED: {
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
@@ -6636,14 +6636,14 @@ class LocalVariable extends Variable {
                     return false;
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
             case INTERACTION_CALLED: {
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
@@ -11419,12 +11419,14 @@ class PrivateIdentifier extends NodeBase {
 class Program extends NodeBase {
     constructor() {
         super(...arguments);
-        this.hasCachedEffect = false;
+        this.hasCachedEffect = null;
+    }
+    hasCachedEffects() {
+        return this.hasCachedEffect === null
+            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
+            : this.hasCachedEffect;
     }
     hasEffects(context) {
-        // We are caching here to later more efficiently identify side-effect-free modules
-        if (this.hasCachedEffect)
-            return true;
         for (const node of this.body) {
             if (node.hasEffects(context)) {
                 return (this.hasCachedEffect = true);
@@ -13322,8 +13324,7 @@ class Module {
         return [null];
     }
     hasEffects() {
-        return (this.info.moduleSideEffects === 'no-treeshake' ||
-            (this.ast.included && this.ast.hasEffects(createHasEffectsContext())));
+        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
     }
     include() {
         const context = createInclusionContext();
@@ -16041,13 +16042,13 @@ const resolveFileName = (dependency) => dependency.getFileName();
  * their iterators. Useful when e.g. working with large sets or lists and when
  * there is a chance that the iterators will not be fully exhausted.
  */
-function* concatLazy(...iterables) {
+function* concatLazy(iterables) {
     for (const iterable of iterables) {
         yield* iterable;
     }
 }
 
-function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, deepChunkOptimization) {
     const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
@@ -16062,7 +16063,7 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const assignedEntriesByModule = new Map();
     for (const entry of allEntries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry);
+            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization);
         }
     }
     chunkDefinitions.push(...createChunks(allEntries, assignedEntriesByModule, minChunkSize));
@@ -16130,13 +16131,13 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization) {
     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)) {
+            isModuleAlreadyLoaded(dynamicallyDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization)) {
             continue;
         }
         else {
@@ -16154,8 +16155,9 @@ const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
 // - 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) {
+function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization) {
+    if (!deepChunkOptimization &&
+        dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
         return false;
     }
     const entriesToCheck = new Set(dynamicallyDependentEntries);
@@ -16165,7 +16167,8 @@ function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticE
                 return false;
             }
             const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
-            if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+            if (!deepChunkOptimization &&
+                dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
                 return false;
             }
             for (const dependentEntry of dynamicallyDependentEntries) {
@@ -16182,47 +16185,11 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize);
-}
-function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
-    timeStart('optimize chunks', 3);
-    const { chunksToBeMerged, unmergeableChunks } = getMergeableChunks(chunkModulesBySignature, minChunkSize);
-    for (const sourceChunk of chunksToBeMerged) {
-        chunksToBeMerged.delete(sourceChunk);
-        let closestChunk = null;
-        let closestChunkDistance = Infinity;
-        const { signature, size, modules } = sourceChunk;
-        for (const targetChunk of concatLazy(chunksToBeMerged, unmergeableChunks)) {
-            const distance = getSignatureDistance(signature, targetChunk.signature, !chunksToBeMerged.has(targetChunk));
-            if (distance === 1) {
-                closestChunk = targetChunk;
-                break;
-            }
-            else if (distance < closestChunkDistance) {
-                closestChunk = targetChunk;
-                closestChunkDistance = distance;
-            }
-        }
-        if (closestChunk) {
-            closestChunk.modules.push(...modules);
-            if (chunksToBeMerged.has(closestChunk)) {
-                closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
-                if ((closestChunk.size += size) > minChunkSize) {
-                    chunksToBeMerged.delete(closestChunk);
-                    unmergeableChunks.push(closestChunk);
-                }
-            }
-        }
-        else {
-            unmergeableChunks.push(sourceChunk);
-        }
-    }
-    timeEnd('optimize chunks', 3);
-    return unmergeableChunks;
+        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
+            alias: null,
+            modules
+        }));
 }
-const CHAR_DEPENDENT = 'X';
-const CHAR_INDEPENDENT = '_';
-const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
 function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     const chunkModules = Object.create(null);
     for (const [module, assignedEntries] of assignedEntriesByModule) {
@@ -16240,28 +16207,167 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     }
     return chunkModules;
 }
-function getMergeableChunks(chunkModulesBySignature, minChunkSize) {
-    const chunksToBeMerged = new Set();
-    const unmergeableChunks = [];
-    const alias = null;
+/**
+ * This function tries to get rid of small chunks by merging them with other
+ * chunks. In order to merge chunks, one must obey the following rule:
+ * - When merging several chunks, at most one of the chunks can have side
+ *   effects
+ * - When one of the chunks has side effects, the entry points depending on that
+ *   chunk need to be a super set of the entry points depending on the other
+ *   chunks
+ * - Pure chunks can always be merged
+ * - We use the entry point dependence signature to calculate "chunk distance",
+ *   i.e. how likely it is that two chunks are loaded together
+ */
+function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
+    timeStart('optimize chunks', 3);
+    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, minChunkSize);
+    if (chunkPartition.small.sideEffect.size > 0) {
+        mergeChunks(chunkPartition.small.sideEffect, [chunkPartition.small.pure, chunkPartition.big.pure], minChunkSize, chunkPartition);
+    }
+    if (chunkPartition.small.pure.size > 0) {
+        mergeChunks(chunkPartition.small.pure, [chunkPartition.small.pure, chunkPartition.big.sideEffect, chunkPartition.big.pure], minChunkSize, chunkPartition);
+    }
+    timeEnd('optimize chunks', 3);
+    return [
+        ...chunkPartition.small.sideEffect,
+        ...chunkPartition.small.pure,
+        ...chunkPartition.big.sideEffect,
+        ...chunkPartition.big.pure
+    ];
+}
+const CHAR_DEPENDENT = 'X';
+const CHAR_INDEPENDENT = '_';
+const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
+function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
+    const smallPureChunks = [];
+    const bigPureChunks = [];
+    const smallSideEffectChunks = [];
+    const bigSideEffectChunks = [];
+    const chunkByModule = new Map();
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
+        const chunkDescription = {
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            modules,
+            pure: true,
+            signature,
+            size: 0
+        };
         let size = 0;
-        checkModules: {
+        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;
+        }
+        chunkDescription.pure = pure;
+        chunkDescription.size = size;
+        (size < minChunkSize
+            ? pure
+                ? smallPureChunks
+                : smallSideEffectChunks
+            : pure
+                ? bigPureChunks
+                : bigSideEffectChunks).push(chunkDescription);
+    }
+    sortChunksAndAddDependencies([bigPureChunks, bigSideEffectChunks, smallPureChunks, smallSideEffectChunks], chunkByModule);
+    return {
+        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
+        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
+    };
+}
+function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
+    for (const chunks of chunkLists) {
+        chunks.sort(compareChunks);
+        for (const chunk of chunks) {
+            const { dependencies, modules } = chunk;
             for (const module of modules) {
-                if (module.hasEffects()) {
-                    break checkModules;
+                for (const dependency of module.getDependenciesToBeIncluded()) {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
                 }
-                size += module.magicString.toString().length;
-                if (size > minChunkSize) {
-                    break checkModules;
+            }
+        }
+    }
+}
+function compareChunks({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartition) {
+    for (const mergedChunk of chunksToBeMerged) {
+        let closestChunk = null;
+        let closestChunkDistance = Infinity;
+        const { signature, modules, pure, size } = mergedChunk;
+        for (const targetChunk of concatLazy(targetChunks)) {
+            if (mergedChunk === targetChunk)
+                continue;
+            // Possible improvement:
+            // For dynamic entries depending on a pure chunk, it is safe to merge that
+            // chunk into the chunk doing the dynamic import (i.e. into an "already
+            // loaded chunk") even if it is not pure.
+            // One way of handling this could be to add all "already loaded entries"
+            // of the dynamic importers into the signature as well. That could also
+            // change the way we do code-splitting for already loaded entries.
+            const distance = pure
+                ? getSignatureDistance(signature, targetChunk.signature, !targetChunk.pure)
+                : getSignatureDistance(targetChunk.signature, signature, true);
+            if (distance < closestChunkDistance && isValidMerge(mergedChunk, targetChunk)) {
+                if (distance === 1) {
+                    closestChunk = targetChunk;
+                    break;
                 }
+                closestChunk = targetChunk;
+                closestChunkDistance = distance;
             }
-            chunksToBeMerged.add({ alias, modules, signature, size });
-            continue;
         }
-        unmergeableChunks.push({ alias, modules, signature, size: null });
+        if (closestChunk) {
+            chunksToBeMerged.delete(mergedChunk);
+            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
+            closestChunk.modules.push(...modules);
+            closestChunk.size += size;
+            closestChunk.pure && (closestChunk.pure = pure);
+            closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
+            const { dependencies, dependentChunks } = closestChunk;
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(closestChunk);
+            }
+            dependencies.delete(closestChunk);
+            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+        }
     }
-    return { chunksToBeMerged, unmergeableChunks };
+}
+// 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) {
+    return !(hasTransitiveDependency(mergedChunk, targetChunk) ||
+        hasTransitiveDependency(targetChunk, mergedChunk));
+}
+function hasTransitiveDependency(dependentChunk, dependencyChunk) {
+    const chunksToCheck = new Set(dependentChunk.dependencies);
+    for (const { dependencies } of chunksToCheck) {
+        for (const dependency of dependencies) {
+            if (dependency === dependencyChunk) {
+                return true;
+            }
+            chunksToCheck.add(dependency);
+        }
+    }
+    return false;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
 }
 function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     let distance = 0;
@@ -16889,7 +16995,7 @@ class Bundle {
         this.pluginDriver.finaliseAssets();
     }
     async generateChunks(bundle, getHashPlaceholder) {
-        const { experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
+        const { experimentalDeepDynamicChunkOptimization, experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
         const manualChunkAliasByEntry = typeof manualChunks === 'object'
             ? await this.addManualChunks(manualChunks)
             : this.assignManualChunks(manualChunks);
@@ -16903,7 +17009,7 @@ class Bundle {
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
-                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, experimentalDeepDynamicChunkOptimization)) {
             sortByExecutionOrder(modules);
             const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
             chunks.push(chunk);
@@ -24694,6 +24800,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         dynamicImportInCjs: config.dynamicImportInCjs ?? true,
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
+        experimentalDeepDynamicChunkOptimization: config.experimentalDeepDynamicChunkOptimization || false,
         experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
@@ -25385,6 +25492,7 @@ async function mergeOutputOptions(config, overrides, warn) {
         dynamicImportInCjs: getOption('dynamicImportInCjs'),
         entryFileNames: getOption('entryFileNames'),
         esModule: getOption('esModule'),
+        experimentalDeepDynamicChunkOptimization: getOption('experimentalDeepDynamicChunkOptimization'),
         experimentalMinChunkSize: getOption('experimentalMinChunkSize'),
         exports: getOption('exports'),
         extend: getOption('extend'),

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/rollup.d.ts

@@ -647,6 +647,7 @@ export interface OutputOptions {
 	dynamicImportInCjs?: boolean;
 	entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
 	esModule?: boolean | 'if-default-prop';
+	experimentalDeepDynamicChunkOptimization?: boolean;
 	experimentalMinChunkSize?: number;
 	exports?: 'default' | 'named' | 'none' | 'auto';
 	extend?: boolean;
@@ -700,6 +701,7 @@ export interface NormalizedOutputOptions {
 	dynamicImportInCjs: boolean;
 	entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
 	esModule: boolean | 'if-default-prop';
+	experimentalDeepDynamicChunkOptimization: boolean;
 	experimentalMinChunkSize: number;
 	exports: 'default' | 'named' | 'none' | 'auto';
 	extend: boolean;

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.12.1";
+var version$1 = "3.14.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1081,6 +1081,7 @@ async function mergeOutputOptions(config, overrides, warn) {
         dynamicImportInCjs: getOption('dynamicImportInCjs'),
         entryFileNames: getOption('entryFileNames'),
         esModule: getOption('esModule'),
+        experimentalDeepDynamicChunkOptimization: getOption('experimentalDeepDynamicChunkOptimization'),
         experimentalMinChunkSize: getOption('experimentalMinChunkSize'),
         exports: getOption('exports'),
         extend: getOption('extend'),
@@ -7143,7 +7144,7 @@ class LocalVariable extends Variable {
             case INTERACTION_ACCESSED: {
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
@@ -7154,14 +7155,14 @@ class LocalVariable extends Variable {
                     return false;
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
             case INTERACTION_CALLED: {
                 if (this.isReassigned)
                     return true;
-                return (this.init &&
+                return !!(this.init &&
                     !(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
             }
@@ -11937,12 +11938,14 @@ class PrivateIdentifier extends NodeBase {
 class Program extends NodeBase {
     constructor() {
         super(...arguments);
-        this.hasCachedEffect = false;
+        this.hasCachedEffect = null;
+    }
+    hasCachedEffects() {
+        return this.hasCachedEffect === null
+            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
+            : this.hasCachedEffect;
     }
     hasEffects(context) {
-        // We are caching here to later more efficiently identify side-effect-free modules
-        if (this.hasCachedEffect)
-            return true;
         for (const node of this.body) {
             if (node.hasEffects(context)) {
                 return (this.hasCachedEffect = true);
@@ -13840,8 +13843,7 @@ class Module {
         return [null];
     }
     hasEffects() {
-        return (this.info.moduleSideEffects === 'no-treeshake' ||
-            (this.ast.included && this.ast.hasEffects(createHasEffectsContext())));
+        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
     }
     include() {
         const context = createInclusionContext();
@@ -16559,13 +16561,13 @@ const resolveFileName = (dependency) => dependency.getFileName();
  * their iterators. Useful when e.g. working with large sets or lists and when
  * there is a chance that the iterators will not be fully exhausted.
  */
-function* concatLazy(...iterables) {
+function* concatLazy(iterables) {
     for (const iterable of iterables) {
         yield* iterable;
     }
 }
 
-function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, deepChunkOptimization) {
     const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
@@ -16580,7 +16582,7 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     const assignedEntriesByModule = new Map();
     for (const entry of allEntries) {
         if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry);
+            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization);
         }
     }
     chunkDefinitions.push(...createChunks(allEntries, assignedEntriesByModule, minChunkSize));
@@ -16648,13 +16650,13 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
+function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization) {
     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)) {
+            isModuleAlreadyLoaded(dynamicallyDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization)) {
             continue;
         }
         else {
@@ -16672,8 +16674,9 @@ const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
 // - 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) {
+function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization) {
+    if (!deepChunkOptimization &&
+        dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
         return false;
     }
     const entriesToCheck = new Set(dynamicallyDependentEntries);
@@ -16683,7 +16686,8 @@ function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticE
                 return false;
             }
             const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
-            if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+            if (!deepChunkOptimization &&
+                dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
                 return false;
             }
             for (const dependentEntry of dynamicallyDependentEntries) {
@@ -16700,47 +16704,11 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize);
-}
-function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
-    timeStart('optimize chunks', 3);
-    const { chunksToBeMerged, unmergeableChunks } = getMergeableChunks(chunkModulesBySignature, minChunkSize);
-    for (const sourceChunk of chunksToBeMerged) {
-        chunksToBeMerged.delete(sourceChunk);
-        let closestChunk = null;
-        let closestChunkDistance = Infinity;
-        const { signature, size, modules } = sourceChunk;
-        for (const targetChunk of concatLazy(chunksToBeMerged, unmergeableChunks)) {
-            const distance = getSignatureDistance(signature, targetChunk.signature, !chunksToBeMerged.has(targetChunk));
-            if (distance === 1) {
-                closestChunk = targetChunk;
-                break;
-            }
-            else if (distance < closestChunkDistance) {
-                closestChunk = targetChunk;
-                closestChunkDistance = distance;
-            }
-        }
-        if (closestChunk) {
-            closestChunk.modules.push(...modules);
-            if (chunksToBeMerged.has(closestChunk)) {
-                closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
-                if ((closestChunk.size += size) > minChunkSize) {
-                    chunksToBeMerged.delete(closestChunk);
-                    unmergeableChunks.push(closestChunk);
-                }
-            }
-        }
-        else {
-            unmergeableChunks.push(sourceChunk);
-        }
-    }
-    timeEnd('optimize chunks', 3);
-    return unmergeableChunks;
+        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
+            alias: null,
+            modules
+        }));
 }
-const CHAR_DEPENDENT = 'X';
-const CHAR_INDEPENDENT = '_';
-const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
 function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     const chunkModules = Object.create(null);
     for (const [module, assignedEntries] of assignedEntriesByModule) {
@@ -16758,28 +16726,167 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     }
     return chunkModules;
 }
-function getMergeableChunks(chunkModulesBySignature, minChunkSize) {
-    const chunksToBeMerged = new Set();
-    const unmergeableChunks = [];
-    const alias = null;
+/**
+ * This function tries to get rid of small chunks by merging them with other
+ * chunks. In order to merge chunks, one must obey the following rule:
+ * - When merging several chunks, at most one of the chunks can have side
+ *   effects
+ * - When one of the chunks has side effects, the entry points depending on that
+ *   chunk need to be a super set of the entry points depending on the other
+ *   chunks
+ * - Pure chunks can always be merged
+ * - We use the entry point dependence signature to calculate "chunk distance",
+ *   i.e. how likely it is that two chunks are loaded together
+ */
+function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
+    timeStart('optimize chunks', 3);
+    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, minChunkSize);
+    if (chunkPartition.small.sideEffect.size > 0) {
+        mergeChunks(chunkPartition.small.sideEffect, [chunkPartition.small.pure, chunkPartition.big.pure], minChunkSize, chunkPartition);
+    }
+    if (chunkPartition.small.pure.size > 0) {
+        mergeChunks(chunkPartition.small.pure, [chunkPartition.small.pure, chunkPartition.big.sideEffect, chunkPartition.big.pure], minChunkSize, chunkPartition);
+    }
+    timeEnd('optimize chunks', 3);
+    return [
+        ...chunkPartition.small.sideEffect,
+        ...chunkPartition.small.pure,
+        ...chunkPartition.big.sideEffect,
+        ...chunkPartition.big.pure
+    ];
+}
+const CHAR_DEPENDENT = 'X';
+const CHAR_INDEPENDENT = '_';
+const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
+function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
+    const smallPureChunks = [];
+    const bigPureChunks = [];
+    const smallSideEffectChunks = [];
+    const bigSideEffectChunks = [];
+    const chunkByModule = new Map();
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
+        const chunkDescription = {
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            modules,
+            pure: true,
+            signature,
+            size: 0
+        };
         let size = 0;
-        checkModules: {
+        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;
+        }
+        chunkDescription.pure = pure;
+        chunkDescription.size = size;
+        (size < minChunkSize
+            ? pure
+                ? smallPureChunks
+                : smallSideEffectChunks
+            : pure
+                ? bigPureChunks
+                : bigSideEffectChunks).push(chunkDescription);
+    }
+    sortChunksAndAddDependencies([bigPureChunks, bigSideEffectChunks, smallPureChunks, smallSideEffectChunks], chunkByModule);
+    return {
+        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
+        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
+    };
+}
+function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
+    for (const chunks of chunkLists) {
+        chunks.sort(compareChunks);
+        for (const chunk of chunks) {
+            const { dependencies, modules } = chunk;
             for (const module of modules) {
-                if (module.hasEffects()) {
-                    break checkModules;
+                for (const dependency of module.getDependenciesToBeIncluded()) {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
                 }
-                size += module.magicString.toString().length;
-                if (size > minChunkSize) {
-                    break checkModules;
+            }
+        }
+    }
+}
+function compareChunks({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartition) {
+    for (const mergedChunk of chunksToBeMerged) {
+        let closestChunk = null;
+        let closestChunkDistance = Infinity;
+        const { signature, modules, pure, size } = mergedChunk;
+        for (const targetChunk of concatLazy(targetChunks)) {
+            if (mergedChunk === targetChunk)
+                continue;
+            // Possible improvement:
+            // For dynamic entries depending on a pure chunk, it is safe to merge that
+            // chunk into the chunk doing the dynamic import (i.e. into an "already
+            // loaded chunk") even if it is not pure.
+            // One way of handling this could be to add all "already loaded entries"
+            // of the dynamic importers into the signature as well. That could also
+            // change the way we do code-splitting for already loaded entries.
+            const distance = pure
+                ? getSignatureDistance(signature, targetChunk.signature, !targetChunk.pure)
+                : getSignatureDistance(targetChunk.signature, signature, true);
+            if (distance < closestChunkDistance && isValidMerge(mergedChunk, targetChunk)) {
+                if (distance === 1) {
+                    closestChunk = targetChunk;
+                    break;
                 }
+                closestChunk = targetChunk;
+                closestChunkDistance = distance;
             }
-            chunksToBeMerged.add({ alias, modules, signature, size });
-            continue;
         }
-        unmergeableChunks.push({ alias, modules, signature, size: null });
+        if (closestChunk) {
+            chunksToBeMerged.delete(mergedChunk);
+            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
+            closestChunk.modules.push(...modules);
+            closestChunk.size += size;
+            closestChunk.pure && (closestChunk.pure = pure);
+            closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
+            const { dependencies, dependentChunks } = closestChunk;
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(closestChunk);
+            }
+            dependencies.delete(closestChunk);
+            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+        }
     }
-    return { chunksToBeMerged, unmergeableChunks };
+}
+// 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) {
+    return !(hasTransitiveDependency(mergedChunk, targetChunk) ||
+        hasTransitiveDependency(targetChunk, mergedChunk));
+}
+function hasTransitiveDependency(dependentChunk, dependencyChunk) {
+    const chunksToCheck = new Set(dependentChunk.dependencies);
+    for (const { dependencies } of chunksToCheck) {
+        for (const dependency of dependencies) {
+            if (dependency === dependencyChunk) {
+                return true;
+            }
+            chunksToCheck.add(dependency);
+        }
+    }
+    return false;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
 }
 function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     let distance = 0;
@@ -17407,7 +17514,7 @@ class Bundle {
         this.pluginDriver.finaliseAssets();
     }
     async generateChunks(bundle, getHashPlaceholder) {
-        const { experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
+        const { experimentalDeepDynamicChunkOptimization, experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
         const manualChunkAliasByEntry = typeof manualChunks === 'object'
             ? await this.addManualChunks(manualChunks)
             : this.assignManualChunks(manualChunks);
@@ -17421,7 +17528,7 @@ class Bundle {
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
-                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, experimentalDeepDynamicChunkOptimization)) {
             sortByExecutionOrder(modules);
             const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
             chunks.push(chunk);
@@ -25116,6 +25223,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         dynamicImportInCjs: config.dynamicImportInCjs ?? true,
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
+        experimentalDeepDynamicChunkOptimization: config.experimentalDeepDynamicChunkOptimization || false,
         experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.12.1
-	Wed, 01 Feb 2023 09:25:11 GMT - commit 0c5aa76cb0e30a66ce7c7972f484c003a5b7b8c1
+	Rollup.js v3.14.0
+	Sun, 05 Feb 2023 05:33:16 GMT - commit b8526485935ef21c65a5cd5474adbddf24ec7a32
 
 	https://github.com/rollup/rollup
 

package/package.json

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