rollup 3.16.0 → 3.17.0

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.16.0
-	Fri, 17 Feb 2023 13:26:29 GMT - commit 8ba73f4f643e5ffe01fc9ad846748f6d5b7963c2
+	Rollup.js v3.17.0
+	Sat, 18 Feb 2023 05:06:04 GMT - commit 0c33497a7de91e150a7d242125e8da9dd4e4a3ac
 
 	https://github.com/rollup/rollup
 
@@ -18,13 +18,14 @@ const rollup = require('../shared/rollup.js');
 const require$$2 = require('util');
 const require$$0 = require('path');
 const require$$0$1 = require('fs');
+const fseventsImporter = require('../shared/fsevents-importer.js');
 const promises = require('node:fs/promises');
 const node_path = require('node:path');
 const loadConfigFile_js = require('../shared/loadConfigFile.js');
+require('tty');
 require('node:perf_hooks');
 require('node:crypto');
 require('node:events');
-require('tty');
 require('node:url');
 
 const help = "rollup version __VERSION__\n=====================================\n\nUsage: rollup [options] <entry file>\n\nBasic options:\n\n-c, --config <filename>     Use this config file (if argument is used but value\n                              is unspecified, defaults to rollup.config.js)\n-d, --dir <dirname>         Directory for chunks (if absent, prints to stdout)\n-e, --external <ids>        Comma-separate list of module IDs to exclude\n-f, --format <format>       Type of output (amd, cjs, es, iife, umd, system)\n-g, --globals <pairs>       Comma-separate list of `moduleID:Global` pairs\n-h, --help                  Show this help message\n-i, --input <filename>      Input (alternative to <entry file>)\n-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)\n-n, --name <name>           Name for UMD export\n-o, --file <output>         Single output file (if absent, prints to stdout)\n-p, --plugin <plugin>       Use the plugin specified (may be repeated)\n-v, --version               Show version number\n-w, --watch                 Watch files in bundle and rebuild on changes\n--amd.autoId                Generate the AMD ID based off the chunk name\n--amd.basePath <prefix>     Path to prepend to auto generated AMD ID\n--amd.define <name>         Function to use in place of `define`\n--amd.forceJsExtensionForImports Use `.js` extension in AMD imports\n--amd.id <id>               ID for AMD module (default is anonymous)\n--assetFileNames <pattern>  Name pattern for emitted assets\n--banner <text>             Code to insert at top of bundle (outside wrapper)\n--chunkFileNames <pattern>  Name pattern for emitted secondary chunks\n--compact                   Minify wrapper code\n--context <variable>        Specify top-level `this` value\n--no-dynamicImportInCjs     Write external dynamic CommonJS imports as require\n--entryFileNames <pattern>  Name pattern for emitted entry chunks\n--environment <values>      Settings passed to config file (see example)\n--no-esModule               Do not add __esModule property\n--exports <mode>            Specify export mode (auto, default, named, none)\n--extend                    Extend global variable defined by --name\n--no-externalImportAssertions Omit import assertions in \"es\" output\n--no-externalLiveBindings   Do not generate code to support live bindings\n--failAfterWarnings         Exit with an error if the build produced warnings\n--footer <text>             Code to insert at end of bundle (outside wrapper)\n--no-freeze                 Do not freeze namespace objects\n--generatedCode <preset>    Which code features to use (es5/es2015)\n--generatedCode.arrowFunctions Use arrow functions in generated code\n--generatedCode.constBindings Use \"const\" in generated code\n--generatedCode.objectShorthand Use shorthand properties in generated code\n--no-generatedCode.reservedNamesAsProps Always quote reserved names as props\n--generatedCode.symbols     Use symbols in generated code\n--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks\n--no-indent                 Don't indent result\n--inlineDynamicImports      Create single bundle when using dynamic imports\n--no-interop                Do not include interop block\n--intro <text>              Code to insert at top of bundle (inside wrapper)\n--no-makeAbsoluteExternalsRelative Prevent normalization of external imports\n--maxParallelFileOps <value> How many files to read in parallel\n--minifyInternalExports     Force or disable minification of internal exports\n--noConflict                Generate a noConflict method for UMD globals\n--outro <text>              Code to insert at end of bundle (inside wrapper)\n--perf                      Display performance timings\n--no-preserveEntrySignatures Avoid facade chunks for entry points\n--preserveModules           Preserve module structure\n--preserveModulesRoot       Put preserved modules under this path at root level\n--preserveSymlinks          Do not follow symlinks when resolving files\n--no-sanitizeFileName       Do not replace invalid characters in file names\n--shimMissingExports        Create shim variables for missing exports\n--silent                    Don't print warnings\n--sourcemapBaseUrl <url>    Emit absolute sourcemap URLs with given base\n--sourcemapExcludeSources   Do not include source code in source maps\n--sourcemapFile <file>      Specify bundle position for source maps\n--stdin=ext                 Specify file extension used for stdin input\n--no-stdin                  Do not read \"-\" from stdin\n--no-strict                 Don't emit `\"use strict\";` in the generated modules\n--strictDeprecations        Throw errors for deprecated features\n--no-systemNullSetters      Do not replace empty SystemJS setters with `null`\n--no-treeshake              Disable tree-shaking optimisations\n--no-treeshake.annotations  Ignore pure call annotations\n--treeshake.correctVarValueBeforeDeclaration Deoptimize variables until declared\n--treeshake.manualPureFunctions <names> Manually declare functions as pure\n--no-treeshake.moduleSideEffects Assume modules have no side effects\n--no-treeshake.propertyReadSideEffects Ignore property access side effects\n--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking\n--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw\n--validate                  Validate output\n--waitForBundleInput        Wait for bundle input files\n--watch.buildDelay <number> Throttle watch rebuilds\n--no-watch.clearScreen      Do not clear the screen when rebuilding\n--watch.exclude <files>     Exclude files from being watched\n--watch.include <files>     Limit watching to specified files\n--watch.onBundleEnd <cmd>   Shell command to run on `\"BUNDLE_END\"` event\n--watch.onBundleStart <cmd> Shell command to run on `\"BUNDLE_START\"` event\n--watch.onEnd <cmd>         Shell command to run on `\"END\"` event\n--watch.onError <cmd>       Shell command to run on `\"ERROR\"` event\n--watch.onStart <cmd>       Shell command to run on `\"START\"` event\n--watch.skipWrite           Do not write files to disk when watching\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n  -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n";
@@ -1648,7 +1649,7 @@ async function runRollup(command) {
         }
     }
     if (rollup.isWatchEnabled(command.watch)) {
-        await rollup.loadFsEvents();
+        await fseventsImporter.loadFsEvents();
         const { watch } = await Promise.resolve().then(() => require('../shared/watch-cli.js'));
         watch(command);
     }

package/dist/es/rollup.js

@@ -1,13 +1,13 @@
 /*
   @license
-	Rollup.js v3.16.0
-	Fri, 17 Feb 2023 13:26:29 GMT - commit 8ba73f4f643e5ffe01fc9ad846748f6d5b7963c2
+	Rollup.js v3.17.0
+	Sat, 18 Feb 2023 05:06:04 GMT - commit 0c33497a7de91e150a7d242125e8da9dd4e4a3ac
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-export { version as VERSION, defineConfig, rollup, watch } from './shared/rollup.js';
+export { version as VERSION, defineConfig, rollup, watch } from './shared/node-entry.js';
 import 'node:path';
 import 'path';
 import 'node:process';

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

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.16.0
-	Fri, 17 Feb 2023 13:26:29 GMT - commit 8ba73f4f643e5ffe01fc9ad846748f6d5b7963c2
+	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.16.0";
+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.
@@ -16303,8 +16460,6 @@ function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSi
     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 = [];
@@ -16313,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(),
@@ -17115,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);
@@ -17129,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);
@@ -24923,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,
@@ -25101,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) {

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.16.0
-	Fri, 17 Feb 2023 13:26:29 GMT - commit 8ba73f4f643e5ffe01fc9ad846748f6d5b7963c2
+	Rollup.js v3.17.0
+	Sat, 18 Feb 2023 05:06:04 GMT - commit 0c33497a7de91e150a7d242125e8da9dd4e4a3ac
 
 	https://github.com/rollup/rollup
 
@@ -9,7 +9,7 @@
 */
 import { resolve } from 'node:path';
 import process$1 from 'node:process';
-import { picomatchExports, getAugmentedNamespace, fseventsImporter, createFilter, rollupInternal } from './rollup.js';
+import { picomatchExports, getAugmentedNamespace, fseventsImporter, createFilter, rollupInternal } from './node-entry.js';
 import { platform } from 'node:os';
 import require$$0$1 from 'fs';
 import require$$2 from 'util';

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.16.0
-	Fri, 17 Feb 2023 13:26:29 GMT - commit 8ba73f4f643e5ffe01fc9ad846748f6d5b7963c2
+	Rollup.js v3.17.0
+	Sat, 18 Feb 2023 05:06:04 GMT - commit 0c33497a7de91e150a7d242125e8da9dd4e4a3ac
 
 	https://github.com/rollup/rollup
 
@@ -17,11 +17,11 @@ require('node:process');
 require('node:url');
 require('./shared/rollup.js');
 const loadConfigFile_js = require('./shared/loadConfigFile.js');
+require('tty');
 require('path');
 require('node:perf_hooks');
 require('node:crypto');
 require('node:events');
-require('tty');
 
 
 

package/dist/rollup.d.ts

@@ -653,6 +653,7 @@ export interface OutputOptions {
 	dynamicImportInCjs?: boolean;
 	entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
 	esModule?: boolean | 'if-default-prop';
+	/** @deprecated This option is no longer needed and ignored. */
 	experimentalDeepDynamicChunkOptimization?: boolean;
 	experimentalMinChunkSize?: number;
 	exports?: 'default' | 'named' | 'none' | 'auto';
@@ -708,6 +709,7 @@ export interface NormalizedOutputOptions {
 	dynamicImportInCjs: boolean;
 	entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
 	esModule: boolean | 'if-default-prop';
+	/** @deprecated This option is no longer needed and ignored. */
 	experimentalDeepDynamicChunkOptimization: boolean;
 	experimentalMinChunkSize: number;
 	exports: 'default' | 'named' | 'none' | 'auto';