rollup 4.6.1 → 4.8.0

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 
@@ -12,21 +12,89 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const rollup = require('./shared/rollup.js');
-const watchProxy = require('./shared/watch-proxy.js');
-require('./shared/parseAst.js');
-require('./native.js');
-require('node:path');
+const parseAst_js = require('./shared/parseAst.js');
+const fseventsImporter = require('./shared/fsevents-importer.js');
 require('node:process');
 require('tty');
+require('node:path');
 require('path');
 require('node:perf_hooks');
+require('./native.js');
 require('node:fs/promises');
-require('./shared/fsevents-importer.js');
 
+class WatchEmitter {
+    constructor() {
+        this.currentHandlers = Object.create(null);
+        this.persistentHandlers = Object.create(null);
+    }
+    // Will be overwritten by Rollup
+    async close() { }
+    emit(event, ...parameters) {
+        return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
+    }
+    off(event, listener) {
+        const listeners = this.persistentHandlers[event];
+        if (listeners) {
+            // A hack stolen from "mitt": ">>> 0" does not change numbers >= 0, but -1
+            // (which would remove the last array element if used unchanged) is turned
+            // into max_int, which is outside the array and does not change anything.
+            listeners.splice(listeners.indexOf(listener) >>> 0, 1);
+        }
+        return this;
+    }
+    on(event, listener) {
+        this.getPersistentHandlers(event).push(listener);
+        return this;
+    }
+    onCurrentRun(event, listener) {
+        this.getCurrentHandlers(event).push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const selfRemovingListener = (...parameters) => {
+            this.off(event, selfRemovingListener);
+            return listener(...parameters);
+        };
+        this.on(event, selfRemovingListener);
+        return this;
+    }
+    removeAllListeners() {
+        this.removeListenersForCurrentRun();
+        this.persistentHandlers = Object.create(null);
+        return this;
+    }
+    removeListenersForCurrentRun() {
+        this.currentHandlers = Object.create(null);
+        return this;
+    }
+    getCurrentHandlers(event) {
+        return this.currentHandlers[event] || (this.currentHandlers[event] = []);
+    }
+    getPersistentHandlers(event) {
+        return this.persistentHandlers[event] || (this.persistentHandlers[event] = []);
+    }
+}
 
+function watch(configs) {
+    const emitter = new WatchEmitter();
+    watchInternal(configs, emitter).catch(error => {
+        rollup.handleError(error);
+    });
+    return emitter;
+}
+async function watchInternal(configs, emitter) {
+    const optionsList = await Promise.all(rollup.ensureArray(configs).map(config => rollup.mergeOptions(config, true)));
+    const watchOptionsList = optionsList.filter(config => config.watch !== false);
+    if (watchOptionsList.length === 0) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('watch', parseAst_js.URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
+    }
+    await fseventsImporter.loadFsEvents();
+    const { Watcher } = await Promise.resolve().then(() => require('./shared/watch.js'));
+    new Watcher(watchOptionsList, emitter);
+}
 
 exports.VERSION = rollup.version;
 exports.defineConfig = rollup.defineConfig;
 exports.rollup = rollup.rollup;
-exports.watch = watchProxy.watch;
+exports.watch = watch;
 //# sourceMappingURL=rollup.js.map

package/dist/shared/fsevents-importer.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/shared/parseAst.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.6.1";
+var version = "4.8.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -17233,11 +17233,15 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
-    // This mutates initialChunks but also clears
-    // dynamicallyDependentEntriesByDynamicEntry as side effect
-    removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize, log).map(({ modules }) => ({
+    const chunkAtoms = getChunksWithSameDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
+    const staticDependencyAtomsByEntry = getStaticDependencyAtomsByEntry(allEntries, chunkAtoms);
+    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+    // If we no longer want this, we should make a copy here.
+    const alreadyLoadedAtomsByEntry = getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+    // This mutates the dependentEntries in chunkAtoms
+    removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry);
+    const { chunks, sideEffectAtoms, sizeByAtom } = getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize);
+    chunkDefinitions.push(...getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log).map(({ modules }) => ({
         alias: null,
         modules
     })));
@@ -17346,7 +17350,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksFromDependentEntries(modulesWithDependentEntries) {
+function getChunksWithSameDependentEntries(modulesWithDependentEntries) {
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
         let chunkSignature = 0n;
@@ -17367,55 +17371,152 @@ function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManu
         }
     }
 }
-/**
- * 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
+function getStaticDependencyAtomsByEntry(allEntries, chunkAtoms) {
+    // The indices correspond to the indices in allEntries. The atoms 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) {
+    const staticDependencyAtomsByEntry = allEntries.map(() => 0n);
+    // This toggles the bits for each atom that is a dependency of an entry
+    let atomMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
         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;
+            staticDependencyAtomsByEntry[entryIndex] |= atomMask;
+        }
+        atomMask <<= 1n;
+    }
+    return staticDependencyAtomsByEntry;
+}
+// Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+function getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+    // Dynamic entries have all atoms as already loaded initially because we then
+    // intersect with the static dependency atoms of all dynamic importers.
+    // Static entries cannot have already loaded atoms.
+    const alreadyLoadedAtomsByEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+    for (const [dynamicEntryIndex, dynamicallyDependentEntries] of dynamicallyDependentEntriesByDynamicEntry) {
+        // We delete here so that they can be added again if necessary to be handled
+        // again by the loop
+        dynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const knownLoadedAtoms = alreadyLoadedAtomsByEntry[dynamicEntryIndex];
+        let updatedLoadedAtoms = knownLoadedAtoms;
+        for (const entryIndex of dynamicallyDependentEntries) {
+            updatedLoadedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        // If the knownLoadedAtoms changed, all dependent dynamic entries need to be
+        // updated again
+        if (updatedLoadedAtoms !== knownLoadedAtoms) {
+            alreadyLoadedAtomsByEntry[dynamicEntryIndex] = updatedLoadedAtoms;
             for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
-                getOrCreate(updatedDynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
+                // If this adds an entry that was deleted before, it will be handled
+                // again. This is the reason why we delete every entry from this map
+                // that we processed.
+                getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
             }
         }
     }
+    return alreadyLoadedAtomsByEntry;
+}
+/**
+ * This removes all unnecessary dynamic entries from the dependentEntries in its
+ * first argument if a chunk is already loaded without that entry.
+ */
+function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry) {
     // Remove entries from dependent entries if a chunk is already loaded without
     // that entry.
-    chunkMask = 1n;
-    for (const { dependentEntries } of chunks) {
+    let chunkMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
         for (const entryIndex of dependentEntries) {
-            if ((alreadyLoadedChunksPerEntry[entryIndex] & chunkMask) === chunkMask) {
+            if ((alreadyLoadedAtomsByEntry[entryIndex] & chunkMask) === chunkMask) {
                 dependentEntries.delete(entryIndex);
             }
         }
         chunkMask <<= 1n;
     }
 }
+function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
+    const chunksBySignature = Object.create(null);
+    const chunkByModule = new Map();
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let atomMask = 1n;
+    for (const { dependentEntries, modules } of chunkAtoms) {
+        let chunkSignature = 0n;
+        let correlatedAtoms = -1n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+            // Correlated atoms are the atoms that are guaranteed to be loaded as
+            // well when a given atom is loaded. It is the intersection of the already
+            // loaded modules of each chunk merged with its static dependencies.
+            correlatedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        const chunk = (chunksBySignature[String(chunkSignature)] ||= {
+            containedAtoms: 0n,
+            correlatedAtoms,
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            dependentEntries: new Set(dependentEntries),
+            modules: [],
+            pure: true,
+            size: 0
+        });
+        let atomSize = 0;
+        let pure = true;
+        for (const module of modules) {
+            chunkByModule.set(module, chunk);
+            // Unfortunately, we cannot take tree-shaking into account here because
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure &&= !module.hasEffects();
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                atomSize += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
+        }
+        if (!pure) {
+            sideEffectAtoms |= atomMask;
+        }
+        sizeByAtom.push(atomSize);
+        chunk.containedAtoms |= atomMask;
+        chunk.modules.push(...modules);
+        chunk.pure &&= pure;
+        chunk.size += atomSize;
+        atomMask <<= 1n;
+    }
+    const chunks = Object.values(chunksBySignature);
+    sideEffectAtoms |= addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, atomMask);
+    return { chunks, sideEffectAtoms, sizeByAtom };
+}
+function addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, nextAvailableAtomMask) {
+    const signatureByExternalModule = new Map();
+    let externalSideEffectAtoms = 0n;
+    for (const chunk of chunks) {
+        const { dependencies, modules } = chunk;
+        for (const module of modules) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (dependency instanceof ExternalModule) {
+                    if (dependency.info.moduleSideEffects) {
+                        const signature = getOrCreate(signatureByExternalModule, dependency, () => {
+                            const signature = nextAvailableAtomMask;
+                            nextAvailableAtomMask <<= 1n;
+                            externalSideEffectAtoms |= signature;
+                            return signature;
+                        });
+                        chunk.containedAtoms |= signature;
+                        chunk.correlatedAtoms |= signature;
+                    }
+                }
+                else {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
+                }
+            }
+        }
+    }
+    return externalSideEffectAtoms;
+}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -17492,77 +17593,44 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
  *    following the rule (a), starting with the smallest chunks to look for
  *    possible merge targets.
  */
-function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize, log) {
+function getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    const chunkPartition = getPartitionedChunks(chunks, minChunkSize);
     if (!chunkPartition) {
         timeEnd('optimize chunks', 3);
-        return initialChunks; // the actual modules
+        return chunks; // the actual modules
     }
     minChunkSize > 1 &&
-        log('info', parseAst_js.logOptimizeChunkStatus(initialChunks.length, chunkPartition.small.size, 'Initially'));
-    mergeChunks(chunkPartition, minChunkSize);
+        log('info', parseAst_js.logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, 'Initially'));
+    mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
     minChunkSize > 1 &&
         log('info', parseAst_js.logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(chunks, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
-    const chunkByModule = new Map();
-    const sizeByAtom = [];
-    let sideEffectAtoms = 0n;
-    let containedAtoms = 1n;
-    for (const { dependentEntries, modules } of initialChunks) {
-        const chunkDescription = {
-            containedAtoms,
-            correlatedAtoms: 0n,
-            dependencies: new Set(),
-            dependentChunks: new Set(),
-            dependentEntries,
-            modules,
-            pure: true,
-            size: 0
-        };
-        let size = 0;
-        let pure = true;
-        for (const module of modules) {
-            chunkByModule.set(module, chunkDescription);
-            // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet, but we can detect empty modules
-            if (module.isIncluded()) {
-                pure &&= !module.hasEffects();
-                // we use a trivial size for the default minChunkSize to improve
-                // performance
-                size += minChunkSize > 1 ? module.estimateSize() : 1;
-            }
-        }
-        chunkDescription.pure = pure;
-        chunkDescription.size = size;
-        sizeByAtom.push(size);
-        if (!pure) {
-            sideEffectAtoms |= containedAtoms;
-        }
-        (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
-        containedAtoms <<= 1n;
+    for (const chunk of chunks) {
+        (chunk.size < minChunkSize ? smallChunks : bigChunks).push(chunk);
     }
-    // If there are no small chunks, we will not optimize
     if (smallChunks.length === 0) {
         return null;
     }
-    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
+    smallChunks.sort(compareChunkSize);
+    bigChunks.sort(compareChunkSize);
     return {
         big: new Set(bigChunks),
-        sideEffectAtoms,
-        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function mergeChunks(chunkPartition, minChunkSize) {
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom) {
     const { small } = chunkPartition;
     for (const mergedChunk of small) {
-        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, sideEffectAtoms, sizeByAtom, 
         // In the default case, we do not accept size increases
         minChunkSize <= 1 ? 1 : Infinity);
         if (bestTargetChunk) {
@@ -17594,57 +17662,7 @@ function mergeChunks(chunkPartition, minChunkSize) {
         }
     }
 }
-function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
-    const signatureByExternalModule = new Map();
-    let sideEffectAtoms = 0n;
-    const atomsByEntry = [];
-    for (let index = 0; index < numberOfEntries; index++) {
-        atomsByEntry.push(0n);
-    }
-    for (const chunks of chunkLists) {
-        chunks.sort(compareChunkSize);
-        for (const chunk of chunks) {
-            const { dependencies, dependentEntries, modules } = chunk;
-            for (const module of modules) {
-                for (const dependency of module.getDependenciesToBeIncluded()) {
-                    if (dependency instanceof ExternalModule) {
-                        if (dependency.info.moduleSideEffects) {
-                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
-                                const signature = nextAtomSignature;
-                                nextAtomSignature <<= 1n;
-                                sideEffectAtoms |= signature;
-                                return signature;
-                            });
-                        }
-                    }
-                    else {
-                        const dependencyChunk = chunkByModule.get(dependency);
-                        if (dependencyChunk && dependencyChunk !== chunk) {
-                            dependencies.add(dependencyChunk);
-                            dependencyChunk.dependentChunks.add(chunk);
-                        }
-                    }
-                }
-            }
-            const { containedAtoms } = chunk;
-            for (const entryIndex of dependentEntries) {
-                atomsByEntry[entryIndex] |= containedAtoms;
-            }
-        }
-    }
-    for (const chunks of chunkLists) {
-        for (const chunk of chunks) {
-            const { dependentEntries } = chunk;
-            // Correlated atoms are the intersection of all entry atoms
-            chunk.correlatedAtoms = -1n;
-            for (const entryIndex of dependentEntries) {
-                chunk.correlatedAtoms &= atomsByEntry[entryIndex];
-            }
-        }
-    }
-    return sideEffectAtoms;
-}
-function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+function findBestMergeTarget(mergedChunk, { big, small }, sideEffectAtoms, sizeByAtom, smallestAdditionalSize) {
     let bestTargetChunk = null;
     // In the default case, we do not accept size increases
     for (const targetChunk of concatLazy([small, big])) {
@@ -17660,12 +17678,6 @@ function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, sm
     }
     return bestTargetChunk;
 }
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-}
-function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
 /**
  * Determine the additional unused code size that would be added by merging the
  * two chunks. This is not an exact measurement but rather an upper bound. If
@@ -17723,6 +17735,9 @@ function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
     }
     return size;
 }
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
 
 // ported from https://github.com/substack/node-commondir
 function commondir(files) {

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup
 
@@ -19,7 +19,7 @@ const rollup = require('./rollup.js');
 const parseAst_js = require('./parseAst.js');
 const loadConfigFile_js = require('./loadConfigFile.js');
 const node_child_process = require('node:child_process');
-const watchProxy = require('./watch-proxy.js');
+const rollup_js = require('../rollup.js');
 require('fs');
 require('util');
 require('stream');
@@ -485,7 +485,7 @@ async function watch(command) {
         await start(options, warnings);
     }
     async function start(configs, warnings) {
-        watcher = watchProxy.watch(configs);
+        watcher = rollup_js.watch(configs);
         watcher.on('event', event => {
             switch (event.code) {
                 case 'ERROR': {

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.6.1
-	Thu, 30 Nov 2023 05:22:35 GMT - commit ded37aa8f95d5ba9786fa8903ef3424fd0549c73
+	Rollup.js v4.8.0
+	Mon, 11 Dec 2023 06:24:24 GMT - commit 62b648e1cc6a1f00260bb85aa2050097bb4afd2b
 
 	https://github.com/rollup/rollup