rollup 3.4.0 → 3.5.0-0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.4.0
-	Tue, 22 Nov 2022 05:15:54 GMT - commit 780e3421e8a498f3248fd7d8506e97fcee8dd1e6
+	Rollup.js v3.5.0-0
+	Fri, 25 Nov 2022 05:53:50 GMT - commit b8beb21aa83e193ed6ef82f06127e95a7ef5fe22
 
 	https://github.com/rollup/rollup
 
@@ -16,7 +16,7 @@ import { promises } from 'node:fs';
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.4.0";
+var version$1 = "3.5.0-0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1776,7 +1776,7 @@ class ExpressionEntity {
         return UnknownValue;
     }
     getReturnExpressionWhenCalledAtPath(_path, _interaction, _recursionTracker, _origin) {
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
         return true;
@@ -1795,6 +1795,10 @@ class ExpressionEntity {
 }
 const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
 })();
+const UNKNOWN_RETURN_EXPRESSION = [
+    UNKNOWN_EXPRESSION,
+    false
+];
 
 const INTERACTION_ACCESSED = 0;
 const INTERACTION_ASSIGNED = 1;
@@ -4930,7 +4934,7 @@ const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEnti
         if (path.length === 1) {
             return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
         }
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         if (interaction.type === INTERACTION_ACCESSED) {
@@ -4953,7 +4957,7 @@ const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity
         if (path.length === 1) {
             return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
         }
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         if (interaction.type === INTERACTION_ACCESSED) {
@@ -4976,7 +4980,7 @@ const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity
         if (path.length === 1) {
             return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
         }
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         if (interaction.type === INTERACTION_ACCESSED) {
@@ -5097,8 +5101,8 @@ function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
 }
 function getMemberReturnExpressionWhenCalled(members, memberName) {
     if (typeof memberName !== 'string' || !members[memberName])
-        return UNKNOWN_EXPRESSION;
-    return members[memberName].returns;
+        return UNKNOWN_RETURN_EXPRESSION;
+    return [members[memberName].returns, false];
 }
 
 // AST walker module for Mozilla Parser API compatible trees
@@ -5748,12 +5752,15 @@ class Method extends ExpressionEntity {
     }
     getReturnExpressionWhenCalledAtPath(path, { thisArg }) {
         if (path.length > 0) {
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         }
-        return (this.description.returnsPrimitive ||
-            (this.description.returns === 'self'
-                ? thisArg || UNKNOWN_EXPRESSION
-                : this.description.returns()));
+        return [
+            this.description.returnsPrimitive ||
+                (this.description.returns === 'self'
+                    ? thisArg || UNKNOWN_EXPRESSION
+                    : this.description.returns()),
+            false
+        ];
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const { type } = interaction;
@@ -5996,7 +6003,7 @@ class ObjectEntity extends ExpressionEntity {
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (path.length === 0) {
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         }
         const [key, ...subPath] = path;
         const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
@@ -6006,7 +6013,7 @@ class ObjectEntity extends ExpressionEntity {
         if (this.prototypeExpression) {
             return this.prototypeExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const [key, ...subPath] = path;
@@ -6478,12 +6485,12 @@ class LocalVariable extends Variable {
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (this.isReassigned || !this.init) {
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         }
         return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
             this.expressionsToBeDeoptimized.push(origin);
             return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        }, UNKNOWN_EXPRESSION);
+        }, UNKNOWN_RETURN_EXPRESSION);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
@@ -6840,6 +6847,19 @@ function is_reference (node, parent) {
 	return false;
 }
 
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] || (currentFunctions[pathSegment] = Object.create(null));
+        }
+        currentFunctions[PureFunctionKey] = true;
+    }
+    return pureFunctions;
+};
+
 /* eslint sort-keys: "off" */
 const ValueProperties = Symbol('Value Properties');
 const getTruthyLiteralValue = () => UnknownTruthyValue;
@@ -7818,7 +7838,8 @@ class Identifier extends NodeBase {
         return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return [expression, isPure || this.isPureFunction(path)];
     }
     hasEffects(context) {
         if (!this.deoptimized)
@@ -7828,19 +7849,22 @@ class Identifier extends NodeBase {
         }
         return (this.context.options.treeshake.unknownGlobalSideEffects &&
             this.variable instanceof GlobalVariable &&
+            !this.isPureFunction(EMPTY_PATH) &&
             this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
             case INTERACTION_ACCESSED: {
                 return (this.variable !== null &&
+                    !this.isPureFunction(path) &&
                     this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
             }
             case INTERACTION_ASSIGNED: {
                 return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
             }
             case INTERACTION_CALLED: {
-                return this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context);
+                return (!this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
             }
         }
     }
@@ -7922,6 +7946,21 @@ class Identifier extends NodeBase {
         }
         return this.variable;
     }
+    isPureFunction(path) {
+        let currentPureFunction = this.context.manualPureFunctions[this.name];
+        for (const segment of path) {
+            if (currentPureFunction) {
+                if (currentPureFunction[PureFunctionKey]) {
+                    return true;
+                }
+                currentPureFunction = currentPureFunction[segment];
+            }
+            else {
+                return false;
+            }
+        }
+        return currentPureFunction?.[PureFunctionKey];
+    }
 }
 function closestParentFunctionOrProgram(node) {
     while (node && !/^Program|Function/.test(node.type)) {
@@ -8243,9 +8282,9 @@ class FunctionBase extends NodeBase {
                 this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
                 this.context.requestTreeshakingPass();
             }
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         }
-        return this.scope.getReturnExpression();
+        return [this.scope.getReturnExpression(), false];
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         if (path.length > 0 || interaction.type !== INTERACTION_CALLED) {
@@ -8844,7 +8883,7 @@ class Literal extends NodeBase {
     }
     getReturnExpressionWhenCalledAtPath(path) {
         if (path.length !== 1)
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         return getMemberReturnExpressionWhenCalled(this.members, path[0]);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
@@ -8997,13 +9036,13 @@ class MemberExpression extends NodeBase {
             return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }
         if (this.isUndefined) {
-            return UNDEFINED_EXPRESSION;
+            return [UNDEFINED_EXPRESSION, false];
         }
         this.expressionsToBeDeoptimized.push(origin);
         if (path.length < MAX_PATH_DEPTH) {
             return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
         }
-        return UNKNOWN_EXPRESSION;
+        return UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffects(context) {
         if (!this.deoptimized)
@@ -9180,8 +9219,8 @@ class CallExpressionBase extends NodeBase {
         this.expressionsToBeDeoptimized = new Set();
     }
     deoptimizeCache() {
-        if (this.returnExpression !== UNKNOWN_EXPRESSION) {
-            this.returnExpression = UNKNOWN_EXPRESSION;
+        if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
             for (const expression of this.deoptimizableDependentExpressions) {
                 expression.deoptimizeCache();
             }
@@ -9195,13 +9234,15 @@ class CallExpressionBase extends NodeBase {
             this.context.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
             return;
         }
-        const returnExpression = this.getReturnExpression();
+        const [returnExpression] = this.getReturnExpression();
         if (returnExpression !== UNKNOWN_EXPRESSION) {
             returnExpression.deoptimizePath(path);
         }
     }
     deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
-        const returnExpression = this.getReturnExpression(recursionTracker);
+        const [returnExpression, isPure] = this.getReturnExpression(recursionTracker);
+        if (isPure)
+            return;
         if (returnExpression === UNKNOWN_EXPRESSION) {
             interaction.thisArg.deoptimizePath(UNKNOWN_PATH);
         }
@@ -9213,7 +9254,7 @@ class CallExpressionBase extends NodeBase {
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        const returnExpression = this.getReturnExpression(recursionTracker);
+        const [returnExpression] = this.getReturnExpression(recursionTracker);
         if (returnExpression === UNKNOWN_EXPRESSION) {
             return UnknownValue;
         }
@@ -9224,13 +9265,14 @@ class CallExpressionBase extends NodeBase {
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const returnExpression = this.getReturnExpression(recursionTracker);
-        if (this.returnExpression === UNKNOWN_EXPRESSION) {
-            return UNKNOWN_EXPRESSION;
+        if (returnExpression[0] === UNKNOWN_EXPRESSION) {
+            return returnExpression;
         }
         return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
             this.deoptimizableDependentExpressions.push(origin);
-            return returnExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        }, UNKNOWN_EXPRESSION);
+            const [expression, isPure] = returnExpression[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+            return [expression, isPure || returnExpression[1]];
+        }, UNKNOWN_RETURN_EXPRESSION);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const { type } = interaction;
@@ -9245,7 +9287,9 @@ class CallExpressionBase extends NodeBase {
             : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
             return false;
         }
-        return this.getReturnExpression().hasEffectsOnInteractionAtPath(path, interaction, context);
+        const [returnExpression, isPure] = this.getReturnExpression();
+        return ((type === INTERACTION_ASSIGNED || !isPure) &&
+            returnExpression.hasEffectsOnInteractionAtPath(path, interaction, context));
     }
 }
 
@@ -9324,7 +9368,7 @@ class CallExpression extends CallExpressionBase {
     }
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
-            this.returnExpression = UNKNOWN_EXPRESSION;
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
             return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
         }
         return this.returnExpression;
@@ -9408,7 +9452,7 @@ class MethodBase extends NodeBase {
     // expressions, there is no known situation where a getter is deoptimized.
     deoptimizeCache() { }
     deoptimizePath(path) {
-        this.getAccessedValue().deoptimizePath(path);
+        this.getAccessedValue()[0].deoptimizePath(path);
     }
     deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
@@ -9427,13 +9471,13 @@ class MethodBase extends NodeBase {
                 withNew: false
             }, EMPTY_PATH, recursionTracker);
         }
-        this.getAccessedValue().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
+        this.getAccessedValue()[0].deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getAccessedValue().getLiteralValueAtPath(path, recursionTracker, origin);
+        return this.getAccessedValue()[0].getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return this.getAccessedValue().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return this.getAccessedValue()[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         return this.key.hasEffects(context);
@@ -9456,17 +9500,17 @@ class MethodBase extends NodeBase {
                 withNew: false
             }, context);
         }
-        return this.getAccessedValue().hasEffectsOnInteractionAtPath(path, interaction, context);
+        return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     applyDeoptimizations() { }
     getAccessedValue() {
         if (this.accessedValue === null) {
             if (this.kind === 'get') {
-                this.accessedValue = UNKNOWN_EXPRESSION;
+                this.accessedValue = UNKNOWN_RETURN_EXPRESSION;
                 return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
             }
             else {
-                return (this.accessedValue = this.value);
+                return (this.accessedValue = [this.value, false]);
             }
         }
         return this.accessedValue;
@@ -9679,7 +9723,10 @@ class MultiExpression extends ExpressionEntity {
         }
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        return new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)));
+        return [
+            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
+            false
+        ];
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         for (const expression of this.expressions) {
@@ -9731,10 +9778,13 @@ class ConditionalExpression extends NodeBase {
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
-            return new MultiExpression([
-                this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin),
-                this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
-            ]);
+            return [
+                new MultiExpression([
+                    this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
@@ -10859,10 +10909,13 @@ class LogicalExpression extends NodeBase {
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
-            return new MultiExpression([
-                this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin),
-                this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
-            ]);
+            return [
+                new MultiExpression([
+                    this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
@@ -11200,7 +11253,12 @@ class PrivateIdentifier extends NodeBase {
 class Program extends NodeBase {
     constructor() {
         super(...arguments);
-        this.hasCachedEffect = false;
+        this.hasCachedEffect = null;
+    }
+    hasCachedEffects() {
+        return this.hasCachedEffect === null
+            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
+            : this.hasCachedEffect;
     }
     hasEffects(context) {
         // We are caching here to later more efficiently identify side-effect-free modules
@@ -11288,7 +11346,7 @@ class PropertyDefinition extends NodeBase {
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         return this.value
             ? this.value.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
-            : UNKNOWN_EXPRESSION;
+            : UNKNOWN_RETURN_EXPRESSION;
     }
     hasEffects(context) {
         return this.key.hasEffects(context) || (this.static && !!this.value?.hasEffects(context));
@@ -11579,7 +11637,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
             this.quasi.include(context, includeChildrenRecursively);
         }
         this.tag.includeCallArguments(context, this.interaction.args);
-        const returnExpression = this.getReturnExpression();
+        const [returnExpression] = this.getReturnExpression();
         if (!returnExpression.included) {
             returnExpression.include(context, false);
         }
@@ -11609,7 +11667,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
     }
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
-            this.returnExpression = UNKNOWN_EXPRESSION;
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
             return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
         }
         return this.returnExpression;
@@ -11642,7 +11700,7 @@ class TemplateLiteral extends NodeBase {
     }
     getReturnExpressionWhenCalledAtPath(path) {
         if (path.length !== 1) {
-            return UNKNOWN_EXPRESSION;
+            return UNKNOWN_RETURN_EXPRESSION;
         }
         return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
     }
@@ -13043,8 +13101,7 @@ class Module {
         return [null];
     }
     hasEffects() {
-        return (this.info.moduleSideEffects === 'no-treeshake' ||
-            (this.ast.included && this.ast.hasEffects(createHasEffectsContext())));
+        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
     }
     include() {
         const context = createInclusionContext();
@@ -13156,6 +13213,7 @@ class Module {
             includeDynamicImport: this.includeDynamicImport.bind(this),
             includeVariableInModule: this.includeVariableInModule.bind(this),
             magicString: this.magicString,
+            manualPureFunctions: this.graph.pureFunctions,
             module: this,
             moduleContext: this.context,
             options: this.options,
@@ -15640,12 +15698,132 @@ 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;
     }
@@ -15771,43 +15949,37 @@ function createChunks(allEntryPoints, assignedEntryPointsByModule, minChunkSize)
             alias: null,
             modules
         }))
-        : getOptimizedChunks(chunkModulesBySignature, minChunkSize);
+        : getOptimizedChunks(chunkModulesBySignature, minChunkSize).map(({ modules }) => ({
+            alias: null,
+            modules
+        }));
 }
 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);
-        }
-    }
+    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}
+`);
+    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.\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.\n`);
     timeEnd('optimize chunks', 3);
-    return unmergeableChunks;
+    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 = '_';
@@ -15829,28 +16001,76 @@ function getChunkModulesBySignature(assignedEntryPointsByModule, allEntryPoints)
     }
     return chunkModules;
 }
-function getMergeableChunks(chunkModulesBySignature, minChunkSize) {
-    const chunksToBeMerged = new Set();
-    const unmergeableChunks = [];
-    const alias = null;
+function getPartitionedChunks(chunkModulesBySignature, minChunkSize) {
+    const smallPureChunks = [];
+    const bigPureChunks = [];
+    const smallSideEffectChunks = [];
+    const bigSideEffectChunks = [];
     for (const [signature, modules] of Object.entries(chunkModulesBySignature)) {
         let size = 0;
-        checkModules: {
-            for (const module of modules) {
-                if (module.hasEffects()) {
-                    break checkModules;
-                }
-                size += module.magicString.toString().length;
-                if (size > minChunkSize) {
-                    break checkModules;
-                }
+        let pure = true;
+        for (const module of modules) {
+            pure && (pure = !module.hasEffects());
+            size += module.magicString.toString().length;
+        }
+        (size < minChunkSize
+            ? pure
+                ? smallPureChunks
+                : smallSideEffectChunks
+            : pure
+                ? bigPureChunks
+                : bigSideEffectChunks).push({ modules, pure, signature, size });
+    }
+    for (const chunks of [
+        bigPureChunks,
+        bigSideEffectChunks,
+        smallPureChunks,
+        smallSideEffectChunks
+    ]) {
+        chunks.sort(compareChunks);
+    }
+    return {
+        big: { pure: new Set(bigPureChunks), sideEffect: new Set(bigSideEffectChunks) },
+        small: { pure: new Set(smallPureChunks), sideEffect: new Set(smallSideEffectChunks) }
+    };
+}
+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 === 1) {
+                closestChunk = targetChunk;
+                break;
+            }
+            else if (distance < closestChunkDistance) {
+                closestChunk = targetChunk;
+                closestChunkDistance = distance;
             }
-            chunksToBeMerged.add({ alias, modules, signature, size });
-            continue;
         }
-        unmergeableChunks.push({ alias, modules, signature, size: null });
+        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);
+            getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+        }
     }
-    return { chunksToBeMerged, unmergeableChunks };
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    const subPartition = chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return chunk.pure ? subPartition.pure : subPartition.sideEffect;
 }
 function getSignatureDistance(sourceSignature, targetSignature, enforceSubset) {
     let distance = 0;
@@ -23477,6 +23697,7 @@ class Graph {
         this.acornParser = Parser.extend(...options.acornInjectPlugins);
         this.moduleLoader = new ModuleLoader(this, this.modulesById, this.options, this.pluginDriver);
         this.fileOperationQueue = new Queue(options.maxParallelFileOps);
+        this.pureFunctions = getPureFunctions(options);
     }
     async build() {
         timeStart('generate module graph', 2);
@@ -23976,6 +24197,7 @@ const treeshakePresets = {
     recommended: {
         annotations: true,
         correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
         moduleSideEffects: () => true,
         propertyReadSideEffects: true,
         tryCatchDeoptimization: true,
@@ -23984,6 +24206,7 @@ const treeshakePresets = {
     safest: {
         annotations: true,
         correctVarValueBeforeDeclaration: true,
+        manualPureFunctions: EMPTY_ARRAY,
         moduleSideEffects: () => true,
         propertyReadSideEffects: true,
         tryCatchDeoptimization: true,
@@ -23992,6 +24215,7 @@ const treeshakePresets = {
     smallest: {
         annotations: true,
         correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
         moduleSideEffects: () => false,
         propertyReadSideEffects: false,
         tryCatchDeoptimization: false,
@@ -24188,6 +24412,7 @@ const getTreeshake = (config) => {
     return {
         annotations: configWithPreset.annotations !== false,
         correctVarValueBeforeDeclaration: configWithPreset.correctVarValueBeforeDeclaration === true,
+        manualPureFunctions: configWithPreset.manualPureFunctions ?? EMPTY_ARRAY,
         moduleSideEffects: getHasModuleSideEffects(configWithPreset.moduleSideEffects),
         propertyReadSideEffects: configWithPreset.propertyReadSideEffects === 'always'
             ? 'always'