rollup 3.15.1-1 → 3.17.0

package/dist/es/shared/{rollup.js → node-entry.js}

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.15.1-1
-	Tue, 14 Feb 2023 09:30:15 GMT - commit 5e91b2d7a9f833cf9e11d98c96c4cba3fac195a4
+	Rollup.js v3.17.0
+	Sat, 18 Feb 2023 05:06:04 GMT - commit 0c33497a7de91e150a7d242125e8da9dd4e4a3ac
 
 	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.1-1";
+var version$1 = "3.17.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -1798,7 +1798,7 @@ class DiscriminatedPathTracker {
                 currentPaths[pathSegment] ||
                     Object.create(null, { [EntitiesKey]: { value: new Map() } });
         }
-        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, getNewSet);
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, (getNewSet));
         if (trackedEntities.has(entity))
             return true;
         trackedEntities.add(entity);
@@ -2071,6 +2071,7 @@ const URL_OUTPUT_EXPORTS = 'configuration-options/#output-exports';
 const URL_OUTPUT_EXTEND = 'configuration-options/#output-extend';
 const URL_OUTPUT_FORMAT = 'configuration-options/#output-format';
 const URL_OUTPUT_GENERATEDCODE = 'configuration-options/#output-generatedcode';
+const URL_OUTPUT_EXPERIMENTALDEEPCHUNKOPTIMIZATION = 'configuration-options/#output-experimentaldeepdynamicchunkoptimization';
 const URL_OUTPUT_GENERATEDCODE_CONSTBINDINGS = 'configuration-options/#output-generatedcode-constbindings';
 const URL_OUTPUT_GENERATEDCODE_SYMBOLS = 'configuration-options/#output-generatedcode-symbols';
 const URL_OUTPUT_GLOBALS = 'configuration-options/#output-globals';
@@ -12966,7 +12967,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
-    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, getNewSet);
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, (getNewSet));
     let currentVariable = variable;
     const referencedVariables = new Set([currentVariable]);
     while (true) {
@@ -13305,7 +13306,7 @@ class Module {
                 searchedNamesAndModules
             });
             if (importerForSideEffects) {
-                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, getNewSet).add(this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
             return [variable];
@@ -16059,7 +16060,137 @@ function* concatLazy(iterables) {
     }
 }
 
-function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, deepChunkOptimization) {
+/**
+ * At its core, the algorithm first starts from each static or dynamic entry
+ * point and then assigns that entry point to all modules than can be reached
+ * via static imports. We call this the *dependent entry points* of that
+ * module.
+ *
+ * Then we group all modules with the same dependent entry points into chunks
+ * as those modules will always be loaded together.
+ *
+ * One non-trivial optimization we can apply is that dynamic entries are
+ * different from static entries in so far as when a dynamic import occurs,
+ * some
+ * modules are already in memory. If some of these modules are also
+ * dependencies
+ * of the dynamic entry, then it does not make sense to create a separate chunk
+ * for them. Instead, the dynamic import target can load them from the
+ * importing
+ * chunk.
+ *
+ * With regard to chunking, if B is implicitly loaded after A, then this can be
+ * handled the same way as if there was a dynamic import A => B.
+ *
+ * Example:
+ * Assume A -> B (A imports B), A => C (A dynamically imports C) and C -> B.
+ * Then the initial algorithm would assign A into the A chunk, C into the C
+ * chunk and B into the AC chunk, i.e. the chunk with the dependent entry
+ * points
+ * A and C.
+ * However we know that C can only be loaded from A, so A and its dependency B
+ * must already be in memory when C is loaded. So it is enough to create only
+ * two chunks A containing [AB] and C containing [C].
+ *
+ * So we do not assign the dynamic entry C as dependent entry point to modules
+ * that are already loaded.
+ *
+ * In a more complex example, let us assume that we have entry points X and Y.
+ * Further, let us assume
+ * X -> A, X -> B, X -> C,
+ * Y -> A, Y -> B,
+ * A => D,
+ * D -> B, D -> C
+ * So without dynamic import optimization, the dependent entry points are
+ * A: XY, B: DXY, C: DX, D: D, X: X, Y: Y,
+ * so we would for now create six chunks.
+ *
+ * Now D is loaded only after A is loaded. But A is loaded if either X is
+ * loaded
+ * or Y is loaded. So the modules that are already in memory when D is loaded
+ * are the intersection of all modules that X depends on with all modules that
+ * Y
+ * depends on, which in this case are the modules A and B.
+ * We could also say they are all modules that have both X and Y as dependent
+ * entry points.
+ *
+ * So we can remove D as dependent entry point from A and B, which means they
+ * both now have only XY as dependent entry points and can be merged into the
+ * same chunk.
+ *
+ * Now let us extend this to the most general case where we have several
+ * dynamic
+ * importers for one dynamic entry point.
+ *
+ * In the most general form, it works like this:
+ * For each dynamic entry point, we have a number of dynamic importers, which
+ * are the modules importing it. Using the previous ideas, we can determine
+ * the modules already in memory for each dynamic importer by looking for all
+ * modules that have all the dependent entry points of the dynamic importer as
+ * dependent entry points.
+ * So the modules that are guaranteed to be in memory when the dynamic entry
+ * point is loaded are the intersection of the modules already in memory for
+ * each dynamic importer.
+ *
+ * Assuming that A => D and B => D and A has dependent entry points XY and B
+ * has
+ * dependent entry points YZ, then the modules guaranteed to be in memory are
+ * all modules that have at least XYZ as dependent entry points.
+ * We call XYZ the *dynamically dependent entry points* of D.
+ *
+ * Now there is one last case to consider: If one of the dynamically dependent
+ * entries is itself a dynamic entry, then any module is in memory that either
+ * is a dependency of that dynamic entry or again has the dynamic dependent
+ * entries of that dynamic entry as dependent entry points.
+ *
+ * A naive algorithm for this proved to be costly as it contained an O(n^3)
+ * complexity with regard to dynamic entries that blew up for very large
+ * projects.
+ *
+ * If we have an efficient way to do Set operations, an alternative approach
+ * would be to instead collect already loaded modules per dynamic entry. And as
+ * all chunks from the initial grouping would behave the same, we can instead
+ * collect already loaded chunks for a performance improvement.
+ *
+ * To do that efficiently, need
+ * - a Map of dynamic imports per dynamic entry, which contains all dynamic
+ *   imports that can be triggered by a dynamic entry
+ * - a Map of static dependencies per entry
+ * - a Map of already loaded chunks per entry that we initially populate with
+ *   empty Sets for static entries and Sets containing all entries for dynamic
+ *   entries
+ *
+ * For efficient operations, we assign each entry a numerical index and
+ * represent Sets of Chunks as BigInt values where each chunk corresponds to a
+ * bit index. Then thw last two maps can be represented as arrays of BigInt
+ * values.
+ *
+ * Then we iterate through each dynamic entry. We set the already loaded modules
+ * to the intersection of the previously already loaded modules with the union
+ * of the already loaded modules of that chunk with its static dependencies.
+ *
+ * If the already loaded modules changed, then we use the Map of dynamic imports
+ * per dynamic entry to marks all dynamic entry dependencies as "dirty" and put
+ * them back into the iteration. As an additional optimization, we note for
+ * each dynamic entry which dynamic dependent entries have changed and only
+ * intersect those entries again on subsequent interations.
+ *
+ * Then we remove the dynamic entries from the list of dependent entries for
+ * those chunks that are already loaded for that dynamic entry and create
+ * another round of chunks.
+ */
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
+    const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
+    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
+    // Each chunk is identified by its position in this array
+    const initialChunks = Object.values(getChunksBySignature(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks)));
+    // This mutates initialChunks but also clears
+    // dynamicallyDependentEntriesByDynamicEntry as side effect
+    removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+    chunkDefinitions.push(...createChunks(allEntries, getChunksBySignature(initialChunks), minChunkSize));
+    return chunkDefinitions;
+}
+function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
     const chunkDefinitions = [];
     const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
     const manualChunkModulesByAlias = Object.create(null);
@@ -16069,16 +16200,7 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, dee
     for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
         chunkDefinitions.push({ alias, modules });
     }
-    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry } = analyzeModuleGraph(entries);
-    const staticEntries = new Set(entries);
-    const assignedEntriesByModule = new Map();
-    for (const entry of allEntries) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization);
-        }
-    }
-    chunkDefinitions.push(...createChunks(allEntries, assignedEntriesByModule, minChunkSize));
-    return chunkDefinitions;
+    return { chunkDefinitions, modulesInManualChunks };
 }
 function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
     const modulesToHandle = new Set([entry]);
@@ -16093,13 +16215,17 @@ function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesIn
     }
 }
 function analyzeModuleGraph(entries) {
-    const dynamicEntries = new Set();
+    const dynamicEntryModules = new Set();
     const dependentEntriesByModule = new Map();
-    const allEntries = new Set(entries);
-    for (const currentEntry of allEntries) {
+    const dynamicImportModulesByEntry = [];
+    const allEntriesSet = new Set(entries);
+    let entryIndex = 0;
+    for (const currentEntry of allEntriesSet) {
+        const dynamicImportsForCurrentEntry = new Set();
+        dynamicImportModulesByEntry.push(dynamicImportsForCurrentEntry);
         const modulesToHandle = new Set([currentEntry]);
         for (const module of modulesToHandle) {
-            getOrCreate(dependentEntriesByModule, module, getNewSet).add(currentEntry);
+            getOrCreate(dependentEntriesByModule, module, (getNewSet)).add(entryIndex);
             for (const dependency of module.getDependenciesToBeIncluded()) {
                 if (!(dependency instanceof ExternalModule)) {
                     modulesToHandle.add(dependency);
@@ -16108,33 +16234,58 @@ function analyzeModuleGraph(entries) {
             for (const { resolution } of module.dynamicImports) {
                 if (resolution instanceof Module &&
                     resolution.includedDynamicImporters.length > 0 &&
-                    !allEntries.has(resolution)) {
-                    dynamicEntries.add(resolution);
-                    allEntries.add(resolution);
+                    !allEntriesSet.has(resolution)) {
+                    dynamicEntryModules.add(resolution);
+                    allEntriesSet.add(resolution);
+                    dynamicImportsForCurrentEntry.add(resolution);
                 }
             }
             for (const dependency of module.implicitlyLoadedBefore) {
-                if (!allEntries.has(dependency)) {
-                    dynamicEntries.add(dependency);
-                    allEntries.add(dependency);
+                if (!allEntriesSet.has(dependency)) {
+                    dynamicEntryModules.add(dependency);
+                    allEntriesSet.add(dependency);
                 }
             }
         }
+        entryIndex++;
     }
+    const allEntries = [...allEntriesSet];
+    const { dynamicEntries, dynamicImportsByEntry } = getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry);
     return {
-        allEntries: [...allEntries],
+        allEntries,
         dependentEntriesByModule,
-        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries)
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries),
+        dynamicImportsByEntry
     };
 }
-function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries) {
+function getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry) {
+    const entryIndexByModule = new Map();
+    const dynamicEntries = new Set();
+    for (const [entryIndex, entry] of allEntries.entries()) {
+        entryIndexByModule.set(entry, entryIndex);
+        if (dynamicEntryModules.has(entry)) {
+            dynamicEntries.add(entryIndex);
+        }
+    }
+    const dynamicImportsByEntry = [];
+    for (const dynamicImportModules of dynamicImportModulesByEntry) {
+        const dynamicImports = new Set();
+        for (const dynamicEntry of dynamicImportModules) {
+            dynamicImports.add(entryIndexByModule.get(dynamicEntry));
+        }
+        dynamicImportsByEntry.push(dynamicImports);
+    }
+    return { dynamicEntries, dynamicImportsByEntry };
+}
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries) {
     const dynamicallyDependentEntriesByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntries) {
-        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, getNewSet);
-        for (const importer of [
-            ...dynamicEntry.includedDynamicImporters,
-            ...dynamicEntry.implicitlyLoadedAfter
-        ]) {
+    for (const dynamicEntryIndex of dynamicEntries) {
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntryIndex, (getNewSet));
+        const dynamicEntry = allEntries[dynamicEntryIndex];
+        for (const importer of concatLazy([
+            dynamicEntry.includedDynamicImporters,
+            dynamicEntry.implicitlyLoadedAfter
+        ])) {
             for (const entry of dependentEntriesByModule.get(importer)) {
                 dynamicallyDependentEntries.add(entry);
             }
@@ -16142,57 +16293,80 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return 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, deepChunkOptimization)) {
-            continue;
-        }
-        else {
-            assignedEntries.add(entry);
-        }
-        for (const dependency of module.getDependenciesToBeIncluded()) {
-            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                modulesToHandle.add(dependency);
-            }
+function getChunksBySignature(modulesWithDependentEntries) {
+    var _a;
+    const chunkModules = Object.create(null);
+    for (const { dependentEntries, modules } of modulesWithDependentEntries) {
+        let chunkSignature = 0n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
         }
+        (chunkModules[_a = String(chunkSignature)] || (chunkModules[_a] = {
+            dependentEntries: new Set(dependentEntries),
+            modules: []
+        })).modules.push(...modules);
     }
+    return chunkModules;
 }
-const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
-// An approach to further speed this up might be
-// - first, create chunks without looking for modules already in memory
-// - all modules that are in the same chunk after this will behave the same
-//   -> Do not iterate by module but by equivalence group and merge chunks
-function isModuleAlreadyLoaded(dynamicallyDependentEntries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry, deepChunkOptimization) {
-    if (!deepChunkOptimization &&
-        dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
-        return false;
-    }
-    const entriesToCheck = new Set(dynamicallyDependentEntries);
-    for (const entry of entriesToCheck) {
-        if (!containedIn.has(entry)) {
-            if (staticEntries.has(entry)) {
-                return false;
-            }
-            const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
-            if (!deepChunkOptimization &&
-                dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
-                return false;
-            }
-            for (const dependentEntry of dynamicallyDependentEntries) {
-                entriesToCheck.add(dependentEntry);
-            }
+function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
+    for (const [module, dependentEntries] of dependentEntriesByModule) {
+        if (!modulesInManualChunks.has(module)) {
+            yield { dependentEntries, modules: [module] };
         }
     }
-    return true;
 }
-function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
-    const chunkModulesBySignature = getChunkModulesBySignature(assignedEntriesByModule, allEntries);
+/**
+ * This removes all unnecessary dynamic entries from the dependenEntries in its
+ * first argument. It will also consume its second argument, so if
+ * dynamicallyDependentEntriesByDynamicEntry is ever needed after this, we
+ * should make a copy.
+ */
+function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+    // The indices correspond to the indices in allEntries. The chunks correspond
+    // to bits in the bigint values where chunk 0 is the lowest bit.
+    const staticDependenciesPerEntry = allEntries.map(() => 0n);
+    const alreadyLoadedChunksPerEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+    // This toggles the bits for each chunk that is a dependency of an entry
+    let chunkMask = 1n;
+    for (const { dependentEntries } of chunks) {
+        for (const entryIndex of dependentEntries) {
+            staticDependenciesPerEntry[entryIndex] |= chunkMask;
+        }
+        chunkMask <<= 1n;
+    }
+    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+    // If we no longer want this, we should make a copy here.
+    const updatedDynamicallyDependentEntriesByDynamicEntry = dynamicallyDependentEntriesByDynamicEntry;
+    for (const [dynamicEntryIndex, updatedDynamicallyDependentEntries] of updatedDynamicallyDependentEntriesByDynamicEntry) {
+        updatedDynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const previousLoadedModules = alreadyLoadedChunksPerEntry[dynamicEntryIndex];
+        let newLoadedModules = previousLoadedModules;
+        for (const entryIndex of updatedDynamicallyDependentEntries) {
+            newLoadedModules &=
+                staticDependenciesPerEntry[entryIndex] | alreadyLoadedChunksPerEntry[entryIndex];
+        }
+        if (newLoadedModules !== previousLoadedModules) {
+            alreadyLoadedChunksPerEntry[dynamicEntryIndex] = newLoadedModules;
+            for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
+                getOrCreate(updatedDynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
+            }
+        }
+    }
+    // Remove entries from dependent entries if a chunk is already loaded without
+    // that entry.
+    chunkMask = 1n;
+    for (const { dependentEntries } of chunks) {
+        for (const entryIndex of dependentEntries) {
+            if ((alreadyLoadedChunksPerEntry[entryIndex] & chunkMask) === chunkMask) {
+                dependentEntries.delete(entryIndex);
+            }
+        }
+        chunkMask <<= 1n;
+    }
+}
+function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
     return minChunkSize === 0
-        ? Object.values(chunkModulesBySignature).map(modules => ({
+        ? Object.values(chunkModulesBySignature).map(({ modules }) => ({
             alias: null,
             modules
         }))
@@ -16201,23 +16375,6 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             modules
         }));
 }
-function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
-    const chunkModules = Object.create(null);
-    for (const [module, assignedEntries] of assignedEntriesByModule) {
-        let chunkSignature = '';
-        for (const entry of allEntries) {
-            chunkSignature += assignedEntries.has(entry) ? CHAR_DEPENDENT : CHAR_INDEPENDENT;
-        }
-        const chunk = chunkModules[chunkSignature];
-        if (chunk) {
-            chunk.push(module);
-        }
-        else {
-            chunkModules[chunkSignature] = [module];
-        }
-    }
-    return chunkModules;
-}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -16289,17 +16446,20 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
  *    following the above rules (a) and (b), starting with the smallest chunks
  *    to look for possible merge targets.
  */
+// TODO instead of picking the "closest" chunk, we could actually use a
+//  technique similar to what we do for side effects to compare the size of the
+//  static dependencies that are not part of the correlated dependencies
 function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
     timeStart('optimize chunks', 3);
     const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
+    console.log('Before eliminating small chunks, there were\n', Object.keys(chunkModulesBySignature).length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
     if (chunkPartition.small.size > 0) {
         mergeChunks(chunkPartition, minChunkSize);
     }
+    console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-const CHAR_DEPENDENT = 'X';
-const CHAR_INDEPENDENT = '_';
 function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
@@ -16308,13 +16468,7 @@ function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunk
     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);
-            }
-        }
+    for (const [signature, { dependentEntries, modules }] of Object.entries(chunkModulesBySignature)) {
         const chunkDescription = {
             correlatedSideEffects: new Set(),
             dependencies: new Set(),
@@ -16391,8 +16545,6 @@ function compareChunkSize({ size: sizeA }, { size: sizeB }) {
     return sizeA - sizeB;
 }
 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;
@@ -16440,11 +16592,10 @@ function mergeChunks(chunkPartition, minChunkSize) {
                     dependentChunk.dependencies.add(closestChunk);
                 }
                 dependencies.delete(closestChunk);
+                dependentChunks.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
@@ -16500,58 +16651,6 @@ function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentE
     }
     return distance;
 }
-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
 function commondir(files) {
@@ -16909,7 +17008,7 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         }
         return result.code;
     });
-    const { compact, dir, file, sourcemap, sourcemapExcludeSources, sourcemapFile, sourcemapPathTransform } = options;
+    const { compact, dir, file, sourcemap, sourcemapExcludeSources, sourcemapFile, sourcemapPathTransform, sourcemapIgnoreList } = options;
     if (!compact && code[code.length - 1] !== '\n')
         code += '\n';
     if (sourcemap) {
@@ -16923,18 +17022,31 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
             resultingFile = resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
         map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, onwarn);
-        map.sources = map.sources
-            .map(sourcePath => {
+        for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
+            let sourcePath = map.sources[sourcesIndex];
+            const sourcemapPath = `${resultingFile}.map`;
+            if (sourcemapIgnoreList) {
+                const ignoreList = sourcemapIgnoreList(sourcePath, sourcemapPath);
+                if (typeof ignoreList !== 'boolean') {
+                    error(errorFailedValidation('sourcemapIgnoreList function must return a boolean.'));
+                }
+                if (ignoreList) {
+                    if (map.x_google_ignoreList === undefined) {
+                        map.x_google_ignoreList = [];
+                    }
+                    if (!map.x_google_ignoreList.includes(sourcesIndex)) {
+                        map.x_google_ignoreList.push(sourcesIndex);
+                    }
+                }
+            }
             if (sourcemapPathTransform) {
-                const newSourcePath = sourcemapPathTransform(sourcePath, `${resultingFile}.map`);
-                if (typeof newSourcePath !== 'string') {
+                sourcePath = sourcemapPathTransform(sourcePath, sourcemapPath);
+                if (typeof sourcePath !== 'string') {
                     error(errorFailedValidation(`sourcemapPathTransform function must return a string.`));
                 }
-                return newSourcePath;
             }
-            return sourcePath;
-        })
-            .map(normalize);
+            map.sources[sourcesIndex] = normalize(sourcePath);
+        }
         timeEnd('sourcemaps', 3);
     }
     return {
@@ -17152,7 +17264,7 @@ class Bundle {
         this.pluginDriver.finaliseAssets();
     }
     async generateChunks(bundle, getHashPlaceholder) {
-        const { experimentalDeepDynamicChunkOptimization, experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
+        const { experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
         const manualChunkAliasByEntry = typeof manualChunks === 'object'
             ? await this.addManualChunks(manualChunks)
             : this.assignManualChunks(manualChunks);
@@ -17166,7 +17278,7 @@ class Bundle {
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
-                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, experimentalDeepDynamicChunkOptimization)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize)) {
             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);
@@ -24301,7 +24413,8 @@ class Graph {
         }
     }
     includeStatements() {
-        for (const module of [...this.entryModules, ...this.implicitEntryModules]) {
+        const entryModules = [...this.entryModules, ...this.implicitEntryModules];
+        for (const module of entryModules) {
             markModuleAndImpureDependenciesAsExecuted(module);
         }
         if (this.options.treeshake) {
@@ -24322,7 +24435,7 @@ class Graph {
                 if (treeshakingPass === 1) {
                     // We only include exports after the first pass to avoid issues with
                     // the TDZ detection logic
-                    for (const module of [...this.entryModules, ...this.implicitEntryModules]) {
+                    for (const module of entryModules) {
                         if (module.preserveSignature !== false) {
                             module.includeAllExports(false);
                             this.needsTreeshakingPass = true;
@@ -24810,7 +24923,9 @@ const getAcornInjectPlugins = (config) => [
     importAssertions,
     ...ensureArray(config.acornInjectPlugins)
 ];
-const getCache = (config) => config.cache?.cache || config.cache;
+const getCache = (config) => config.cache === true // `true` is the default
+    ? undefined
+    : config.cache?.cache || config.cache;
 const getIdMatcher = (option) => {
     if (option === true) {
         return () => true;
@@ -24957,7 +25072,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,
+        experimentalDeepDynamicChunkOptimization: getExperimentalDeepDynamicChunkOptimization(config, inputOptions),
         experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
@@ -24994,6 +25109,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         sourcemapBaseUrl: getSourcemapBaseUrl(config),
         sourcemapExcludeSources: config.sourcemapExcludeSources || false,
         sourcemapFile: config.sourcemapFile,
+        sourcemapIgnoreList: config.sourcemapIgnoreList,
         sourcemapPathTransform: config.sourcemapPathTransform,
         strict: config.strict ?? true,
         systemNullSetters: config.systemNullSetters ?? true,
@@ -25134,6 +25250,13 @@ const getEntryFileNames = (config, unsetOptions) => {
     }
     return configEntryFileNames ?? '[name].js';
 };
+function getExperimentalDeepDynamicChunkOptimization(config, inputOptions) {
+    const configExperimentalDeepDynamicChunkOptimization = config.experimentalDeepDynamicChunkOptimization;
+    if (configExperimentalDeepDynamicChunkOptimization != null) {
+        warnDeprecation(`The "output.experimentalDeepDynamicChunkOptimization" option is deprecated as Rollup always runs the full chunking algorithm now. The option should be removed.`, URL_OUTPUT_EXPERIMENTALDEEPCHUNKOPTIMIZATION, true, inputOptions);
+    }
+    return configExperimentalDeepDynamicChunkOptimization || false;
+}
 function getExports(config, unsetOptions) {
     const configExports = config.exports;
     if (configExports == null) {
@@ -25547,7 +25670,7 @@ async function mergeOptions(config, rawCommandOptions = EMPTY_COMMAND_OPTIONS, d
     const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn)));
     warnUnknownOptions(command, [
         ...Object.keys(inputOptions),
-        ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapPathTransform'),
+        ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapIgnoreList' && option !== 'sourcemapPathTransform'),
         ...Object.keys(commandAliases),
         'bundleConfigAsCjs',
         'config',
@@ -25682,6 +25805,7 @@ async function mergeOutputOptions(config, overrides, warn) {
         sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
         sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
         sourcemapFile: getOption('sourcemapFile'),
+        sourcemapIgnoreList: getOption('sourcemapIgnoreList'),
         sourcemapPathTransform: getOption('sourcemapPathTransform'),
         strict: getOption('strict'),
         systemNullSetters: getOption('systemNullSetters'),