rollup 3.7.6-0 → 3.8.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.6-0
-	Sun, 18 Dec 2022 05:56:49 GMT - commit d226f7976dc543ff814af389e183d627d4e94ed4
+	Rollup.js v3.8.1
+	Fri, 23 Dec 2022 05:34:14 GMT - commit 571f3a83d4e24f7bfa9b085cf9736ccdf89e8251
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.7.6-0";
+var version$1 = "3.8.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -6082,7 +6082,7 @@ function getAndCreateKeys(esTreeNode) {
 
 const INCLUDE_PARAMETERS = 'variables';
 class NodeBase extends ExpressionEntity {
-    constructor(esTreeNode, parent, parentScope) {
+    constructor(esTreeNode, parent, parentScope, keepEsTreeNode = false) {
         super();
         /**
          * Nodes can apply custom deoptimizations once they become part of the
@@ -6091,7 +6091,9 @@ class NodeBase extends ExpressionEntity {
          * custom handlers
          */
         this.deoptimized = false;
-        this.esTreeNode = esTreeNode;
+        // Nodes can opt-in to keep the AST if needed during the build pipeline.
+        // Avoid true when possible as large AST takes up memory.
+        this.esTreeNode = keepEsTreeNode ? esTreeNode : null;
         this.keys = keys[esTreeNode.type] || getAndCreateKeys(esTreeNode);
         this.parent = parent;
         this.context = parent.context;
@@ -6177,7 +6179,7 @@ class NodeBase extends ExpressionEntity {
             code.appendLeft(this.end, ';');
         }
     }
-    parseNode(esTreeNode) {
+    parseNode(esTreeNode, keepEsTreeNodeKeys) {
         for (const [key, value] of Object.entries(esTreeNode)) {
             // That way, we can override this function to add custom initialisation and then call super.parseNode
             if (this.hasOwnProperty(key))
@@ -6199,11 +6201,11 @@ class NodeBase extends ExpressionEntity {
                 for (const child of value) {
                     this[key].push(child === null
                         ? null
-                        : new (this.context.getNodeConstructor(child.type))(child, this, this.scope));
+                        : new (this.context.getNodeConstructor(child.type))(child, this, this.scope, keepEsTreeNodeKeys?.includes(key)));
                 }
             }
             else {
-                this[key] = new (this.context.getNodeConstructor(value.type))(value, this, this.scope);
+                this[key] = new (this.context.getNodeConstructor(value.type))(value, this, this.scope, keepEsTreeNodeKeys?.includes(key));
             }
         }
     }
@@ -11190,6 +11192,10 @@ class ImportExpression extends NodeBase {
     initialise() {
         this.context.addDynamicImport(this);
     }
+    parseNode(esTreeNode) {
+        // Keep the source AST to be used by renderDynamicImport
+        super.parseNode(esTreeNode, ['source']);
+    }
     render(code, options) {
         const { snippets: { _, getDirectReturnFunction, getObject, getPropertyAccess } } = options;
         if (this.inlineNamespace) {
@@ -11795,12 +11801,7 @@ class PrivateIdentifier extends NodeBase {
 class Program extends NodeBase {
     constructor() {
         super(...arguments);
-        this.hasCachedEffect = null;
-    }
-    hasCachedEffects() {
-        return this.hasCachedEffect === null
-            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
-            : this.hasCachedEffect;
+        this.hasCachedEffect = false;
     }
     hasEffects(context) {
         // We are caching here to later more efficiently identify side-effect-free modules
@@ -13702,7 +13703,8 @@ class Module {
         return [null];
     }
     hasEffects() {
-        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
+        return (this.info.moduleSideEffects === 'no-treeshake' ||
+            (this.ast.included && this.ast.hasEffects(createHasEffectsContext())));
     }
     include() {
         const context = createInclusionContext();
@@ -13784,9 +13786,7 @@ class Module {
         this.transformDependencies = transformDependencies;
         this.customTransformCache = customTransformCache;
         this.updateOptions(moduleOptions);
-        if (!ast) {
-            ast = this.tryParse();
-        }
+        const moduleAst = ast || this.tryParse();
         timeEnd('generate ast', 3);
         timeStart('analyze ast', 3);
         this.resolvedIds = resolvedIds || Object.create(null);
@@ -13828,14 +13828,33 @@ class Module {
         };
         this.scope = new ModuleScope(this.graph.scope, this.astContext);
         this.namespace = new NamespaceVariable(this.astContext);
-        this.ast = new Program(ast, { context: this.astContext, type: 'Module' }, this.scope);
-        this.info.ast = ast;
+        this.ast = new Program(moduleAst, { context: this.astContext, type: 'Module' }, this.scope);
+        // Assign AST directly if has existing one as there's no way to drop it from memory.
+        // If cache is enabled, also assign directly as otherwise it takes more CPU and memory to re-compute.
+        if (ast || this.options.cache !== false) {
+            this.info.ast = moduleAst;
+        }
+        else {
+            // Make lazy and apply LRU cache to not hog the memory
+            Object.defineProperty(this.info, 'ast', {
+                get: () => {
+                    if (this.graph.astLru.has(fileName)) {
+                        return this.graph.astLru.get(fileName);
+                    }
+                    else {
+                        const parsedAst = this.tryParse();
+                        this.graph.astLru.set(fileName, parsedAst);
+                        return parsedAst;
+                    }
+                }
+            });
+        }
         timeEnd('analyze ast', 3);
     }
     toJSON() {
         return {
             assertions: this.info.assertions,
-            ast: this.ast.esTreeNode,
+            ast: this.info.ast,
             code: this.info.code,
             customTransformCache: this.customTransformCache,
             // eslint-disable-next-line unicorn/prefer-spread
@@ -15639,12 +15658,17 @@ class Chunk {
         const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
         let hasExports = renderedExports.length > 0;
         let hasDefaultExport = false;
-        for (const { reexports } of renderedDependencies) {
+        for (const renderedDependence of renderedDependencies) {
+            const { reexports } = renderedDependence;
             if (reexports?.length) {
                 hasExports = true;
-                if (reexports.some(reexport => reexport.reexported === 'default')) {
+                if (!hasDefaultExport && reexports.some(reexport => reexport.reexported === 'default')) {
                     hasDefaultExport = true;
-                    break;
+                }
+                if (format === 'es') {
+                    renderedDependence.reexports = reexports.filter(
+                    // eslint-disable-next-line unicorn/prefer-array-some
+                    ({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
                 }
             }
         }
@@ -15777,8 +15801,24 @@ class Chunk {
             const variable = this.exportsByName.get(exportName);
             if (!(variable instanceof SyntheticNamedExportVariable)) {
                 const module = variable.module;
-                if (module && this.chunkByModule.get(module) !== this)
-                    continue;
+                if (module) {
+                    const chunk = this.chunkByModule.get(module);
+                    if (chunk !== this) {
+                        if (!chunk || format !== 'es') {
+                            continue;
+                        }
+                        const chunkDep = this.renderedDependencies.get(chunk);
+                        if (!chunkDep) {
+                            continue;
+                        }
+                        const { imports, reexports } = chunkDep;
+                        const importedByReexported = reexports?.find(({ reexported }) => reexported === exportName);
+                        const isImported = imports?.find(({ imported }) => imported === importedByReexported?.imported);
+                        if (!isImported) {
+                            continue;
+                        }
+                    }
+                }
             }
             let expression = null;
             let hoisted = false;
@@ -16301,132 +16341,12 @@ function getImportedBindingsPerDependency(renderedDependencies, resolveFileName)
 const QUERY_HASH_REGEX = /[#?]/;
 const resolveFileName = (dependency) => dependency.getFileName();
 
-const BYTE_UNITS = [
-	'B',
-	'kB',
-	'MB',
-	'GB',
-	'TB',
-	'PB',
-	'EB',
-	'ZB',
-	'YB',
-];
-
-const BIBYTE_UNITS = [
-	'B',
-	'kiB',
-	'MiB',
-	'GiB',
-	'TiB',
-	'PiB',
-	'EiB',
-	'ZiB',
-	'YiB',
-];
-
-const BIT_UNITS = [
-	'b',
-	'kbit',
-	'Mbit',
-	'Gbit',
-	'Tbit',
-	'Pbit',
-	'Ebit',
-	'Zbit',
-	'Ybit',
-];
-
-const BIBIT_UNITS = [
-	'b',
-	'kibit',
-	'Mibit',
-	'Gibit',
-	'Tibit',
-	'Pibit',
-	'Eibit',
-	'Zibit',
-	'Yibit',
-];
-
-/*
-Formats the given number using `Number#toLocaleString`.
-- If locale is a string, the value is expected to be a locale-key (for example: `de`).
-- If locale is true, the system default locale is used for translation.
-- If no value for locale is specified, the number is returned unmodified.
-*/
-const toLocaleString = (number, locale, options) => {
-	let result = number;
-	if (typeof locale === 'string' || Array.isArray(locale)) {
-		result = number.toLocaleString(locale, options);
-	} else if (locale === true || options !== undefined) {
-		result = number.toLocaleString(undefined, options);
-	}
-
-	return result;
-};
-
-function prettyBytes(number, options) {
-	if (!Number.isFinite(number)) {
-		throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
-	}
-
-	options = {
-		bits: false,
-		binary: false,
-		...options,
-	};
-
-	const UNITS = options.bits
-		? (options.binary ? BIBIT_UNITS : BIT_UNITS)
-		: (options.binary ? BIBYTE_UNITS : BYTE_UNITS);
-
-	if (options.signed && number === 0) {
-		return ` 0 ${UNITS[0]}`;
-	}
-
-	const isNegative = number < 0;
-	const prefix = isNegative ? '-' : (options.signed ? '+' : '');
-
-	if (isNegative) {
-		number = -number;
-	}
-
-	let localeOptions;
-
-	if (options.minimumFractionDigits !== undefined) {
-		localeOptions = {minimumFractionDigits: options.minimumFractionDigits};
-	}
-
-	if (options.maximumFractionDigits !== undefined) {
-		localeOptions = {maximumFractionDigits: options.maximumFractionDigits, ...localeOptions};
-	}
-
-	if (number < 1) {
-		const numberString = toLocaleString(number, options.locale, localeOptions);
-		return prefix + numberString + ' ' + UNITS[0];
-	}
-
-	const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
-	number /= (options.binary ? 1024 : 1000) ** exponent;
-
-	if (!localeOptions) {
-		number = number.toPrecision(3);
-	}
-
-	const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-
-	const unit = UNITS[exponent];
-
-	return prefix + numberString + ' ' + unit;
-}
-
 /**
  * Concatenate a number of iterables to a new iterable without fully evaluating
  * their iterators. Useful when e.g. working with large sets or lists and when
  * there is a chance that the iterators will not be fully exhausted.
  */
-function* concatLazy(iterables) {
+function* concatLazy(...iterables) {
     for (const iterable of iterables) {
         yield* iterable;
     }
@@ -16567,11 +16487,47 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
+        : getOptimizedChunks(chunkModulesBySignature, minChunkSize);
+}
+function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
+    timeStart('optimize chunks', 3);
+    const { chunksToBeMerged, unmergeableChunks } = getMergeableChunks(chunkModulesBySignature, minChunkSize);
+    for (const sourceChunk of chunksToBeMerged) {
+        chunksToBeMerged.delete(sourceChunk);
+        let closestChunk = null;
+        let closestChunkDistance = Infinity;
+        const { signature, size, modules } = sourceChunk;
+        for (const targetChunk of concatLazy(chunksToBeMerged, unmergeableChunks)) {
+            const distance = getSignatureDistance(signature, targetChunk.signature, !chunksToBeMerged.has(targetChunk));
+            if (distance === 1) {
+                closestChunk = targetChunk;
+                break;
+            }
+            else if (distance < closestChunkDistance) {
+                closestChunk = targetChunk;
+                closestChunkDistance = distance;
+            }
+        }
+        if (closestChunk) {
+            closestChunk.modules.push(...modules);
+            if (chunksToBeMerged.has(closestChunk)) {
+                closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
+                if ((closestChunk.size += size) > minChunkSize) {
+                    chunksToBeMerged.delete(closestChunk);
+                    unmergeableChunks.push(closestChunk);
+                }
+            }
+        }
+        else {
+            unmergeableChunks.push(sourceChunk);
+        }
+    }
+    timeEnd('optimize chunks', 3);
+    return unmergeableChunks;
 }
+const CHAR_DEPENDENT = 'X';
+const CHAR_INDEPENDENT = '_';
+const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
 function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     const chunkModules = Object.create(null);
     for (const [module, assignedEntries] of assignedEntriesByModule) {
@@ -16589,205 +16545,28 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     }
     return chunkModules;
 }
-/**
- * This function tries to get rid of small chunks by merging them with other
- * chunks. In order to merge chunks, one must obey the following rule:
- * - When merging several chunks, at most one of the chunks can have side
- *   effects
- * - When one of the chunks has side effects, the entry points depending on that
- *   chunk need to be a super set of the entry points depending on the other
- *   chunks
- * - Pure chunks can always be merged
- * - We use the entry point dependence signature to calculate "chunk distance",
- *   i.e. how likely it is that two chunks are loaded together
- */
-function getOptimizedChunks(chunkModulesBySignature, minChunkSize) {
-    timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, minChunkSize);
-    console.log(`Created ${chunkPartition.big.pure.size +
-        chunkPartition.big.sideEffect.size +
-        chunkPartition.small.pure.size +
-        chunkPartition.small.sideEffect.size} chunks
------ pure  side effects
-small ${`${chunkPartition.small.pure.size}`.padEnd(5, ' ')} ${chunkPartition.small.sideEffect.size}
-  big ${`${chunkPartition.big.pure.size}`.padEnd(5, ' ')} ${chunkPartition.big.sideEffect.size}
-Unoptimized chunks contain ${getNumberOfCycles(chunkPartition)} cycles.
-`);
-    if (chunkPartition.small.sideEffect.size > 0) {
-        console.log(`Trying to find merge targets for ${chunkPartition.small.sideEffect.size} chunks smaller than ${prettyBytes(minChunkSize)} with side effects...`);
-        mergeChunks(chunkPartition.small.sideEffect, [chunkPartition.small.pure, chunkPartition.big.pure], minChunkSize, chunkPartition);
-        console.log(`${chunkPartition.small.sideEffect.size} chunks smaller than ${prettyBytes(minChunkSize)} with side effects remaining.\nGenerated chunks contain ${getNumberOfCycles(chunkPartition)} cycles.\n`);
-    }
-    if (chunkPartition.small.pure.size > 0) {
-        console.log(`Trying to find merge targets for ${chunkPartition.small.pure.size} pure chunks smaller than ${prettyBytes(minChunkSize)}...`);
-        mergeChunks(chunkPartition.small.pure, [chunkPartition.small.pure, chunkPartition.big.sideEffect, chunkPartition.big.pure], minChunkSize, chunkPartition);
-        console.log(`${chunkPartition.small.pure.size} pure chunks smaller than ${prettyBytes(minChunkSize)} remaining.\nGenerated chunks contain ${getNumberOfCycles(chunkPartition)} cycles.\n`);
-    }
-    timeEnd('optimize chunks', 3);
-    const result = [
-        ...chunkPartition.small.sideEffect,
-        ...chunkPartition.small.pure,
-        ...chunkPartition.big.sideEffect,
-        ...chunkPartition.big.pure
-    ];
-    console.log(`${result.length} chunks remaining.`);
-    return result;
-}
-const CHAR_DEPENDENT = 'X';
-const CHAR_INDEPENDENT = '_';
-const CHAR_CODE_DEPENDENT = CHAR_DEPENDENT.charCodeAt(0);
-function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
-    const smallPureChunks = [];
-    const bigPureChunks = [];
-    const smallSideEffectChunks = [];
-    const bigSideEffectChunks = [];
-    const chunkByModule = new Map();
+function getMergeableChunks(chunkModulesBySignature, minChunkSize) {
+    const chunksToBeMerged = new Set();
+    const unmergeableChunks = [];
+    const alias = null;
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
-        const chunkDescription = {
-            dependencies: new Set(),
-            dependentChunks: new Set(),
-            modules,
-            pure: true,
-            signature,
-            size: 0
-        };
         let size = 0;
-        let pure = true;
-        for (const module of modules) {
-            chunkByModule.set(module, chunkDescription);
-            pure && (pure = !module.hasEffects());
-            // Unfortunately, we cannot take tree-shaking into account here because
-            // rendering did not happen yet
-            size += module.originalCode.length;
-        }
-        chunkDescription.pure = pure;
-        chunkDescription.size = size;
-        (size < minChunkSize
-            ? pure
-                ? smallPureChunks
-                : smallSideEffectChunks
-            : pure
-                ? bigPureChunks
-                : bigSideEffectChunks).push(chunkDescription);
-    }
-    sortChunksAndAddDependencies([bigPureChunks, bigSideEffectChunks, smallPureChunks, smallSideEffectChunks], chunkByModule);
-    return {
-        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
-        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
-    };
-}
-function getNumberOfCycles(partition) {
-    const parents = new Set();
-    const analysedChunks = new Set();
-    let cycles = 0;
-    const analyseChunk = (chunk) => {
-        for (const dependency of chunk.dependencies) {
-            if (parents.has(dependency)) {
-                if (!analysedChunks.has(dependency)) {
-                    cycles++;
-                }
-                continue;
-            }
-            parents.add(dependency);
-            analyseChunk(dependency);
-        }
-        analysedChunks.add(chunk);
-    };
-    for (const chunk of [
-        ...partition.big.pure,
-        ...partition.big.sideEffect,
-        ...partition.small.pure,
-        ...partition.small.sideEffect
-    ]) {
-        if (!parents.has(chunk)) {
-            parents.add(chunk);
-            analyseChunk(chunk);
-        }
-    }
-    return cycles;
-}
-function sortChunksAndAddDependencies(chunkLists, chunkByModule) {
-    for (const chunks of chunkLists) {
-        chunks.sort(compareChunks);
-        for (const chunk of chunks) {
-            const { dependencies, modules } = chunk;
+        checkModules: {
             for (const module of modules) {
-                for (const dependency of module.getDependenciesToBeIncluded()) {
-                    const dependencyChunk = chunkByModule.get(dependency);
-                    if (dependencyChunk && dependencyChunk !== chunk) {
-                        dependencies.add(dependencyChunk);
-                        dependencyChunk.dependentChunks.add(chunk);
-                    }
+                if (module.hasEffects()) {
+                    break checkModules;
                 }
-            }
-        }
-    }
-}
-function compareChunks({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
-function mergeChunks(chunksToBeMerged, targetChunks, minChunkSize, chunkPartition) {
-    for (const mergedChunk of chunksToBeMerged) {
-        let closestChunk = null;
-        let closestChunkDistance = Infinity;
-        const { signature, modules, pure, size } = mergedChunk;
-        for (const targetChunk of concatLazy(targetChunks)) {
-            if (mergedChunk === targetChunk)
-                continue;
-            const distance = pure
-                ? getSignatureDistance(signature, targetChunk.signature, !targetChunk.pure)
-                : getSignatureDistance(targetChunk.signature, signature, true);
-            if (distance < closestChunkDistance && isValidMerge(mergedChunk, targetChunk)) {
-                if (distance === 1) {
-                    closestChunk = targetChunk;
-                    break;
+                size += module.magicString.toString().length;
+                if (size > minChunkSize) {
+                    break checkModules;
                 }
-                closestChunk = targetChunk;
-                closestChunkDistance = distance;
-            }
-        }
-        if (closestChunk) {
-            chunksToBeMerged.delete(mergedChunk);
-            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
-            closestChunk.modules.push(...modules);
-            closestChunk.size += size;
-            closestChunk.pure && (closestChunk.pure = pure);
-            closestChunk.signature = mergeSignatures(signature, closestChunk.signature);
-            const { dependencies, dependentChunks } = closestChunk;
-            for (const dependency of mergedChunk.dependencies) {
-                dependencies.add(dependency);
-            }
-            for (const dependentChunk of mergedChunk.dependentChunks) {
-                dependentChunks.add(dependentChunk);
-                dependentChunk.dependencies.delete(mergedChunk);
-                dependentChunk.dependencies.add(closestChunk);
-            }
-            dependencies.delete(closestChunk);
-            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
-        }
-    }
-}
-// Merging will not produce cycles if none of the direct non-merged dependencies
-// of a chunk have the other chunk as a transitive dependency
-function isValidMerge(mergedChunk, targetChunk) {
-    return !(hasTransitiveDependency(mergedChunk, targetChunk) ||
-        hasTransitiveDependency(targetChunk, mergedChunk));
-}
-function hasTransitiveDependency(dependentChunk, dependencyChunk) {
-    const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies } of chunksToCheck) {
-        for (const dependency of dependencies) {
-            if (dependency === dependencyChunk) {
-                return true;
             }
-            chunksToCheck.add(dependency);
+            chunksToBeMerged.add({ alias, modules, signature, size });
+            continue;
         }
+        unmergeableChunks.push({ alias, modules, signature, size: null });
     }
-    return false;
-}
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
+    return { chunksToBeMerged, unmergeableChunks };
 }
 function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     let distance = 0;
@@ -23091,6 +22870,50 @@ const acorn = /*#__PURE__*/Object.defineProperty({
   version
 }, Symbol.toStringTag, { value: 'Module' });
 
+function flru (max) {
+	var num, curr, prev;
+	var limit = max || 1;
+
+	function keep(key, value) {
+		if (++num > limit) {
+			prev = curr;
+			reset(1);
+			++num;
+		}
+		curr[key] = value;
+	}
+
+	function reset(isPartial) {
+		num = 0;
+		curr = Object.create(null);
+		isPartial || (prev=Object.create(null));
+	}
+
+	reset();
+
+	return {
+		clear: reset,
+		has: function (key) {
+			return curr[key] !== void 0 || prev[key] !== void 0;
+		},
+		get: function (key) {
+			var val = curr[key];
+			if (val !== void 0) return val;
+			if ((val=prev[key]) !== void 0) {
+				keep(key, val);
+				return val;
+			}
+		},
+		set: function (key, value) {
+			if (curr[key] !== void 0) {
+				curr[key] = value;
+			} else {
+				keep(key, value);
+			}
+		}
+	};
+}
+
 function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, assertions) {
     let skipped = null;
     let replaceContext = null;
@@ -23852,6 +23675,7 @@ class FileEmitter {
         this.facadeChunkByModule = null;
         this.nextIdBase = 1;
         this.output = null;
+        this.outputFileEmitters = [];
         this.emitFile = (emittedFile) => {
             if (!hasValidType(emittedFile)) {
                 return error(errorFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
@@ -23895,6 +23719,9 @@ class FileEmitter {
             }
             else {
                 consumedFile.source = source;
+                for (const emitter of this.outputFileEmitters) {
+                    emitter.finalizeAsset(consumedFile, source, referenceId, emitter.output);
+                }
             }
         };
         this.setChunkInformation = (facadeChunkByModule) => {
@@ -23917,6 +23744,10 @@ class FileEmitter {
         this.filesByReferenceId = baseFileEmitter
             ? new Map(baseFileEmitter.filesByReferenceId)
             : new Map();
+        baseFileEmitter?.addOutputFileEmitter(this);
+    }
+    addOutputFileEmitter(outputFileEmitter) {
+        this.outputFileEmitters.push(outputFileEmitter);
     }
     assignReferenceId(file, idBase) {
         let referenceId;
@@ -23925,8 +23756,12 @@ class FileEmitter {
                 .update(referenceId || idBase)
                 .digest('hex')
                 .slice(0, 8);
-        } while (this.filesByReferenceId.has(referenceId));
+        } while (this.filesByReferenceId.has(referenceId) ||
+            this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
         this.filesByReferenceId.set(referenceId, file);
+        for (const { filesByReferenceId } of this.outputFileEmitters) {
+            filesByReferenceId.set(referenceId, file);
+        }
         return referenceId;
     }
     emitAsset(emittedAsset) {
@@ -23941,15 +23776,24 @@ class FileEmitter {
         };
         const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || String(this.nextIdBase++));
         if (this.output) {
-            if (emittedAsset.fileName) {
-                reserveFileNameInBundle(emittedAsset.fileName, this.output, this.options.onwarn);
-            }
-            if (source !== undefined) {
-                this.finalizeAsset(consumedAsset, source, referenceId, this.output);
+            this.emitAssetWithReferenceId(consumedAsset, referenceId, this.output);
+        }
+        else {
+            for (const fileEmitter of this.outputFileEmitters) {
+                fileEmitter.emitAssetWithReferenceId(consumedAsset, referenceId, fileEmitter.output);
             }
         }
         return referenceId;
     }
+    emitAssetWithReferenceId(consumedAsset, referenceId, output) {
+        const { fileName, source } = consumedAsset;
+        if (fileName) {
+            reserveFileNameInBundle(fileName, output, this.options.onwarn);
+        }
+        if (source !== undefined) {
+            this.finalizeAsset(consumedAsset, source, referenceId, output);
+        }
+    }
     emitChunk(emittedChunk) {
         if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
             return error(errorInvalidRollupPhaseForChunkEmission());
@@ -24371,6 +24215,7 @@ function normalizeEntryModules(entryModules) {
 class Graph {
     constructor(options, watcher) {
         this.options = options;
+        this.astLru = flru(5);
         this.cachedModules = new Map();
         this.deoptimizationTracker = new PathTracker();
         this.entryModules = [];
@@ -25376,10 +25221,12 @@ async function rollupInternal(rawInputOptions, watcher) {
     const { options: inputOptions, unsetOptions: unsetInputOptions } = await getInputOptions(rawInputOptions, watcher !== null);
     initialiseTimers(inputOptions);
     const graph = new Graph(inputOptions, watcher);
-    // remove the cache option from the memory after graph creation (cache is not used anymore)
+    // remove the cache object from the memory after graph creation (cache is not used anymore)
     const useCache = rawInputOptions.cache !== false;
-    delete inputOptions.cache;
-    delete rawInputOptions.cache;
+    if (rawInputOptions.cache) {
+        inputOptions.cache = undefined;
+        rawInputOptions.cache = undefined;
+    }
     timeStart('BUILD', 1);
     await catchUnfinishedHookActions(graph.pluginDriver, async () => {
         try {
@@ -25621,7 +25468,6 @@ exports.loadFsEvents = loadFsEvents;
 exports.mergeOptions = mergeOptions;
 exports.normalizePluginOption = normalizePluginOption;
 exports.picomatch = picomatch$1;
-exports.prettyBytes = prettyBytes;
 exports.printQuotedStringList = printQuotedStringList;
 exports.relativeId = relativeId;
 exports.rollup = rollup;