rollup 3.7.1-0 → 3.7.2

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1-0
-	Thu, 08 Dec 2022 05:48:12 GMT - commit a3259be5f30c0b2c85c985459782207fb05f50c3
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version$1 = "3.7.1-0";
+var version$1 = "3.7.2";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -95,6 +95,19 @@ function locate(source, search, options) {
     return getLocator$1(source, options)(search, options && options.startIndex);
 }
 
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[/\\|])/;
+const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
+function isAbsolute(path) {
+    return ABSOLUTE_PATH_REGEX.test(path);
+}
+function isRelative(path) {
+    return RELATIVE_PATH_REGEX.test(path);
+}
+const BACKSLASH_REGEX = /\\/g;
+function normalize(path) {
+    return path.replace(BACKSLASH_REGEX, '/');
+}
+
 function spaces(index) {
     let result = '';
     while (index--)
@@ -163,19 +176,6 @@ function relative(from, to) {
     return toParts.join('/');
 }
 
-const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[/\\|])/;
-const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
-function isAbsolute(path) {
-    return ABSOLUTE_PATH_REGEX.test(path);
-}
-function isRelative(path) {
-    return RELATIVE_PATH_REGEX.test(path);
-}
-const BACKSLASH_REGEX = /\\/g;
-function normalize(path) {
-    return path.replace(BACKSLASH_REGEX, '/');
-}
-
 function getAliasName(id) {
     const base = node_path.basename(id);
     return base.slice(0, Math.max(0, base.length - node_path.extname(id).length));
@@ -535,12 +535,13 @@ function errorMissingConfig() {
     };
 }
 function errorMissingExport(binding, importingModule, exporter) {
+    const isJson = node_path.extname(exporter) === '.json';
     return {
         binding,
         code: MISSING_EXPORT,
         exporter,
         id: importingModule,
-        message: `"${binding}" is not exported by "${relativeId(exporter)}", imported by "${relativeId(importingModule)}".`,
+        message: `"${binding}" is not exported by "${relativeId(exporter)}", imported by "${relativeId(importingModule)}".${isJson ? ' (Note that you need @rollup/plugin-json to import JSON files)' : ''}`,
         url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
     };
 }
@@ -2835,6 +2836,12 @@ function getOrCreate(map, key, init) {
     map.set(key, value);
     return value;
 }
+function getNewSet() {
+    return new Set();
+}
+function getNewArray() {
+    return [];
+}
 
 const UnknownKey = Symbol('Unknown Key');
 const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
@@ -2896,7 +2903,7 @@ class DiscriminatedPathTracker {
                 currentPaths[pathSegment] ||
                     Object.create(null, { [EntitiesKey]: { value: new Map() } });
         }
-        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, () => new Set());
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, getNewSet);
         if (trackedEntities.has(entity))
             return true;
         trackedEntities.add(entity);
@@ -11777,12 +11784,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
@@ -13273,7 +13275,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
-    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, () => new Set());
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, getNewSet);
     let currentVariable = variable;
     const referencedVariables = new Set([currentVariable]);
     while (true) {
@@ -13612,7 +13614,7 @@ class Module {
                 searchedNamesAndModules
             });
             if (importerForSideEffects) {
-                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, () => new Set()).add(this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, getNewSet).add(this);
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
             return [variable];
@@ -13642,7 +13644,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();
@@ -15839,7 +15842,7 @@ class Chunk {
                 dependency = this.chunkByModule.get(module);
                 imported = dependency.getVariableExportName(variable);
             }
-            getOrCreate(importsByDependency, dependency, () => []).push({
+            getOrCreate(importsByDependency, dependency, getNewArray).push({
                 imported,
                 local: variable.getName(this.snippets.getPropertyAccess)
             });
@@ -15951,7 +15954,7 @@ class Chunk {
                             (imported !== 'default' || isDefaultAProperty(interop(module.id), true));
                 }
             }
-            getOrCreate(reexportSpecifiers, dependency, () => []).push({
+            getOrCreate(reexportSpecifiers, dependency, getNewArray).push({
                 imported,
                 needsLiveBinding,
                 reexported: exportName
@@ -16241,132 +16244,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;
     }
@@ -16443,25 +16326,25 @@ function analyzeModuleGraph(entries) {
 function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries) {
     const dynamicallyDependentEntriesByDynamicEntry = new Map();
     for (const dynamicEntry of dynamicEntries) {
-        const dynamicDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, getNewSet);
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntry, getNewSet);
         for (const importer of [
             ...dynamicEntry.includedDynamicImporters,
             ...dynamicEntry.implicitlyLoadedAfter
         ]) {
             for (const entry of dependentEntriesByModule.get(importer)) {
-                dynamicDependentEntries.add(entry);
+                dynamicallyDependentEntries.add(entry);
             }
         }
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
 function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assignedEntriesByModule, modulesInManualChunks, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
-    const dynamicDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
+    const dynamicallyDependentEntries = dynamicallyDependentEntriesByDynamicEntry.get(entry);
     const modulesToHandle = new Set([entry]);
     for (const module of modulesToHandle) {
         const assignedEntries = getOrCreate(assignedEntriesByModule, module, getNewSet);
-        if (dynamicDependentEntries &&
-            areEntriesContainedOrDynamicallyDependent(dynamicDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry)) {
+        if (dynamicallyDependentEntries &&
+            isModuleAlreadyLoaded(dynamicallyDependentEntries, dependentEntriesByModule.get(module), staticEntries, dynamicallyDependentEntriesByDynamicEntry)) {
             continue;
         }
         else {
@@ -16475,11 +16358,15 @@ function assignEntryToStaticDependencies(entry, dependentEntriesByModule, assign
     }
 }
 const MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES = 3;
-function areEntriesContainedOrDynamicallyDependent(entries, containedIn, staticEntries, dynamicallyDependentEntriesByDynamicEntry) {
-    if (entries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
+// 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) {
+    if (dynamicallyDependentEntries.size > MAX_ENTRIES_TO_CHECK_FOR_SHARED_DEPENDENCIES) {
         return false;
     }
-    const entriesToCheck = new Set(entries);
+    const entriesToCheck = new Set(dynamicallyDependentEntries);
     for (const entry of entriesToCheck) {
         if (!containedIn.has(entry)) {
             if (staticEntries.has(entry)) {
@@ -16503,50 +16390,43 @@ function createChunks(allEntries, assignedEntriesByModule, minChunkSize) {
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
+        : getOptimizedChunks(chunkModulesBySignature, minChunkSize);
 }
-/**
- * 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.
-`);
-    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`);
-    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`);
+    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);
-    const result = [
-        ...chunkPartition.small.sideEffect,
-        ...chunkPartition.small.pure,
-        ...chunkPartition.big.sideEffect,
-        ...chunkPartition.big.pure
-    ];
-    console.log(`${result.length} chunks remaining.`);
-    return result;
+    return unmergeableChunks;
 }
 const CHAR_DEPENDENT = 'X';
 const CHAR_INDEPENDENT = '_';
@@ -16568,171 +16448,28 @@ function getChunkModulesBySignature(assignedEntriesByModule, allEntries) {
     }
     return chunkModules;
 }
-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(),
-            modules,
-            pure: true,
-            signature,
-            size: 0,
-            transitiveDependencies: new Set(),
-            transitiveDependentChunks: new Set()
-        };
         let size = 0;
-        let pure = true;
-        for (const module of modules) {
-            chunkByModule.set(module, chunkDescription);
-            pure && (pure = !module.hasEffects());
-            size += module.magicString.toString().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, transitiveDependencies } = chunk;
-            const transitiveDependencyModules = new Set();
+        checkModules: {
             for (const module of modules) {
-                for (const dependency of module.getDependenciesToBeIncluded()) {
-                    const dependencyChunk = chunkByModule.get(dependency);
-                    if (dependencyChunk && dependencyChunk !== chunk) {
-                        dependencies.add(dependencyChunk);
-                        transitiveDependencyModules.add(dependency);
-                    }
+                if (module.hasEffects()) {
+                    break checkModules;
                 }
-            }
-            for (const module of transitiveDependencyModules) {
-                const transitiveDependency = chunkByModule.get(module);
-                if (transitiveDependency !== chunk) {
-                    transitiveDependencies.add(transitiveDependency);
-                    transitiveDependency.transitiveDependentChunks.add(chunk);
-                    for (const dependency of module.getDependenciesToBeIncluded()) {
-                        if (!(dependency instanceof ExternalModule)) {
-                            transitiveDependencyModules.add(dependency);
-                        }
-                    }
+                size += module.magicString.toString().length;
+                if (size > minChunkSize) {
+                    break checkModules;
                 }
             }
+            chunksToBeMerged.add({ alias, modules, signature, size });
+            continue;
         }
+        unmergeableChunks.push({ alias, modules, signature, size: null });
     }
-}
-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;
-                }
-                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, transitiveDependencies, transitiveDependentChunks } = closestChunk;
-            for (const dependency of mergedChunk.dependencies) {
-                dependencies.add(dependency);
-            }
-            for (const dependency of mergedChunk.transitiveDependencies) {
-                transitiveDependencies.add(dependency);
-                dependency.transitiveDependentChunks.delete(mergedChunk);
-                dependency.transitiveDependentChunks.add(closestChunk);
-            }
-            for (const dependentChunk of mergedChunk.transitiveDependentChunks) {
-                transitiveDependentChunks.add(dependentChunk);
-                if (dependentChunk.dependencies.has(mergedChunk)) {
-                    dependentChunk.dependencies.delete(mergedChunk);
-                    dependentChunk.dependencies.add(closestChunk);
-                }
-                dependentChunk.transitiveDependencies.delete(mergedChunk);
-                dependentChunk.transitiveDependencies.add(closestChunk);
-            }
-            dependencies.delete(closestChunk);
-            transitiveDependencies.delete(closestChunk);
-            transitiveDependentChunks.delete(closestChunk);
-            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
-        }
-    }
-}
-// If a module is a transitive but not a direct dependency of the other chunk,
-// merging is prohibited as that would create a new cyclic dependency.
-function isValidMerge(mergedChunk, targetChunk) {
-    return ((!targetChunk.transitiveDependencies.has(mergedChunk) ||
-        targetChunk.dependencies.has(mergedChunk)) &&
-        (!mergedChunk.transitiveDependencies.has(targetChunk) ||
-            mergedChunk.dependencies.has(targetChunk)));
-}
-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;
@@ -16760,9 +16497,6 @@ function mergeSignatures(sourceSignature, targetSignature) {
     }
     return signature;
 }
-function getNewSet() {
-    return new Set();
-}
 
 // ported from https://github.com/substack/node-commondir
 function commondir(files) {
@@ -25560,6 +25294,7 @@ exports.errorOnlyInlineSourcemapsForStdout = errorOnlyInlineSourcemapsForStdout;
 exports.fseventsImporter = fseventsImporter;
 exports.getAliasName = getAliasName;
 exports.getAugmentedNamespace = getAugmentedNamespace;
+exports.getNewArray = getNewArray;
 exports.getOrCreate = getOrCreate;
 exports.gray = gray;
 exports.green = green;
@@ -25569,7 +25304,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;

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1-0
-	Thu, 08 Dec 2022 05:48:12 GMT - commit a3259be5f30c0b2c85c985459782207fb05f50c3
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.7.1-0
-	Thu, 08 Dec 2022 05:48:12 GMT - commit a3259be5f30c0b2c85c985459782207fb05f50c3
+	Rollup.js v3.7.2
+	Sat, 10 Dec 2022 06:16:44 GMT - commit f368adf4943a11207157ec44a83345da7a905a13
 
 	https://github.com/rollup/rollup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "3.7.1-0",
+  "version": "3.7.2",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",