rollup 3.15.0 → 3.15.1-1

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	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.15.0";
+var version$1 = "3.15.1-1";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -370,6 +370,9 @@ class SourceMap {
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
 		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
 	}
 
 	toString() {
@@ -16119,7 +16122,7 @@ function analyzeModuleGraph(entries) {
         }
     }
     return {
-        allEntries,
+        allEntries: [...allEntries],
         dependentEntriesByModule,
         dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries)
     };
@@ -16193,7 +16196,7 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
+        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
             alias: null,
             modules
         }));
@@ -16217,49 +16220,109 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
 }
 /**
  * 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
+ * chunks.
+ *
+ * We can only merge chunks safely if after the merge, loading any entry point
+ * in any allowed order will not trigger side effects that should not have been
+ * triggered. While side effects are usually things like global function calls,
+ * global variable mutations or potentially thrown errors, details do not
+ * matter here, and we just discern chunks without side effects (pure chunks)
+ * from other chunks.
+ *
+ * As a first step, we assign each pre-generated chunk with side effects a
+ * label. I.e. we have side effect "A" if the non-pure chunk "A" is loaded.
+ *
+ * Now to determine the side effects of loading a chunk, one also has to take
+ * the side effects of its dependencies into account. So if A depends on B
+ * (A -> B) and both have side effects, loading A triggers effects AB.
+ *
+ * Now from the previous step we know that each chunk is uniquely determine by
+ * the entry points that depend on it and cause it to load, which we will call
+ * its dependent entry points.
+ *
+ * E.g. if X -> A and Y -> A, then the dependent entry points of A are XY.
+ * Starting from that idea, we can determine a set of chunks—and thus a set
+ * of side effects—that must have been triggered if a certain chunk has been
+ * loaded. Basically, it is the intersection of all chunks loaded by the
+ * dependent entry points of a given chunk. We call the corresponding side
+ * effects the correlated side effects of that chunk.
+ *
+ * Example:
+ * X -> ABC, Y -> ADE, A-> F, B -> D
+ * Then taking dependencies into account, X -> ABCDF, Y -> ADEF
+ * The intersection is ADF. So we know that when A is loaded, D and F must also
+ * be in memory even though neither D nor A is a dependency of the other.
+ * If all have side effects, we call ADF the correlated side effects of A. The
+ * correlated side effects need to remain constant when merging chunks.
+ *
+ * In contrast, we have the dependency side effects of A, which represents
+ * the side effects we trigger if we directly load A. In this example, the
+ * dependency side effects are AF.
+ * For entry chunks, dependency and correlated side effects are the same.
+ *
+ * With these concepts, merging chunks is allowed if the correlated side effects
+ * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * a) the dependency side effects of each chunk are a subset of the correlated
+ *    side effects of the other chunk, so no additional side effects are
+ *    triggered for any entry, or
+ * b) The signature of chunk A is a subset of the signature of chunk B while the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
+ *    But there are cases when B is loaded where A is not loaded. So if we merge
+ *    the chunks, all dependency side effects of A will be added to the
+ *    correlated side effects of B, and as the latter is not allowed to change,
+ *    the former need to be a subset of the latter.
+ *
+ * Another consideration when merging small chunks into other chunks is to avoid
+ * that too much additional code is loaded. This is achieved when the dependent
+ * entries of the small chunk are a subset of the dependent entries of the other
+ * chunk. Because then when the small chunk is loaded, the other chunk was
+ * loaded/in memory anyway, so at most when the other chunk is loaded, the
+ * additional size of the small chunk is loaded unnecessarily.
+ *
+ * So the algorithm performs merges in two passes:
+ * 1. First we try to merge small chunks A only into other chunks B if the
+ *    dependent entries of A are a subset of the dependent entries of B and the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B.
+ * 2. Only then for all remaining small chunks, we look for arbitrary merges
+ *    following the above rules (a) and (b), starting with the smallest chunks
+ *    to look for possible merge targets.
  */
-function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
+function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, 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);
+    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
+    if (chunkPartition.small.size > 0) {
+        mergeChunks(chunkPartition, minChunkSize);
     }
     timeEnd('optimize chunks', 3);
-    return [
-        ...chunkPartition.small.sideEffect,
-        ...chunkPartition.small.pure,
-        ...chunkPartition.big.sideEffect,
-        ...chunkPartition.big.pure
-    ];
+    return [...chunkPartition.small, ...chunkPartition.big];
 }
 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 = [];
+function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+    const smallChunks = [];
+    const bigChunks = [];
     const chunkByModule = new Map();
+    const sideEffectsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        sideEffectsByEntry.push(new Set());
+    }
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
+        const dependentEntries = new Set();
+        for (let position = 0; position < numberOfEntries; position++) {
+            if (signature[position] === CHAR_DEPENDENT) {
+                dependentEntries.add(position);
+            }
+        }
         const chunkDescription = {
+            correlatedSideEffects: new Set(),
             dependencies: new Set(),
             dependentChunks: new Set(),
+            dependentEntries,
             modules,
             pure: true,
-            signature,
+            sideEffects: new Set(),
             size: 0
         };
         let size = 0;
@@ -16273,25 +16336,27 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
-        (size < minChunkSize
-            ? pure
-                ? smallPureChunks
-                : smallSideEffectChunks
-            : pure
-                ? bigPureChunks
-                : bigSideEffectChunks).push(chunkDescription);
-    }
-    sortChunksAndAddDependencies([bigPureChunks, bigSideEffectChunks, smallPureChunks, smallSideEffectChunks], chunkByModule);
+        if (!pure) {
+            for (const entryIndex of dependentEntries) {
+                sideEffectsByEntry[entryIndex].add(signature);
+            }
+            // In the beginning, each chunk is only its own side effect. After
+            // merging, additional side effects can accumulate.
+            chunkDescription.sideEffects.add(signature);
+        }
+        (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+    }
+    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
     return {
-        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
-        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
+        big: new Set(bigChunks),
+        small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
+function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
     for (const chunks of chunkLists) {
-        chunks.sort(compareChunks);
+        chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules } = chunk;
+            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
             for (const module of modules) {
                 for (const dependency of module.getDependenciesToBeIncluded()) {
                     const dependencyChunk = chunkByModule.get(dependency);
@@ -16301,89 +16366,133 @@ function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
                     }
                 }
             }
+            let firstEntry = true;
+            // Correlated side effects is the intersection of all entry side effects
+            for (const entryIndex of dependentEntries) {
+                const entryEffects = sideEffectsByEntry[entryIndex];
+                if (firstEntry) {
+                    for (const sideEffect of entryEffects) {
+                        correlatedSideEffects.add(sideEffect);
+                    }
+                    firstEntry = false;
+                }
+                else {
+                    for (const sideEffect of correlatedSideEffects) {
+                        if (!entryEffects.has(sideEffect)) {
+                            correlatedSideEffects.delete(sideEffect);
+                        }
+                    }
+                }
+            }
         }
     }
 }
-function compareChunks({ size: sizeA }, { size: sizeB }) {
+function compareChunkSize({ 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) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    console.log('---- Initial chunks');
+    printConsistencyCheck(chunkPartition);
+    for (const allowArbitraryMerges of [false, true]) {
+        for (const mergedChunk of chunkPartition.small) {
+            let closestChunk = null;
+            let closestChunkDistance = Infinity;
+            const { modules, pure, size } = mergedChunk;
+            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
+                if (mergedChunk === targetChunk)
+                    continue;
+                // If both chunks are small, we also allow for unrelated merges during
+                // the first pass
+                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
+                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
+                if (distance < closestChunkDistance &&
+                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
                     closestChunk = targetChunk;
-                    break;
+                    closestChunkDistance = distance;
                 }
-                closestChunk = targetChunk;
-                closestChunkDistance = distance;
-            }
-        }
-        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);
+            if (closestChunk) {
+                chunkPartition.small.delete(mergedChunk);
+                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
+                closestChunk.modules.push(...modules);
+                closestChunk.size += size;
+                closestChunk.pure && (closestChunk.pure = pure);
+                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
+                for (const sideEffect of correlatedSideEffects) {
+                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
+                        correlatedSideEffects.delete(sideEffect);
+                    }
+                }
+                for (const entry of mergedChunk.dependentEntries) {
+                    dependentEntries.add(entry);
+                }
+                for (const sideEffect of mergedChunk.sideEffects) {
+                    sideEffects.add(sideEffect);
+                }
+                for (const dependency of mergedChunk.dependencies) {
+                    dependencies.add(dependency);
+                    dependency.dependentChunks.delete(mergedChunk);
+                    dependency.dependentChunks.add(closestChunk);
+                }
+                for (const dependentChunk of mergedChunk.dependentChunks) {
+                    dependentChunks.add(dependentChunk);
+                    dependentChunk.dependencies.delete(mergedChunk);
+                    dependentChunk.dependencies.add(closestChunk);
+                }
+                dependencies.delete(closestChunk);
+                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
             }
-            dependencies.delete(closestChunk);
-            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
         }
+        console.log('---- After run with arbitrary merges:', allowArbitraryMerges);
+        printConsistencyCheck(chunkPartition);
     }
 }
 // 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) {
+function isValidMerge(mergedChunk, targetChunk, onlySubsetMerge) {
+    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
+        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
+}
+function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
+    const { correlatedSideEffects } = dependencyChunk;
+    if (checkSideEffects) {
+        for (const sideEffect of dependentChunk.sideEffects) {
+            if (!correlatedSideEffects.has(sideEffect)) {
+                return true;
+            }
+        }
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies } of chunksToCheck) {
+    for (const { dependencies, sideEffects } of chunksToCheck) {
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
                 return true;
             }
             chunksToCheck.add(dependency);
         }
+        if (checkSideEffects) {
+            for (const sideEffect of sideEffects) {
+                if (!correlatedSideEffects.has(sideEffect)) {
+                    return true;
+                }
+            }
+        }
     }
     return false;
 }
 function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
 }
-function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
+function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
     let distance = 0;
-    const { length } = sourceSignature;
-    for (let index = 0; index < length; index++) {
-        const sourceValue = sourceSignature.charCodeAt(index);
-        if (sourceValue !== targetSignature.charCodeAt(index)) {
-            if (enforceSubset && sourceValue === CHAR_CODE_DEPENDENT) {
+    for (const entryIndex of targetEntries) {
+        if (!sourceEntries.has(entryIndex)) {
+            distance++;
+        }
+    }
+    for (const entryIndex of sourceEntries) {
+        if (!targetEntries.has(entryIndex)) {
+            if (enforceSubest) {
                 return Infinity;
             }
             distance++;
@@ -16391,17 +16500,57 @@ function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     }
     return distance;
 }
-function mergeSignatures(sourceSignature, targetSignature) {
-    let signature = '';
-    const { length } = sourceSignature;
-    for (let index = 0; index < length; index++) {
-        signature +=
-            sourceSignature.charCodeAt(index) === CHAR_CODE_DEPENDENT ||
-                targetSignature.charCodeAt(index) === CHAR_CODE_DEPENDENT
-                ? CHAR_DEPENDENT
-                : CHAR_INDEPENDENT;
-    }
-    return signature;
+function printConsistencyCheck(partition) {
+    console.log(`Chunks\n  small: ${partition.small.size},\n  large: ${partition.big.size}`);
+    const chunks = new Set([...partition.big, ...partition.small]);
+    console.log('Number of cycles:', getNumberOfCycles(chunks));
+    let missingDependencies = 0;
+    let missingDependentChunks = 0;
+    const seenModules = new Set();
+    for (const { modules, dependencies, dependentChunks } of chunks) {
+        for (const module of modules) {
+            if (seenModules.has(module)) {
+                console.log(`Module ${module.id} is duplicated between chunks.`);
+            }
+            seenModules.add(module);
+        }
+        for (const dependency of dependencies) {
+            if (!chunks.has(dependency)) {
+                missingDependencies++;
+            }
+        }
+        for (const dependency of dependentChunks) {
+            if (!chunks.has(dependency)) {
+                missingDependentChunks++;
+            }
+        }
+    }
+    console.log(`Missing\n  dependencies: ${missingDependencies},\n  dependent chunks: ${missingDependentChunks}\n`);
+}
+function getNumberOfCycles(chunks) {
+    const parents = new Set();
+    const analysedChunks = new Set();
+    let cycles = 0;
+    const analyseChunk = (chunk) => {
+        for (const dependency of chunk.dependencies) {
+            if (parents.has(dependency)) {
+                if (!analysedChunks.has(dependency)) {
+                    cycles++;
+                }
+                continue;
+            }
+            parents.add(dependency);
+            analyseChunk(dependency);
+        }
+        analysedChunks.add(chunk);
+    };
+    for (const chunk of chunks) {
+        if (!parents.has(chunk)) {
+            parents.add(chunk);
+            analyseChunk(chunk);
+        }
+    }
+    return cycles;
 }
 
 // ported from https://github.com/substack/node-commondir

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/rollup.d.ts

@@ -52,7 +52,7 @@ export interface ExistingDecodedSourceMap {
 	names: string[];
 	sourceRoot?: string;
 	sources: string[];
-	sourcesContent?: string[];
+	sourcesContent?: (string | null)[];
 	version: number;
 }
 
@@ -62,7 +62,7 @@ export interface ExistingRawSourceMap {
 	names: string[];
 	sourceRoot?: string;
 	sources: string[];
-	sourcesContent?: string[];
+	sourcesContent?: (string | null)[];
 	version: number;
 }
 
@@ -79,7 +79,7 @@ export interface SourceMap {
 	mappings: string;
 	names: string[];
 	sources: string[];
-	sourcesContent: string[];
+	sourcesContent: (string | null)[];
 	version: number;
 	toString(): string;
 	toUrl(): string;

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.15.0";
+var version$1 = "3.15.1-1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1641,6 +1641,9 @@ class SourceMap {
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
 		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
 	}
 
 	toString() {
@@ -16638,7 +16641,7 @@ function analyzeModuleGraph(entries) {
         }
     }
     return {
-        allEntries,
+        allEntries: [...allEntries],
         dependentEntriesByModule,
         dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries)
     };
@@ -16712,7 +16715,7 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
+        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
             alias: null,
             modules
         }));
@@ -16736,49 +16739,109 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
 }
 /**
  * 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
+ * chunks.
+ *
+ * We can only merge chunks safely if after the merge, loading any entry point
+ * in any allowed order will not trigger side effects that should not have been
+ * triggered. While side effects are usually things like global function calls,
+ * global variable mutations or potentially thrown errors, details do not
+ * matter here, and we just discern chunks without side effects (pure chunks)
+ * from other chunks.
+ *
+ * As a first step, we assign each pre-generated chunk with side effects a
+ * label. I.e. we have side effect "A" if the non-pure chunk "A" is loaded.
+ *
+ * Now to determine the side effects of loading a chunk, one also has to take
+ * the side effects of its dependencies into account. So if A depends on B
+ * (A -> B) and both have side effects, loading A triggers effects AB.
+ *
+ * Now from the previous step we know that each chunk is uniquely determine by
+ * the entry points that depend on it and cause it to load, which we will call
+ * its dependent entry points.
+ *
+ * E.g. if X -> A and Y -> A, then the dependent entry points of A are XY.
+ * Starting from that idea, we can determine a set of chunks—and thus a set
+ * of side effects—that must have been triggered if a certain chunk has been
+ * loaded. Basically, it is the intersection of all chunks loaded by the
+ * dependent entry points of a given chunk. We call the corresponding side
+ * effects the correlated side effects of that chunk.
+ *
+ * Example:
+ * X -> ABC, Y -> ADE, A-> F, B -> D
+ * Then taking dependencies into account, X -> ABCDF, Y -> ADEF
+ * The intersection is ADF. So we know that when A is loaded, D and F must also
+ * be in memory even though neither D nor A is a dependency of the other.
+ * If all have side effects, we call ADF the correlated side effects of A. The
+ * correlated side effects need to remain constant when merging chunks.
+ *
+ * In contrast, we have the dependency side effects of A, which represents
+ * the side effects we trigger if we directly load A. In this example, the
+ * dependency side effects are AF.
+ * For entry chunks, dependency and correlated side effects are the same.
+ *
+ * With these concepts, merging chunks is allowed if the correlated side effects
+ * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * a) the dependency side effects of each chunk are a subset of the correlated
+ *    side effects of the other chunk, so no additional side effects are
+ *    triggered for any entry, or
+ * b) The signature of chunk A is a subset of the signature of chunk B while the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
+ *    But there are cases when B is loaded where A is not loaded. So if we merge
+ *    the chunks, all dependency side effects of A will be added to the
+ *    correlated side effects of B, and as the latter is not allowed to change,
+ *    the former need to be a subset of the latter.
+ *
+ * Another consideration when merging small chunks into other chunks is to avoid
+ * that too much additional code is loaded. This is achieved when the dependent
+ * entries of the small chunk are a subset of the dependent entries of the other
+ * chunk. Because then when the small chunk is loaded, the other chunk was
+ * loaded/in memory anyway, so at most when the other chunk is loaded, the
+ * additional size of the small chunk is loaded unnecessarily.
+ *
+ * So the algorithm performs merges in two passes:
+ * 1. First we try to merge small chunks A only into other chunks B if the
+ *    dependent entries of A are a subset of the dependent entries of B and the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B.
+ * 2. Only then for all remaining small chunks, we look for arbitrary merges
+ *    following the above rules (a) and (b), starting with the smallest chunks
+ *    to look for possible merge targets.
  */
-function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
+function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, 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);
+    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
+    if (chunkPartition.small.size > 0) {
+        mergeChunks(chunkPartition, minChunkSize);
     }
     timeEnd('optimize chunks', 3);
-    return [
-        ...chunkPartition.small.sideEffect,
-        ...chunkPartition.small.pure,
-        ...chunkPartition.big.sideEffect,
-        ...chunkPartition.big.pure
-    ];
+    return [...chunkPartition.small, ...chunkPartition.big];
 }
 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 = [];
+function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+    const smallChunks = [];
+    const bigChunks = [];
     const chunkByModule = new Map();
+    const sideEffectsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        sideEffectsByEntry.push(new Set());
+    }
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
+        const dependentEntries = new Set();
+        for (let position = 0; position < numberOfEntries; position++) {
+            if (signature[position] === CHAR_DEPENDENT) {
+                dependentEntries.add(position);
+            }
+        }
         const chunkDescription = {
+            correlatedSideEffects: new Set(),
             dependencies: new Set(),
             dependentChunks: new Set(),
+            dependentEntries,
             modules,
             pure: true,
-            signature,
+            sideEffects: new Set(),
             size: 0
         };
         let size = 0;
@@ -16792,25 +16855,27 @@ function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
-        (size < minChunkSize
-            ? pure
-                ? smallPureChunks
-                : smallSideEffectChunks
-            : pure
-                ? bigPureChunks
-                : bigSideEffectChunks).push(chunkDescription);
-    }
-    sortChunksAndAddDependencies([bigPureChunks, bigSideEffectChunks, smallPureChunks, smallSideEffectChunks], chunkByModule);
+        if (!pure) {
+            for (const entryIndex of dependentEntries) {
+                sideEffectsByEntry[entryIndex].add(signature);
+            }
+            // In the beginning, each chunk is only its own side effect. After
+            // merging, additional side effects can accumulate.
+            chunkDescription.sideEffects.add(signature);
+        }
+        (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+    }
+    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
     return {
-        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
-        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
+        big: new Set(bigChunks),
+        small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
+function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
     for (const chunks of chunkLists) {
-        chunks.sort(compareChunks);
+        chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules } = chunk;
+            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
             for (const module of modules) {
                 for (const dependency of module.getDependenciesToBeIncluded()) {
                     const dependencyChunk = chunkByModule.get(dependency);
@@ -16820,89 +16885,133 @@ function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
                     }
                 }
             }
+            let firstEntry = true;
+            // Correlated side effects is the intersection of all entry side effects
+            for (const entryIndex of dependentEntries) {
+                const entryEffects = sideEffectsByEntry[entryIndex];
+                if (firstEntry) {
+                    for (const sideEffect of entryEffects) {
+                        correlatedSideEffects.add(sideEffect);
+                    }
+                    firstEntry = false;
+                }
+                else {
+                    for (const sideEffect of correlatedSideEffects) {
+                        if (!entryEffects.has(sideEffect)) {
+                            correlatedSideEffects.delete(sideEffect);
+                        }
+                    }
+                }
+            }
         }
     }
 }
-function compareChunks({ size: sizeA }, { size: sizeB }) {
+function compareChunkSize({ 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) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    console.log('---- Initial chunks');
+    printConsistencyCheck(chunkPartition);
+    for (const allowArbitraryMerges of [false, true]) {
+        for (const mergedChunk of chunkPartition.small) {
+            let closestChunk = null;
+            let closestChunkDistance = Infinity;
+            const { modules, pure, size } = mergedChunk;
+            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
+                if (mergedChunk === targetChunk)
+                    continue;
+                // If both chunks are small, we also allow for unrelated merges during
+                // the first pass
+                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
+                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
+                if (distance < closestChunkDistance &&
+                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
                     closestChunk = targetChunk;
-                    break;
+                    closestChunkDistance = distance;
                 }
-                closestChunk = targetChunk;
-                closestChunkDistance = distance;
-            }
-        }
-        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);
+            if (closestChunk) {
+                chunkPartition.small.delete(mergedChunk);
+                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
+                closestChunk.modules.push(...modules);
+                closestChunk.size += size;
+                closestChunk.pure && (closestChunk.pure = pure);
+                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
+                for (const sideEffect of correlatedSideEffects) {
+                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
+                        correlatedSideEffects.delete(sideEffect);
+                    }
+                }
+                for (const entry of mergedChunk.dependentEntries) {
+                    dependentEntries.add(entry);
+                }
+                for (const sideEffect of mergedChunk.sideEffects) {
+                    sideEffects.add(sideEffect);
+                }
+                for (const dependency of mergedChunk.dependencies) {
+                    dependencies.add(dependency);
+                    dependency.dependentChunks.delete(mergedChunk);
+                    dependency.dependentChunks.add(closestChunk);
+                }
+                for (const dependentChunk of mergedChunk.dependentChunks) {
+                    dependentChunks.add(dependentChunk);
+                    dependentChunk.dependencies.delete(mergedChunk);
+                    dependentChunk.dependencies.add(closestChunk);
+                }
+                dependencies.delete(closestChunk);
+                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
             }
-            dependencies.delete(closestChunk);
-            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
         }
+        console.log('---- After run with arbitrary merges:', allowArbitraryMerges);
+        printConsistencyCheck(chunkPartition);
     }
 }
 // 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) {
+function isValidMerge(mergedChunk, targetChunk, onlySubsetMerge) {
+    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
+        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
+}
+function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
+    const { correlatedSideEffects } = dependencyChunk;
+    if (checkSideEffects) {
+        for (const sideEffect of dependentChunk.sideEffects) {
+            if (!correlatedSideEffects.has(sideEffect)) {
+                return true;
+            }
+        }
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies } of chunksToCheck) {
+    for (const { dependencies, sideEffects } of chunksToCheck) {
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
                 return true;
             }
             chunksToCheck.add(dependency);
         }
+        if (checkSideEffects) {
+            for (const sideEffect of sideEffects) {
+                if (!correlatedSideEffects.has(sideEffect)) {
+                    return true;
+                }
+            }
+        }
     }
     return false;
 }
 function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
 }
-function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
+function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
     let distance = 0;
-    const { length } = sourceSignature;
-    for (let index = 0; index < length; index++) {
-        const sourceValue = sourceSignature.charCodeAt(index);
-        if (sourceValue !== targetSignature.charCodeAt(index)) {
-            if (enforceSubset && sourceValue === CHAR_CODE_DEPENDENT) {
+    for (const entryIndex of targetEntries) {
+        if (!sourceEntries.has(entryIndex)) {
+            distance++;
+        }
+    }
+    for (const entryIndex of sourceEntries) {
+        if (!targetEntries.has(entryIndex)) {
+            if (enforceSubest) {
                 return Infinity;
             }
             distance++;
@@ -16910,17 +17019,57 @@ function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     }
     return distance;
 }
-function mergeSignatures(sourceSignature, targetSignature) {
-    let signature = '';
-    const { length } = sourceSignature;
-    for (let index = 0; index < length; index++) {
-        signature +=
-            sourceSignature.charCodeAt(index) === CHAR_CODE_DEPENDENT ||
-                targetSignature.charCodeAt(index) === CHAR_CODE_DEPENDENT
-                ? CHAR_DEPENDENT
-                : CHAR_INDEPENDENT;
-    }
-    return signature;
+function printConsistencyCheck(partition) {
+    console.log(`Chunks\n  small: ${partition.small.size},\n  large: ${partition.big.size}`);
+    const chunks = new Set([...partition.big, ...partition.small]);
+    console.log('Number of cycles:', getNumberOfCycles(chunks));
+    let missingDependencies = 0;
+    let missingDependentChunks = 0;
+    const seenModules = new Set();
+    for (const { modules, dependencies, dependentChunks } of chunks) {
+        for (const module of modules) {
+            if (seenModules.has(module)) {
+                console.log(`Module ${module.id} is duplicated between chunks.`);
+            }
+            seenModules.add(module);
+        }
+        for (const dependency of dependencies) {
+            if (!chunks.has(dependency)) {
+                missingDependencies++;
+            }
+        }
+        for (const dependency of dependentChunks) {
+            if (!chunks.has(dependency)) {
+                missingDependentChunks++;
+            }
+        }
+    }
+    console.log(`Missing\n  dependencies: ${missingDependencies},\n  dependent chunks: ${missingDependentChunks}\n`);
+}
+function getNumberOfCycles(chunks) {
+    const parents = new Set();
+    const analysedChunks = new Set();
+    let cycles = 0;
+    const analyseChunk = (chunk) => {
+        for (const dependency of chunk.dependencies) {
+            if (parents.has(dependency)) {
+                if (!analysedChunks.has(dependency)) {
+                    cycles++;
+                }
+                continue;
+            }
+            parents.add(dependency);
+            analyseChunk(dependency);
+        }
+        analysedChunks.add(chunk);
+    };
+    for (const chunk of chunks) {
+        if (!parents.has(chunk)) {
+            parents.add(chunk);
+            analyseChunk(chunk);
+        }
+    }
+    return cycles;
 }
 
 // ported from https://github.com/substack/node-commondir

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.0
-	Fri, 10 Feb 2023 05:20:05 GMT - commit 5d81532f688383a8aeaf6a099da2b0205e8b8609
+	Rollup.js v3.15.1-1
+	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
 
 	https://github.com/rollup/rollup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "3.15.0",
+  "version": "3.15.1-1",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",
@@ -116,7 +116,7 @@
     "is-reference": "^3.0.1",
     "lint-staged": "^13.1.0",
     "locate-character": "^2.0.5",
-    "magic-string": "^0.27.0",
+    "magic-string": "^0.29.0",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0",
     "pinia": "^2.0.29",