rollup 4.7.0 → 4.9.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.7.0
-	Fri, 08 Dec 2023 07:57:30 GMT - commit 098e29ca3e0643006870f9ed94710fd3004a9043
+	Rollup.js v4.9.0
+	Wed, 13 Dec 2023 09:23:48 GMT - commit c5337ef28a71c796e768a9f0edb3d7259a93f1aa
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.7.0";
+var version = "4.9.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -3506,6 +3506,20 @@ function makeLegal(value) {
         value = `_${value}`;
     return value || '_';
 }
+const VALID_IDENTIFIER_REGEXP = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+const NUMBER_REGEXP = /^\d+$/;
+function stringifyObjectKeyIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key) || NUMBER_REGEXP.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+function stringifyIdentifierIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
 
 class ExternalModule {
     constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath, attributes) {
@@ -9281,7 +9295,7 @@ function getSystemExportStatement(exportedVariables, { exportNamesByVariable, sn
     if (exportedVariables.length === 1 &&
         exportNamesByVariable.get(exportedVariables[0]).length === 1) {
         const variable = exportedVariables[0];
-        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
+        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
     }
     else {
         const fields = [];
@@ -9293,8 +9307,9 @@ function getSystemExportStatement(exportedVariables, { exportNamesByVariable, sn
         return `exports(${getObject(fields, { lineBreakIndent: null })})`;
     }
 }
+// This is only invoked if there is exactly one export name
 function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
-    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
+    code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
     code.appendLeft(expressionEnd, ')');
 }
 function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
@@ -13614,7 +13629,7 @@ class NamespaceVariable extends Variable {
             if (this.referencedEarly || variable.isReassigned || variable === this) {
                 return [
                     null,
-                    `get ${name}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
+                    `get ${stringifyObjectKeyIfNeeded(name)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
                 ];
             }
             return [name, variable.getName(getPropertyAccess)];
@@ -14645,7 +14660,7 @@ class Module {
             this.addSource(source, node);
             if (node.exported) {
                 // export * as name from './other'
-                const name = node.exported.name;
+                const name = node.exported instanceof Literal ? node.exported.value : node.exported.name;
                 this.assertUniqueExportName(name, node.exported.start);
                 this.reexportDescriptions.set(name, {
                     localName: '*',
@@ -14977,7 +14992,7 @@ function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snip
                             name: null
                         });
                         exportBlock +=
-                            `Object.defineProperty(exports,${_}'${specifier.reexported}',${_}{${n}` +
+                            `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n}` +
                                 `${t}enumerable:${_}true,${n}` +
                                 `${t}get:${_}${left}${importName}${right}${n}});`;
                     }
@@ -15355,7 +15370,7 @@ function getImportBlock(dependencies, { _ }) {
                 importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
                     .map(specifier => specifier.imported === specifier.local
                     ? specifier.imported
-                    : `${specifier.imported} as ${specifier.local}`)
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`)
                     .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
             }
         }
@@ -15383,14 +15398,16 @@ function getImportBlock(dependencies, { _ }) {
                     importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
                 }
                 for (const specifier of namespaceReexports) {
-                    importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${specifier.reexported}`} };`);
+                    importBlock.push(`export${_}{${_}${name === specifier.reexported
+                        ? name
+                        : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
                 }
             }
             if (namedReexports.length > 0) {
                 importBlock.push(`export${_}{${_}${namedReexports
                     .map(specifier => specifier.imported === specifier.reexported
-                    ? specifier.imported
-                    : `${specifier.imported} as ${specifier.reexported}`)
+                    ? stringifyIdentifierIfNeeded(specifier.imported)
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`)
                     .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
             }
         }
@@ -15406,7 +15423,7 @@ function getExportBlock(exports, { _, cnst }) {
         }
         exportDeclaration.push(specifier.exported === specifier.local
             ? specifier.local
-            : `${specifier.local} as ${specifier.exported}`);
+            : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
     }
     if (exportDeclaration.length > 0) {
         exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
@@ -15822,7 +15839,7 @@ function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconf
                 : module.suggestedVariableName, usedNames, variable.forbiddenNames));
         }
         else {
-            variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
+            variable.setRenderNames(null, getSafeName(makeLegal(name), usedNames, variable.forbiddenNames));
         }
     }
     for (const variable of syntheticExports) {
@@ -17233,11 +17250,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 +17367,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 +17388,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 +17610,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 +17679,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 +17695,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 +17752,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) {
@@ -17832,8 +17864,8 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
             : `${s}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`
     ];
     const isValidPropertyName = reservedNamesAsProps
-        ? (name) => validPropertyName.test(name)
-        : (name) => !RESERVED_NAMES$1.has(name) && validPropertyName.test(name);
+        ? (name) => VALID_IDENTIFIER_REGEXP.test(name)
+        : (name) => !RESERVED_NAMES$1.has(name) && VALID_IDENTIFIER_REGEXP.test(name);
     return {
         _,
         cnst,
@@ -17854,10 +17886,10 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
                 .map(([key, value]) => {
                 if (key === null)
                     return `${prefix}${value}`;
-                const needsQuotes = !isValidPropertyName(key);
-                return key === value && objectShorthand && !needsQuotes
+                const keyInObject = stringifyObjectKeyIfNeeded(key);
+                return key === value && objectShorthand && key === keyInObject
                     ? prefix + key
-                    : `${prefix}${needsQuotes ? `'${key}'` : key}:${_}${value}`;
+                    : `${prefix}${keyInObject}:${_}${value}`;
             })
                 .join(`,`)}${fields.length === 0 ? '' : lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`;
         },
@@ -17867,7 +17899,6 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
     };
 }
 const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
-const validPropertyName = /^(?!\d)[\w$]+$/;
 
 class Source {
     constructor(filename, content) {

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.7.0
-	Fri, 08 Dec 2023 07:57:30 GMT - commit 098e29ca3e0643006870f9ed94710fd3004a9043
+	Rollup.js v4.9.0
+	Wed, 13 Dec 2023 09:23:48 GMT - commit c5337ef28a71c796e768a9f0edb3d7259a93f1aa
 
 	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.7.0
-	Fri, 08 Dec 2023 07:57:30 GMT - commit 098e29ca3e0643006870f9ed94710fd3004a9043
+	Rollup.js v4.9.0
+	Wed, 13 Dec 2023 09:23:48 GMT - commit c5337ef28a71c796e768a9f0edb3d7259a93f1aa
 
 	https://github.com/rollup/rollup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "4.7.0",
+  "version": "4.9.0",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",
@@ -101,19 +101,19 @@
   "homepage": "https://rollupjs.org/",
   "optionalDependencies": {
     "fsevents": "~2.3.2",
-    "@rollup/rollup-darwin-arm64": "4.7.0",
-    "@rollup/rollup-android-arm64": "4.7.0",
-    "@rollup/rollup-win32-arm64-msvc": "4.7.0",
-    "@rollup/rollup-linux-arm64-gnu": "4.7.0",
-    "@rollup/rollup-linux-arm64-musl": "4.7.0",
-    "@rollup/rollup-android-arm-eabi": "4.7.0",
-    "@rollup/rollup-linux-arm-gnueabihf": "4.7.0",
-    "@rollup/rollup-win32-ia32-msvc": "4.7.0",
-    "@rollup/rollup-linux-riscv64-gnu": "4.7.0",
-    "@rollup/rollup-darwin-x64": "4.7.0",
-    "@rollup/rollup-win32-x64-msvc": "4.7.0",
-    "@rollup/rollup-linux-x64-gnu": "4.7.0",
-    "@rollup/rollup-linux-x64-musl": "4.7.0"
+    "@rollup/rollup-darwin-arm64": "4.9.0",
+    "@rollup/rollup-android-arm64": "4.9.0",
+    "@rollup/rollup-win32-arm64-msvc": "4.9.0",
+    "@rollup/rollup-linux-arm64-gnu": "4.9.0",
+    "@rollup/rollup-linux-arm64-musl": "4.9.0",
+    "@rollup/rollup-android-arm-eabi": "4.9.0",
+    "@rollup/rollup-linux-arm-gnueabihf": "4.9.0",
+    "@rollup/rollup-win32-ia32-msvc": "4.9.0",
+    "@rollup/rollup-linux-riscv64-gnu": "4.9.0",
+    "@rollup/rollup-darwin-x64": "4.9.0",
+    "@rollup/rollup-win32-x64-msvc": "4.9.0",
+    "@rollup/rollup-linux-x64-gnu": "4.9.0",
+    "@rollup/rollup-linux-x64-musl": "4.9.0"
   },
   "devDependenciesComments": {
     "@rollup/plugin-typescript": "It appears that 11.1.3 breaks sourcemaps"