@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/{extension-tools-d0cfdea1.js → extension-tools-3c2bf0a4.js}

@@ -7,7 +7,6 @@ import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
 import { createHash as createHash$1 } from 'node:crypto';
 import { mkdir, writeFile, readFile, lstat, realpath, readdir } from 'node:fs/promises';
-import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 import { addExtension } from '@rollup/pluginutils';
 
@@ -1401,6 +1400,9 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+/**
+ * Extracted from json.ts to keep json nls free.
+ */
 function getParseErrorMessage(errorCode) {
     switch (errorCode) {
         case 1 /* ParseErrorCode.InvalidSymbol */: return localize('error.invalidSymbol', 'Invalid symbol');
@@ -1419,15 +1421,15 @@ function getParseErrorMessage(errorCode) {
 
 /*
   @license
-	Rollup.js v3.21.3
-	Tue, 02 May 2023 04:37:56 GMT - commit ef6ca52fec43ec4a7d6f12c8ebdee82ee690c2ce
+	Rollup.js v3.25.1
+	Mon, 12 Jun 2023 04:38:12 GMT - commit b1341bf9cd719670a670905e0308418b37621d70
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
 
-var version$1 = "3.21.3";
+var version$1 = "3.25.1";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -3383,6 +3385,89 @@ const EMPTY_SET = Object.freeze(new (class extends Set {
     }
 })());
 
+const RESERVED_NAMES = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'NaN',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+const RESERVED_NAMES$1 = RESERVED_NAMES;
+
+const illegalCharacters = /[^\w$]/g;
+const startsWithDigit = (value) => /\d/.test(value[0]);
+const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES$1.has(value) || value === 'arguments';
+function isLegal(value) {
+    if (needsEscape(value)) {
+        return false;
+    }
+    return !illegalCharacters.test(value);
+}
+function makeLegal(value) {
+    value = value
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(illegalCharacters, '_');
+    if (needsEscape(value))
+        value = `_${value}`;
+    return value || '_';
+}
+
+const LOGLEVEL_SILENT = 'silent';
+const LOGLEVEL_ERROR = 'error';
+const LOGLEVEL_WARN = 'warn';
+const LOGLEVEL_INFO = 'info';
+const LOGLEVEL_DEBUG = 'debug';
+const logLevelPriority = {
+    [LOGLEVEL_DEBUG]: 0,
+    [LOGLEVEL_INFO]: 1,
+    [LOGLEVEL_SILENT]: 3,
+    [LOGLEVEL_WARN]: 2
+};
+
 function getLocator(source, options) {
     if (options === void 0) { options = {}; }
     var offsetLine = options.offsetLine || 0;
@@ -3495,6 +3580,12 @@ function isValidUrl(url) {
 function getRollupUrl(snippet) {
     return `https://rollupjs.org/${snippet}`;
 }
+function addTrailingSlashIfMissed(url) {
+    if (!url.endsWith('/')) {
+        return url + '/';
+    }
+    return url;
+}
 
 // troubleshooting
 const URL_AVOIDING_EVAL = 'troubleshooting/#avoiding-eval';
@@ -3554,21 +3645,21 @@ function augmentCodeLocation(properties, pos, source, id) {
 }
 // Error codes should be sorted alphabetically while errors should be sorted by
 // error code below
-const ADDON_ERROR = 'ADDON_ERROR', ALREADY_CLOSED = 'ALREADY_CLOSED', AMBIGUOUS_EXTERNAL_NAMESPACES = 'AMBIGUOUS_EXTERNAL_NAMESPACES', ANONYMOUS_PLUGIN_CACHE = 'ANONYMOUS_PLUGIN_CACHE', ASSET_NOT_FINALISED = 'ASSET_NOT_FINALISED', ASSET_NOT_FOUND = 'ASSET_NOT_FOUND', ASSET_SOURCE_ALREADY_SET = 'ASSET_SOURCE_ALREADY_SET', ASSET_SOURCE_MISSING = 'ASSET_SOURCE_MISSING', BAD_LOADER = 'BAD_LOADER', CANNOT_CALL_NAMESPACE = 'CANNOT_CALL_NAMESPACE', CANNOT_EMIT_FROM_OPTIONS_HOOK = 'CANNOT_EMIT_FROM_OPTIONS_HOOK', CHUNK_NOT_GENERATED = 'CHUNK_NOT_GENERATED', CHUNK_INVALID = 'CHUNK_INVALID', CIRCULAR_DEPENDENCY = 'CIRCULAR_DEPENDENCY', CIRCULAR_REEXPORT = 'CIRCULAR_REEXPORT', CYCLIC_CROSS_CHUNK_REEXPORT = 'CYCLIC_CROSS_CHUNK_REEXPORT', DEPRECATED_FEATURE = 'DEPRECATED_FEATURE', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INCONSISTENT_IMPORT_ASSERTIONS = 'INCONSISTENT_IMPORT_ASSERTIONS', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', SHIMMED_EXPORT = 'SHIMMED_EXPORT', SOURCEMAP_BROKEN = 'SOURCEMAP_BROKEN', SOURCEMAP_ERROR = 'SOURCEMAP_ERROR', SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT = 'SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT', THIS_IS_UNDEFINED = 'THIS_IS_UNDEFINED', UNEXPECTED_NAMED_IMPORT = 'UNEXPECTED_NAMED_IMPORT', UNKNOWN_OPTION = 'UNKNOWN_OPTION', UNRESOLVED_ENTRY = 'UNRESOLVED_ENTRY', UNRESOLVED_IMPORT = 'UNRESOLVED_IMPORT', UNUSED_EXTERNAL_IMPORT = 'UNUSED_EXTERNAL_IMPORT', VALIDATION_ERROR = 'VALIDATION_ERROR';
-function errorAddonNotGenerated(message, hook, plugin) {
+const ADDON_ERROR = 'ADDON_ERROR', ALREADY_CLOSED = 'ALREADY_CLOSED', AMBIGUOUS_EXTERNAL_NAMESPACES = 'AMBIGUOUS_EXTERNAL_NAMESPACES', ANONYMOUS_PLUGIN_CACHE = 'ANONYMOUS_PLUGIN_CACHE', ASSET_NOT_FINALISED = 'ASSET_NOT_FINALISED', ASSET_NOT_FOUND = 'ASSET_NOT_FOUND', ASSET_SOURCE_ALREADY_SET = 'ASSET_SOURCE_ALREADY_SET', ASSET_SOURCE_MISSING = 'ASSET_SOURCE_MISSING', BAD_LOADER = 'BAD_LOADER', CANNOT_CALL_NAMESPACE = 'CANNOT_CALL_NAMESPACE', CANNOT_EMIT_FROM_OPTIONS_HOOK = 'CANNOT_EMIT_FROM_OPTIONS_HOOK', CHUNK_NOT_GENERATED = 'CHUNK_NOT_GENERATED', CHUNK_INVALID = 'CHUNK_INVALID', CIRCULAR_DEPENDENCY = 'CIRCULAR_DEPENDENCY', CIRCULAR_REEXPORT = 'CIRCULAR_REEXPORT', CYCLIC_CROSS_CHUNK_REEXPORT = 'CYCLIC_CROSS_CHUNK_REEXPORT', DEPRECATED_FEATURE = 'DEPRECATED_FEATURE', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', FIRST_SIDE_EFFECT = 'FIRST_SIDE_EFFECT', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INCONSISTENT_IMPORT_ASSERTIONS = 'INCONSISTENT_IMPORT_ASSERTIONS', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_LOG_POSITION = 'INVALID_LOG_POSITION', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', OPTIMIZE_CHUNK_STATUS = 'OPTIMIZE_CHUNK_STATUS', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', SHIMMED_EXPORT = 'SHIMMED_EXPORT', SOURCEMAP_BROKEN = 'SOURCEMAP_BROKEN', SOURCEMAP_ERROR = 'SOURCEMAP_ERROR', SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT = 'SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT', THIS_IS_UNDEFINED = 'THIS_IS_UNDEFINED', UNEXPECTED_NAMED_IMPORT = 'UNEXPECTED_NAMED_IMPORT', UNKNOWN_OPTION = 'UNKNOWN_OPTION', UNRESOLVED_ENTRY = 'UNRESOLVED_ENTRY', UNRESOLVED_IMPORT = 'UNRESOLVED_IMPORT', UNUSED_EXTERNAL_IMPORT = 'UNUSED_EXTERNAL_IMPORT', VALIDATION_ERROR = 'VALIDATION_ERROR';
+function logAddonNotGenerated(message, hook, plugin) {
     return {
         code: ADDON_ERROR,
         message: `Could not retrieve "${hook}". Check configuration of plugin "${plugin}".
 \tError Message: ${message}`
     };
 }
-function errorAlreadyClosed() {
+function logAlreadyClosed() {
     return {
         code: ALREADY_CLOSED,
         message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
     };
 }
-function errorAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
+function logAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
     return {
         binding,
         code: AMBIGUOUS_EXTERNAL_NAMESPACES,
@@ -3577,61 +3668,61 @@ function errorAmbiguousExternalNamespaces(binding, reexportingModule, usedModule
         reexporter: reexportingModule
     };
 }
-function errorAnonymousPluginCache() {
+function logAnonymousPluginCache() {
     return {
         code: ANONYMOUS_PLUGIN_CACHE,
         message: 'A plugin is trying to use the Rollup cache but is not declaring a plugin name or cacheKey.'
     };
 }
-function errorAssetNotFinalisedForFileName(name) {
+function logAssetNotFinalisedForFileName(name) {
     return {
         code: ASSET_NOT_FINALISED,
         message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first. If you reference assets via import.meta.ROLLUP_FILE_URL_<referenceId>, you need to either have set their source after "renderStart" or need to provide an explicit "fileName" when emitting them.`
     };
 }
-function errorAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+function logAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
     return {
         code: ASSET_NOT_FOUND,
         message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
     };
 }
-function errorAssetSourceAlreadySet(name) {
+function logAssetSourceAlreadySet(name) {
     return {
         code: ASSET_SOURCE_ALREADY_SET,
         message: `Unable to set the source for asset "${name}", source already set.`
     };
 }
-function errorNoAssetSourceSet(assetName) {
+function logNoAssetSourceSet(assetName) {
     return {
         code: ASSET_SOURCE_MISSING,
         message: `Plugin error creating asset "${assetName}" - no asset source set.`
     };
 }
-function errorBadLoader(id) {
+function logBadLoader(id) {
     return {
         code: BAD_LOADER,
         message: `Error loading "${relativeId(id)}": plugin load hook should return a string, a { code, map } object, or nothing/null.`
     };
 }
-function errorCannotCallNamespace(name) {
+function logCannotCallNamespace(name) {
     return {
         code: CANNOT_CALL_NAMESPACE,
         message: `Cannot call a namespace ("${name}").`
     };
 }
-function errorCannotEmitFromOptionsHook() {
+function logCannotEmitFromOptionsHook() {
     return {
         code: CANNOT_EMIT_FROM_OPTIONS_HOOK,
         message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
     };
 }
-function errorChunkNotGeneratedForFileName(name) {
+function logChunkNotGeneratedForFileName(name) {
     return {
         code: CHUNK_NOT_GENERATED,
         message: `Plugin error - Unable to get file name for emitted chunk "${name}". You can only get file names once chunks have been generated after the "renderStart" hook.`
     };
 }
-function errorChunkInvalid({ fileName, code }, exception) {
+function logChunkInvalid({ fileName, code }, exception) {
     const errorProperties = {
         code: CHUNK_INVALID,
         message: `Chunk "${fileName}" is not valid JavaScript: ${exception.message}.`
@@ -3639,21 +3730,21 @@ function errorChunkInvalid({ fileName, code }, exception) {
     augmentCodeLocation(errorProperties, exception.loc, code, fileName);
     return errorProperties;
 }
-function errorCircularDependency(cyclePath) {
+function logCircularDependency(cyclePath) {
     return {
         code: CIRCULAR_DEPENDENCY,
         ids: cyclePath,
         message: `Circular dependency: ${cyclePath.map(relativeId).join(' -> ')}`
     };
 }
-function errorCircularReexport(exportName, exporter) {
+function logCircularReexport(exportName, exporter) {
     return {
         code: CIRCULAR_REEXPORT,
         exporter,
         message: `"${exportName}" cannot be exported from "${relativeId(exporter)}" as it is a reexport that references itself.`
     };
 }
-function errorCyclicCrossChunkReexport(exportName, exporter, reexporter, importer, preserveModules) {
+function logCyclicCrossChunkReexport(exportName, exporter, reexporter, importer, preserveModules) {
     return {
         code: CYCLIC_CROSS_CHUNK_REEXPORT,
         exporter,
@@ -3662,7 +3753,7 @@ function errorCyclicCrossChunkReexport(exportName, exporter, reexporter, importe
         reexporter
     };
 }
-function errorDeprecation(deprecation, urlSnippet, plugin) {
+function logDeprecation(deprecation, urlSnippet, plugin) {
     return {
         code: DEPRECATED_FEATURE,
         message: deprecation,
@@ -3670,20 +3761,20 @@ function errorDeprecation(deprecation, urlSnippet, plugin) {
         ...(plugin ? { plugin } : {})
     };
 }
-function errorDuplicatePluginName(plugin) {
+function logDuplicatePluginName(plugin) {
     return {
         code: DUPLICATE_PLUGIN_NAME,
         message: `The plugin name ${plugin} is being used twice in the same build. Plugin names must be distinct or provide a cacheKey (please post an issue to the plugin if you are a plugin user).`
     };
 }
-function errorEmptyChunk(chunkName) {
+function logEmptyChunk(chunkName) {
     return {
         code: EMPTY_BUNDLE,
         message: `Generated an empty chunk: "${chunkName}".`,
         names: [chunkName]
     };
 }
-function errorEval(id) {
+function logEval(id) {
     return {
         code: EVAL,
         id,
@@ -3691,39 +3782,45 @@ function errorEval(id) {
         url: getRollupUrl(URL_AVOIDING_EVAL)
     };
 }
-function errorExternalSyntheticExports(id, importer) {
+function logExternalSyntheticExports(id, importer) {
     return {
         code: EXTERNAL_SYNTHETIC_EXPORTS,
         exporter: id,
         message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
     };
 }
-function errorFileNameConflict(fileName) {
+function logFileNameConflict(fileName) {
     return {
         code: FILE_NAME_CONFLICT,
         message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
     };
 }
-function errorFileReferenceIdNotFoundForFilename(assetReferenceId) {
+function logFileReferenceIdNotFoundForFilename(assetReferenceId) {
     return {
         code: FILE_NOT_FOUND,
         message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
     };
 }
-function errorIllegalIdentifierAsName(name) {
+function logFirstSideEffect(source, id, { line, column }) {
+    return {
+        code: FIRST_SIDE_EFFECT,
+        message: `First side effect in ${relativeId(id)} is at (${line}:${column})\n${getCodeFrame(source, line, column)}`
+    };
+}
+function logIllegalIdentifierAsName(name) {
     return {
         code: ILLEGAL_IDENTIFIER_AS_NAME,
         message: `Given name "${name}" is not a legal JS identifier. If you need this, you can try "output.extend: true".`,
         url: getRollupUrl(URL_OUTPUT_EXTEND)
     };
 }
-function errorIllegalImportReassignment(name, importingId) {
+function logIllegalImportReassignment(name, importingId) {
     return {
         code: ILLEGAL_REASSIGNMENT,
         message: `Illegal reassignment of import "${name}" in "${relativeId(importingId)}".`
     };
 }
-function errorInconsistentImportAssertions(existingAssertions, newAssertions, source, importer) {
+function logInconsistentImportAssertions(existingAssertions, newAssertions, source, importer) {
     return {
         code: INCONSISTENT_IMPORT_ASSERTIONS,
         message: `Module "${relativeId(importer)}" tried to import "${relativeId(source)}" with ${formatAssertions(newAssertions)} assertions, but it was already imported elsewhere with ${formatAssertions(existingAssertions)} assertions. Please ensure that import assertions for the same module are always consistent.`
@@ -3735,46 +3832,52 @@ const formatAssertions = (assertions) => {
         return 'no';
     return entries.map(([key, value]) => `"${key}": "${value}"`).join(', ');
 };
-function errorInputHookInOutputPlugin(pluginName, hookName) {
+function logInputHookInOutputPlugin(pluginName, hookName) {
     return {
         code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
         message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
     };
 }
-function errorCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
+function logCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
     return {
         code: INVALID_CHUNK,
         message: `Cannot assign "${relativeId(moduleId)}" to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
     };
 }
-function errorInvalidExportOptionValue(optionValue) {
+function logInvalidExportOptionValue(optionValue) {
     return {
         code: INVALID_EXPORT_OPTION,
         message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}".`,
         url: getRollupUrl(URL_OUTPUT_EXPORTS)
     };
 }
-function errorIncompatibleExportOptionValue(optionValue, keys, entryModule) {
+function logIncompatibleExportOptionValue(optionValue, keys, entryModule) {
     return {
         code: INVALID_EXPORT_OPTION,
         message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${printQuotedStringList(keys)}`,
         url: getRollupUrl(URL_OUTPUT_EXPORTS)
     };
 }
-function errorInternalIdCannotBeExternal(source, importer) {
+function logInternalIdCannotBeExternal(source, importer) {
     return {
         code: INVALID_EXTERNAL_ID,
         message: `"${source}" is imported as an external by "${relativeId(importer)}", but is already an existing non-external module id.`
     };
 }
-function errorInvalidOption(option, urlSnippet, explanation, value) {
+function logInvalidLogPosition(plugin) {
+    return {
+        code: INVALID_LOG_POSITION,
+        message: `Plugin "${plugin}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
+    };
+}
+function logInvalidOption(option, urlSnippet, explanation, value) {
     return {
         code: INVALID_OPTION,
         message: `Invalid value ${value === undefined ? '' : `${JSON.stringify(value)} `}for option "${option}" - ${explanation}.`,
         url: getRollupUrl(urlSnippet)
     };
 }
-function errorInvalidAddonPluginHook(hook, plugin) {
+function logInvalidAddonPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
@@ -3782,7 +3885,7 @@ function errorInvalidAddonPluginHook(hook, plugin) {
         plugin
     };
 }
-function errorInvalidFunctionPluginHook(hook, plugin) {
+function logInvalidFunctionPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
@@ -3790,32 +3893,32 @@ function errorInvalidFunctionPluginHook(hook, plugin) {
         plugin
     };
 }
-function errorInvalidRollupPhaseForAddWatchFile() {
+function logInvalidRollupPhaseForAddWatchFile() {
     return {
         code: INVALID_ROLLUP_PHASE,
         message: `Cannot call "addWatchFile" after the build has finished.`
     };
 }
-function errorInvalidRollupPhaseForChunkEmission() {
+function logInvalidRollupPhaseForChunkEmission() {
     return {
         code: INVALID_ROLLUP_PHASE,
         message: `Cannot emit chunks after module loading has finished.`
     };
 }
-function errorInvalidSetAssetSourceCall() {
+function logInvalidSetAssetSourceCall() {
     return {
         code: INVALID_SETASSETSOURCE,
         message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
     };
 }
-function errorInvalidFormatForTopLevelAwait(id, format) {
+function logInvalidFormatForTopLevelAwait(id, format) {
     return {
         code: INVALID_TLA_FORMAT,
         id,
         message: `Module format "${format}" does not support top-level await. Use the "es" or "system" output formats rather.`
     };
 }
-function errorMissingExport(binding, importingModule, exporter) {
+function logMissingExport(binding, importingModule, exporter) {
     const isJson = extname(exporter) === '.json';
     return {
         binding,
@@ -3826,7 +3929,7 @@ function errorMissingExport(binding, importingModule, exporter) {
         url: getRollupUrl(URL_NAME_IS_NOT_EXPORTED)
     };
 }
-function errorMissingGlobalName(externalId, guess) {
+function logMissingGlobalName(externalId, guess) {
     return {
         code: MISSING_GLOBAL_NAME,
         id: externalId,
@@ -3835,19 +3938,19 @@ function errorMissingGlobalName(externalId, guess) {
         url: getRollupUrl(URL_OUTPUT_GLOBALS)
     };
 }
-function errorImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
+function logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
     return {
         code: MISSING_IMPLICIT_DEPENDANT,
         message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
     };
 }
-function errorUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
+function logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
     return {
         code: MISSING_IMPLICIT_DEPENDANT,
         message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
     };
 }
-function errorImplicitDependantIsNotIncluded(module) {
+function logImplicitDependantIsNotIncluded(module) {
     const implicitDependencies = [...module.implicitlyLoadedBefore]
         .map(dependency => relativeId(dependency.id))
         .sort();
@@ -3856,21 +3959,21 @@ function errorImplicitDependantIsNotIncluded(module) {
         message: `Module "${relativeId(module.id)}" that should be implicitly loaded before ${printQuotedStringList(implicitDependencies)} is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
     };
 }
-function errorMissingNameOptionForIifeExport() {
+function logMissingNameOptionForIifeExport() {
     return {
         code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
         message: `If you do not supply "output.name", you may not be able to access the exports of an IIFE bundle.`,
         url: getRollupUrl(URL_OUTPUT_NAME)
     };
 }
-function errorMissingNameOptionForUmdExport() {
+function logMissingNameOptionForUmdExport() {
     return {
         code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
         message: 'You must supply "output.name" for UMD bundles that have exports so that the exports are accessible in environments without a module loader.',
         url: getRollupUrl(URL_OUTPUT_NAME)
     };
 }
-function errorMissingNodeBuiltins(externalBuiltins) {
+function logMissingNodeBuiltins(externalBuiltins) {
     return {
         code: MISSING_NODE_BUILTINS,
         ids: externalBuiltins,
@@ -3878,14 +3981,14 @@ function errorMissingNodeBuiltins(externalBuiltins) {
     };
 }
 // eslint-disable-next-line unicorn/prevent-abbreviations
-function errorMissingFileOrDirOption() {
+function logMissingFileOrDirOption() {
     return {
         code: MISSING_OPTION,
         message: 'You must specify "output.file" or "output.dir" for the build.',
         url: getRollupUrl(URL_OUTPUT_DIR)
     };
 }
-function errorMixedExport(facadeModuleId, name) {
+function logMixedExport(facadeModuleId, name) {
     return {
         code: MIXED_EXPORTS,
         id: facadeModuleId,
@@ -3893,14 +3996,14 @@ function errorMixedExport(facadeModuleId, name) {
         url: getRollupUrl(URL_OUTPUT_EXPORTS)
     };
 }
-function errorModuleLevelDirective(directive, id) {
+function logModuleLevelDirective(directive, id) {
     return {
         code: MODULE_LEVEL_DIRECTIVE,
         id,
         message: `Module level directives cause errors when bundled, "${directive}" in "${relativeId(id)}" was ignored.`
     };
 }
-function errorNamespaceConflict(binding, reexportingModuleId, sources) {
+function logNamespaceConflict(binding, reexportingModuleId, sources) {
     return {
         binding,
         code: NAMESPACE_CONFLICT,
@@ -3909,14 +4012,22 @@ function errorNamespaceConflict(binding, reexportingModuleId, sources) {
         reexporter: reexportingModuleId
     };
 }
-function errorNoTransformMapOrAstWithoutCode(pluginName) {
+function logNoTransformMapOrAstWithoutCode(pluginName) {
     return {
         code: NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
         message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
             'a "code". This will be ignored.'
     };
 }
-function errorParseError(error, moduleId) {
+function logOptimizeChunkStatus(chunks, smallChunks, pointInTime) {
+    return {
+        code: OPTIMIZE_CHUNK_STATUS,
+        message: `${pointInTime}, there are\n` +
+            `${chunks} chunks, of which\n` +
+            `${smallChunks} are below minChunkSize.`
+    };
+}
+function logParseError(error, moduleId) {
     let message = error.message.replace(/ \(\d+:\d+\)$/, '');
     if (moduleId.endsWith('.json')) {
         message += ' (Note that you need @rollup/plugin-json to import JSON files)';
@@ -3931,10 +4042,8 @@ function errorParseError(error, moduleId) {
         message
     };
 }
-function errorPluginError(error, plugin, { hook, id } = {}) {
-    if (typeof error === 'string')
-        error = { message: error };
-    if (error.code && error.code !== PLUGIN_ERROR) {
+function logPluginError(error, plugin, { hook, id } = {}) {
+    if (error.code && !error.code.startsWith('PLUGIN_') && !error.pluginCode) {
         error.pluginCode = error.code;
     }
     error.code = PLUGIN_ERROR;
@@ -3947,7 +4056,7 @@ function errorPluginError(error, plugin, { hook, id } = {}) {
     }
     return error;
 }
-function errorShimmedExport(id, binding) {
+function logShimmedExport(id, binding) {
     return {
         binding,
         code: SHIMMED_EXPORT,
@@ -3955,7 +4064,7 @@ function errorShimmedExport(id, binding) {
         message: `Missing export "${binding}" has been shimmed in module "${relativeId(id)}".`
     };
 }
-function errorSourcemapBroken(plugin) {
+function logSourcemapBroken(plugin) {
     return {
         code: SOURCEMAP_BROKEN,
         message: `Sourcemap is likely to be incorrect: a plugin (${plugin}) was used to transform files, but didn't generate a sourcemap for the transformation. Consult the plugin documentation for help`,
@@ -3963,13 +4072,13 @@ function errorSourcemapBroken(plugin) {
         url: getRollupUrl(URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT)
     };
 }
-function errorConflictingSourcemapSources(filename) {
+function logConflictingSourcemapSources(filename) {
     return {
         code: SOURCEMAP_BROKEN,
         message: `Multiple conflicting contents for sourcemap source ${filename}`
     };
 }
-function errorInvalidSourcemapForError(error, id, column, line, pos) {
+function logInvalidSourcemapForError(error, id, column, line, pos) {
     return {
         cause: error,
         code: SOURCEMAP_ERROR,
@@ -3983,7 +4092,7 @@ function errorInvalidSourcemapForError(error, id, column, line, pos) {
         pos
     };
 }
-function errorSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+function logSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
     return {
         code: SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
         exporter: id,
@@ -3992,14 +4101,14 @@ function errorSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExports
             : 'a default export'} that does not reexport an unresolved named export of the same module.`
     };
 }
-function errorThisIsUndefined() {
+function logThisIsUndefined() {
     return {
         code: THIS_IS_UNDEFINED,
         message: `The 'this' keyword is equivalent to 'undefined' at the top level of an ES module, and has been rewritten`,
         url: getRollupUrl(URL_THIS_IS_UNDEFINED)
     };
 }
-function errorUnexpectedNamedImport(id, imported, isReexport) {
+function logUnexpectedNamedImport(id, imported, isReexport) {
     const importType = isReexport ? 'reexport' : 'import';
     return {
         code: UNEXPECTED_NAMED_IMPORT,
@@ -4008,7 +4117,7 @@ function errorUnexpectedNamedImport(id, imported, isReexport) {
         url: getRollupUrl(URL_OUTPUT_INTEROP)
     };
 }
-function errorUnexpectedNamespaceReexport(id) {
+function logUnexpectedNamespaceReexport(id) {
     return {
         code: UNEXPECTED_NAMED_IMPORT,
         exporter: id,
@@ -4016,25 +4125,25 @@ function errorUnexpectedNamespaceReexport(id) {
         url: getRollupUrl(URL_OUTPUT_INTEROP)
     };
 }
-function errorUnknownOption(optionType, unknownOptions, validOptions) {
+function logUnknownOption(optionType, unknownOptions, validOptions) {
     return {
         code: UNKNOWN_OPTION,
         message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.join(', ')}`
     };
 }
-function errorEntryCannotBeExternal(unresolvedId) {
+function logEntryCannotBeExternal(unresolvedId) {
     return {
         code: UNRESOLVED_ENTRY,
         message: `Entry module "${relativeId(unresolvedId)}" cannot be external.`
     };
 }
-function errorUnresolvedEntry(unresolvedId) {
+function logUnresolvedEntry(unresolvedId) {
     return {
         code: UNRESOLVED_ENTRY,
         message: `Could not resolve entry module "${relativeId(unresolvedId)}".`
     };
 }
-function errorUnresolvedImport(source, importer) {
+function logUnresolvedImport(source, importer) {
     return {
         code: UNRESOLVED_IMPORT,
         exporter: source,
@@ -4042,7 +4151,7 @@ function errorUnresolvedImport(source, importer) {
         message: `Could not resolve "${source}" from "${relativeId(importer)}"`
     };
 }
-function errorUnresolvedImportTreatedAsExternal(source, importer) {
+function logUnresolvedImportTreatedAsExternal(source, importer) {
     return {
         code: UNRESOLVED_IMPORT,
         exporter: source,
@@ -4051,7 +4160,7 @@ function errorUnresolvedImportTreatedAsExternal(source, importer) {
         url: getRollupUrl(URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY)
     };
 }
-function errorUnusedExternalImports(externalId, names, importers) {
+function logUnusedExternalImports(externalId, names, importers) {
     return {
         code: UNUSED_EXTERNAL_IMPORT,
         exporter: externalId,
@@ -4063,94 +4172,23 @@ function errorUnusedExternalImports(externalId, names, importers) {
         names
     };
 }
-function errorFailedValidation(message) {
+function logFailedValidation(message) {
     return {
         code: VALIDATION_ERROR,
         message
     };
 }
 function warnDeprecation(deprecation, urlSnippet, activeDeprecation, options, plugin) {
-    warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, options.onwarn, options.strictDeprecations, plugin);
+    warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, options.onLog, options.strictDeprecations, plugin);
 }
-function warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, warn, strictDeprecations, plugin) {
+function warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, log, strictDeprecations, plugin) {
     if (activeDeprecation || strictDeprecations) {
-        const warning = errorDeprecation(deprecation, urlSnippet, plugin);
+        const warning = logDeprecation(deprecation, urlSnippet, plugin);
         if (strictDeprecations) {
             return error(warning);
         }
-        warn(warning);
-    }
-}
-
-const RESERVED_NAMES = new Set([
-    'await',
-    'break',
-    'case',
-    'catch',
-    'class',
-    'const',
-    'continue',
-    'debugger',
-    'default',
-    'delete',
-    'do',
-    'else',
-    'enum',
-    'eval',
-    'export',
-    'extends',
-    'false',
-    'finally',
-    'for',
-    'function',
-    'if',
-    'implements',
-    'import',
-    'in',
-    'instanceof',
-    'interface',
-    'let',
-    'NaN',
-    'new',
-    'null',
-    'package',
-    'private',
-    'protected',
-    'public',
-    'return',
-    'static',
-    'super',
-    'switch',
-    'this',
-    'throw',
-    'true',
-    'try',
-    'typeof',
-    'undefined',
-    'var',
-    'void',
-    'while',
-    'with',
-    'yield'
-]);
-const RESERVED_NAMES$1 = RESERVED_NAMES;
-
-const illegalCharacters = /[^\w$]/g;
-const startsWithDigit = (value) => /\d/.test(value[0]);
-const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES$1.has(value) || value === 'arguments';
-function isLegal(value) {
-    if (needsEscape(value)) {
-        return false;
+        log(LOGLEVEL_WARN, warning);
     }
-    return !illegalCharacters.test(value);
-}
-function makeLegal(value) {
-    value = value
-        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
-        .replace(illegalCharacters, '_');
-    if (needsEscape(value))
-        value = `_${value}`;
-    return value || '_';
 }
 
 class ExternalModule {
@@ -4235,7 +4273,7 @@ class ExternalModule {
             }
         }
         const importersArray = [...importersSet];
-        this.options.onwarn(errorUnusedExternalImports(this.id, unused, importersArray));
+        this.options.onLog(LOGLEVEL_WARN, logUnusedExternalImports(this.id, unused, importersArray));
     }
 }
 
@@ -4763,6 +4801,7 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
 
 // AST walker module for Mozilla Parser API compatible trees
 
+
 function skipThrough(node, st, c) { c(node, st); }
 function ignore(_node, _st, _c) {}
 
@@ -5032,7 +5071,10 @@ const BlockStatement$1 = 'BlockStatement';
 const CallExpression$1 = 'CallExpression';
 const ChainExpression$1 = 'ChainExpression';
 const ConditionalExpression$1 = 'ConditionalExpression';
+const ExportDefaultDeclaration$1 = 'ExportDefaultDeclaration';
+const ExportNamedDeclaration$1 = 'ExportNamedDeclaration';
 const ExpressionStatement$1 = 'ExpressionStatement';
+const FunctionDeclaration$1 = 'FunctionDeclaration';
 const Identifier$1 = 'Identifier';
 const LogicalExpression$1 = 'LogicalExpression';
 const NewExpression$1 = 'NewExpression';
@@ -5040,6 +5082,8 @@ const Program$1 = 'Program';
 const Property$1 = 'Property';
 const ReturnStatement$1 = 'ReturnStatement';
 const SequenceExpression$1 = 'SequenceExpression';
+const VariableDeclarator$1 = 'VariableDeclarator';
+const VariableDeclaration$1 = 'VariableDeclaration';
 
 // this looks ridiculous, but it prevents sourcemap tooling from mistaking
 // this for an actual sourceMappingURL
@@ -5111,6 +5155,28 @@ function markPureNode(node, comment, code) {
                     invalidAnnotation = true;
                     break;
                 }
+                case ExportNamedDeclaration$1:
+                case ExportDefaultDeclaration$1: {
+                    node = node.declaration;
+                    continue;
+                }
+                case VariableDeclaration$1: {
+                    
+                    const declaration = node;
+                    if (declaration.kind === 'const') {
+                        // jsdoc only applies to the first declaration
+                        node = declaration.declarations[0].init;
+                        continue;
+                    }
+                    invalidAnnotation = true;
+                    break;
+                }
+                case VariableDeclarator$1: {
+                    node = node.init;
+                    continue;
+                }
+                case FunctionDeclaration$1:
+                case ArrowFunctionExpression$1:
                 case CallExpression$1:
                 case NewExpression$1: {
                     break;
@@ -5153,15 +5219,20 @@ function doesNotMatchOutsideComment(code, forbiddenChars) {
     }
     return true;
 }
-const pureCommentRegex = /[#@]__PURE__/;
+const annotationsRegexes = [
+    ['pure', /[#@]__PURE__/],
+    ['noSideEffects', /[#@]__NO_SIDE_EFFECTS__/]
+];
 function addAnnotations(comments, esTreeAst, code) {
     const annotations = [];
     const sourceMappingComments = [];
     for (const comment of comments) {
-        if (pureCommentRegex.test(comment.value)) {
-            annotations.push(comment);
+        for (const [annotationType, regex] of annotationsRegexes) {
+            if (regex.test(comment.value)) {
+                annotations.push({ ...comment, annotationType });
+            }
         }
-        else if (SOURCEMAPPING_URL_RE.test(comment.value)) {
+        if (SOURCEMAPPING_URL_RE.test(comment.value)) {
             sourceMappingComments.push(comment);
         }
     }
@@ -5305,7 +5376,12 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (key.charCodeAt(0) === 95 /* _ */) {
                 if (key === ANNOTATION_KEY) {
-                    this.annotations = value;
+                    const annotations = value;
+                    this.annotations = annotations;
+                    if (this.context.options.treeshake.annotations) {
+                        this.annotationNoSideEffects = annotations.some(comment => comment.annotationType === 'noSideEffects');
+                        this.annotationPure = annotations.some(comment => comment.annotationType === 'pure');
+                    }
                 }
                 else if (key === INVALID_COMMENT_KEY) {
                     for (const { start, end } of value)
@@ -6648,6 +6724,13 @@ const IMPURE = {
     getLiteralValue: getTruthyLiteralValue,
     hasEffectsWhenCalled: returnTrue
 };
+const PURE_WITH_ARRAY = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }) {
+        return args.length > 1 && !(args[1] instanceof ArrayExpression);
+    }
+};
 // We use shortened variables to reduce file size here
 /* OBJECT */
 const O = {
@@ -6685,6 +6768,11 @@ const PC = {
     [ValueProperties]: PURE,
     prototype: O
 };
+const PC_WITH_ARRAY = {
+    __proto__: null,
+    [ValueProperties]: PURE_WITH_ARRAY,
+    prototype: O
+};
 const ARRAY_TYPE = {
     __proto__: null,
     [ValueProperties]: PURE,
@@ -6755,7 +6843,7 @@ const knownGlobals = {
     isNaN: PF,
     isPrototypeOf: O,
     JSON: O,
-    Map: C,
+    Map: PC_WITH_ARRAY,
     Math: {
         __proto__: null,
         [ValueProperties]: IMPURE,
@@ -6851,7 +6939,7 @@ const knownGlobals = {
     ReferenceError: PC,
     Reflect: O,
     RegExp: PC,
-    Set: C,
+    Set: PC_WITH_ARRAY,
     SharedArrayBuffer: C,
     String: {
         __proto__: null,
@@ -6891,8 +6979,8 @@ const knownGlobals = {
     unescape: PF,
     URIError: PC,
     valueOf: O,
-    WeakMap: C,
-    WeakSet: C,
+    WeakMap: PC_WITH_ARRAY,
+    WeakSet: PC_WITH_ARRAY,
     // Additional globals shared by Node and Browser that are not strictly part of the language
     clearInterval: C,
     clearTimeout: C,
@@ -7769,7 +7857,7 @@ class Identifier extends NodeBase {
         }
     }
     disallowImportReassignment() {
-        return this.context.error(errorIllegalImportReassignment(this.name, this.context.module.id), this.start);
+        return this.context.error(logIllegalImportReassignment(this.name, this.context.module.id), this.start);
     }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
@@ -7977,9 +8065,9 @@ class ExpressionStatement extends NodeBase {
         if (this.directive &&
             this.directive !== 'use strict' &&
             this.parent.type === Program$1) {
-            this.context.warn(
+            this.context.log(LOGLEVEL_WARN, 
             // This is necessary, because either way (deleting or not) can lead to errors.
-            errorModuleLevelDirective(this.directive, this.context.module.id), this.start);
+            logModuleLevelDirective(this.directive, this.context.module.id), this.start);
         }
     }
     render(code, options) {
@@ -8145,6 +8233,9 @@ class FunctionBase extends NodeBase {
         if (path.length > 0 || interaction.type !== INTERACTION_CALLED) {
             return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
         }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
         if (this.async) {
             const { propertyReadSideEffects } = this.context.options
                 .treeshake;
@@ -8208,8 +8299,12 @@ class ArrowFunctionExpression extends FunctionBase {
         return false;
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context)) {
             return true;
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
         if (interaction.type === INTERACTION_CALLED) {
             const { ignore, brokenFlow } = context;
             context.ignore = {
@@ -8515,11 +8610,17 @@ class FunctionNode extends FunctionBase {
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
         return !!this.id?.hasEffects(context);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
             return true;
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
         if (interaction.type === INTERACTION_CALLED) {
             const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
             context.replacedVariableInits.set(this.scope.thisVariable, interaction.withNew ? this.constructedEntity : UNKNOWN_EXPRESSION);
@@ -9015,7 +9116,7 @@ class MemberExpression extends NodeBase {
                 if (this.variable) {
                     this.context.includeVariableInModule(this.variable);
                 }
-                this.context.warn(errorIllegalImportReassignment(this.object.name, this.context.module.id), this.start);
+                this.context.log(LOGLEVEL_WARN, logIllegalImportReassignment(this.object.name, this.context.module.id), this.start);
             }
         }
     }
@@ -9061,7 +9162,7 @@ function resolveNamespaceVariables(baseVariable, path, astContext) {
     if (!variable) {
         if (path.length === 1) {
             const fileName = baseVariable.context.fileName;
-            astContext.warn(errorMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
+            astContext.log(LOGLEVEL_WARN, logMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
             return 'undefined';
         }
         return null;
@@ -9168,10 +9269,10 @@ class CallExpression extends CallExpressionBase {
         if (this.callee instanceof Identifier) {
             const variable = this.scope.findVariable(this.callee.name);
             if (variable.isNamespace) {
-                this.context.warn(errorCannotCallNamespace(this.callee.name), this.start);
+                this.context.log(LOGLEVEL_WARN, logCannotCallNamespace(this.callee.name), this.start);
             }
             if (this.callee.name === 'eval') {
-                this.context.warn(errorEval(this.context.module.id), this.start);
+                this.context.log(LOGLEVEL_WARN, logEval(this.context.module.id), this.start);
             }
         }
         this.interaction = {
@@ -9191,9 +9292,9 @@ class CallExpression extends CallExpressionBase {
                 if (argument.hasEffects(context))
                     return true;
             }
-            if (this.context.options.treeshake.annotations &&
-                this.annotations)
+            if (this.annotationPure) {
                 return false;
+            }
             return (this.callee.hasEffects(context) ||
                 this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
         }
@@ -11164,8 +11265,7 @@ class NewExpression extends NodeBase {
                 if (argument.hasEffects(context))
                     return true;
             }
-            if (this.context.options.treeshake.annotations &&
-                this.annotations) {
+            if (this.annotationPure) {
                 return false;
             }
             return (this.callee.hasEffects(context) ||
@@ -11285,29 +11385,6 @@ class ObjectExpression extends NodeBase {
 class PrivateIdentifier extends NodeBase {
 }
 
-function getOriginalLocation(sourcemapChain, location) {
-    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !!sourcemap.mappings);
-    traceSourcemap: while (filteredSourcemapChain.length > 0) {
-        const sourcemap = filteredSourcemapChain.pop();
-        const line = sourcemap.mappings[location.line - 1];
-        if (line) {
-            const filteredLine = line.filter((segment) => segment.length > 1);
-            const lastSegment = filteredLine[filteredLine.length - 1];
-            for (const segment of filteredLine) {
-                if (segment[0] >= location.column || segment === lastSegment) {
-                    location = {
-                        column: segment[3],
-                        line: segment[2] + 1
-                    };
-                    continue traceSourcemap;
-                }
-            }
-        }
-        throw new Error("Can't resolve original location of error.");
-    }
-    return location;
-}
-
 class Program extends NodeBase {
     constructor() {
         super(...arguments);
@@ -11327,19 +11404,8 @@ class Program extends NodeBase {
             if (node.hasEffects(context)) {
                 if (this.context.options.experimentalLogSideEffects && !this.hasLoggedEffect) {
                     this.hasLoggedEffect = true;
-                    const { code, module } = this.context;
-                    const { line, column } = locate(code, node.start, { offsetLine: 1 });
-                    console.log(`First side effect in ${relativeId(module.id)} is at (${line}:${column})\n${getCodeFrame(code, line, column)}`);
-                    try {
-                        const { column: originalColumn, line: originalLine } = getOriginalLocation(module.sourcemapChain, { column, line });
-                        if (originalLine !== line) {
-                            console.log(`Original location is at (${originalLine}:${originalColumn})\n${getCodeFrame(module.originalCode, originalLine, originalColumn)}\n`);
-                        }
-                    }
-                    catch {
-                        /* ignored */
-                    }
-                    console.log();
+                    const { code, log, module } = this.context;
+                    log(LOGLEVEL_INFO, logFirstSideEffect(code, module.id, locate(code, node.start, { offsetLine: 1 })), node.start);
                 }
                 return (this.hasCachedEffect = true);
             }
@@ -11361,6 +11427,14 @@ class Program extends NodeBase {
             code.remove(0, start);
         }
         if (this.body.length > 0) {
+            // Keep all consecutive lines that start with a comment
+            while (code.original[start] === '/' && /[*/]/.test(code.original[start + 1])) {
+                const firstLineBreak = findFirstLineBreakOutsideComment(code.original.slice(start, this.body[0].start));
+                if (firstLineBreak[0] === -1) {
+                    break;
+                }
+                start += firstLineBreak[1];
+            }
             renderStatementList(this.body, code, start, this.end, options);
         }
         else {
@@ -11604,6 +11678,7 @@ SwitchCase.prototype.needsBoundaries = true;
 
 class SwitchStatement extends NodeBase {
     createScope(parentScope) {
+        this.parentScope = parentScope;
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
@@ -11672,6 +11747,10 @@ class SwitchStatement extends NodeBase {
         }
         this.defaultCase = null;
     }
+    parseNode(esTreeNode) {
+        this.discriminant = new (this.context.getNodeConstructor(esTreeNode.discriminant.type))(esTreeNode.discriminant, this, this.parentScope);
+        super.parseNode(esTreeNode);
+    }
     render(code, options) {
         this.discriminant.render(code, options);
         if (this.cases.length > 0) {
@@ -11687,7 +11766,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
             const name = this.tag.name;
             const variable = this.scope.findVariable(name);
             if (variable.isNamespace) {
-                this.context.warn(errorCannotCallNamespace(name), this.start);
+                this.context.log(LOGLEVEL_WARN, logCannotCallNamespace(name), this.start);
             }
         }
     }
@@ -11934,7 +12013,7 @@ class ThisExpression extends NodeBase {
         this.alias =
             this.scope.findLexicalBoundary() instanceof ModuleScope ? this.context.moduleContext : null;
         if (this.alias === 'undefined') {
-            this.context.warn(errorThisIsUndefined(), this.start);
+            this.context.log(LOGLEVEL_WARN, logThisIsUndefined(), this.start);
         }
     }
     render(code) {
@@ -12478,14 +12557,14 @@ class NamespaceVariable extends Variable {
         const memberVariables = this.getMemberVariables();
         const members = Object.entries(memberVariables)
             .filter(([_, variable]) => variable.included)
-            .map(([name, original]) => {
-            if (this.referencedEarly || original.isReassigned) {
+            .map(([name, variable]) => {
+            if (this.referencedEarly || variable.isReassigned || variable === this) {
                 return [
                     null,
-                    `get ${name}${_}()${_}{${_}return ${original.getName(getPropertyAccess)}${s}${_}}`
+                    `get ${name}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
                 ];
             }
-            return [name, original.getName(getPropertyAccess)];
+            return [name, variable.getName(getPropertyAccess)];
         });
         members.unshift([null, `__proto__:${_}null`]);
         let output = getObject(members, { lineBreakIndent: { base: '', t } });
@@ -12577,6 +12656,29 @@ function getId(m) {
     return m.id;
 }
 
+function getOriginalLocation(sourcemapChain, location) {
+    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !!sourcemap.mappings);
+    traceSourcemap: while (filteredSourcemapChain.length > 0) {
+        const sourcemap = filteredSourcemapChain.pop();
+        const line = sourcemap.mappings[location.line - 1];
+        if (line) {
+            const filteredLine = line.filter((segment) => segment.length > 1);
+            const lastSegment = filteredLine[filteredLine.length - 1];
+            for (const segment of filteredLine) {
+                if (segment[0] >= location.column || segment === lastSegment) {
+                    location = {
+                        column: segment[3],
+                        line: segment[2] + 1
+                    };
+                    continue traceSourcemap;
+                }
+            }
+        }
+        throw new Error("Can't resolve original location of error.");
+    }
+    return location;
+}
+
 function getAssertionsFromImportExpression(node) {
     const assertProperty = node.arguments?.[0]?.properties.find((property) => getPropertyKey(property) === 'assert')?.value;
     if (!assertProperty) {
@@ -12753,7 +12855,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
-            return isExportAllSearch ? [null] : error(errorCircularReexport(name, target.id));
+            return isExportAllSearch ? [null] : error(logCircularReexport(name, target.id));
         }
         searchedModules.add(target);
     }
@@ -12936,6 +13038,16 @@ class Module {
         this.addLocationToLogProps(properties, pos);
         return error(properties);
     }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
     getAllExportNames() {
         if (this.allExportNames) {
             return this.allExportNames;
@@ -13069,7 +13181,7 @@ class Module {
                 : 'default', { onlyExplicit: true });
         }
         if (!this.syntheticNamespace) {
-            return error(errorSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
+            return error(logSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
         }
         return this.syntheticNamespace;
     }
@@ -13088,7 +13200,7 @@ class Module {
         if (reexportDeclaration) {
             const [variable] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
             if (!variable) {
-                return this.error(errorMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
+                return this.error(logMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
             }
             if (importerForSideEffects) {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
@@ -13205,7 +13317,11 @@ class Module {
     isIncluded() {
         // Modules where this.ast is missing have been loaded via this.load and are
         // not yet fully processed, hence they cannot be included.
-        return (this.ast && (this.ast.included || this.namespace.included || this.importedFromNotTreeshaken));
+        return (this.ast &&
+            (this.ast.included ||
+                this.namespace.included ||
+                this.importedFromNotTreeshaken ||
+                this.exportShimVariable.included));
     }
     linkImports() {
         this.addModulesToImportDescriptions(this.importDescriptions);
@@ -13221,13 +13337,17 @@ class Module {
         }
         this.exportAllModules.push(...externalExportAllModules);
     }
+    log(level, properties, pos) {
+        this.addLocationToLogProps(properties, pos);
+        this.options.onLog(level, properties);
+    }
     render(options) {
         const source = this.magicString.clone();
         this.ast.render(source, options);
         source.trim();
         const { usesTopLevelAwait } = this.astContext;
         if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
-            return error(errorInvalidFormatForTopLevelAwait(this.id, options.format));
+            return error(logInvalidFormatForTopLevelAwait(this.id, options.format));
         }
         return { source, usesTopLevelAwait };
     }
@@ -13272,6 +13392,7 @@ class Module {
             includeAllExports: () => this.includeAllExports(true),
             includeDynamicImport: this.includeDynamicImport.bind(this),
             includeVariableInModule: this.includeVariableInModule.bind(this),
+            log: this.log.bind(this),
             magicString: this.magicString,
             manualPureFunctions: this.graph.pureFunctions,
             module: this,
@@ -13280,8 +13401,7 @@ class Module {
             requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
             traceExport: (name) => this.getVariableForExportName(name)[0],
             traceVariable: this.traceVariable.bind(this),
-            usesTopLevelAwait: false,
-            warn: this.warn.bind(this)
+            usesTopLevelAwait: false
         };
         this.scope = new ModuleScope(this.graph.scope, this.astContext);
         this.namespace = new NamespaceVariable(this.astContext);
@@ -13341,7 +13461,7 @@ class Module {
             }
             const [declaration] = getVariableForExportNameRecursive(otherModule, importDescription.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules);
             if (!declaration) {
-                return this.error(errorMissingExport(importDescription.name, this.id, otherModule.id), importDescription.start);
+                return this.error(logMissingExport(importDescription.name, this.id, otherModule.id), importDescription.start);
             }
             return declaration;
         }
@@ -13358,10 +13478,6 @@ class Module {
             Object.assign(this.info.meta, meta);
         }
     }
-    warn(properties, pos) {
-        this.addLocationToLogProps(properties, pos);
-        this.options.onwarn(properties);
-    }
     addDynamicImport(node) {
         let argument = node.source;
         if (argument instanceof TemplateLiteral) {
@@ -13475,7 +13591,7 @@ class Module {
                 code = this.originalCode;
             }
             catch (error_) {
-                this.options.onwarn(errorInvalidSourcemapForError(error_, this.id, column, line, pos));
+                this.options.onLog(LOGLEVEL_WARN, logInvalidSourcemapForError(error_, this.id, column, line, pos));
             }
             augmentCodeLocation(properties, { column, line }, code, this.id);
         }
@@ -13516,7 +13632,7 @@ class Module {
         const existingAssertions = this.sourcesWithAssertions.get(source);
         if (existingAssertions) {
             if (doAssertionsDiffer(existingAssertions, parsedAssertions)) {
-                this.warn(errorInconsistentImportAssertions(existingAssertions, parsedAssertions, source, this.id), declaration.start);
+                this.log(LOGLEVEL_WARN, logInconsistentImportAssertions(existingAssertions, parsedAssertions, source, this.id), declaration.start);
             }
         }
         else {
@@ -13554,7 +13670,7 @@ class Module {
             if (foundDeclarationList.length === 1) {
                 return [usedDeclaration];
             }
-            this.options.onwarn(errorNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
+            this.options.onLog(LOGLEVEL_WARN, logNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
             // TODO we are pretending it was not found while it should behave like "undefined"
             return [null];
         }
@@ -13562,7 +13678,7 @@ class Module {
             const foundDeclarationList = [...foundExternalDeclarations];
             const usedDeclaration = foundDeclarationList[0];
             if (foundDeclarationList.length > 1) {
-                this.options.onwarn(errorAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
+                this.options.onLog(LOGLEVEL_WARN, logAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
             }
             return [usedDeclaration, true];
         }
@@ -13606,10 +13722,15 @@ class Module {
         }
     }
     includeVariable(variable) {
-        if (!variable.included) {
+        const variableModule = variable.module;
+        if (variable.included) {
+            if (variableModule instanceof Module && variableModule !== this) {
+                getAndExtendSideEffectModules(variable, this);
+            }
+        }
+        else {
             variable.include();
             this.graph.needsTreeshakingPass = true;
-            const variableModule = variable.module;
             if (variableModule instanceof Module) {
                 if (!variableModule.isExecuted) {
                     markModuleAndImpureDependenciesAsExecuted(variableModule);
@@ -13633,7 +13754,7 @@ class Module {
         }
     }
     shimMissingExport(name) {
-        this.options.onwarn(errorShimmedExport(this.id, name));
+        this.options.onLog(LOGLEVEL_WARN, logShimmedExport(this.id, name));
         this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
     tryParse() {
@@ -13641,7 +13762,7 @@ class Module {
             return this.graph.contextParse(this.info.code);
         }
         catch (error_) {
-            return this.error(errorParseError(error_, this.id), error_.pos);
+            return this.error(logParseError(error_, this.id), error_.pos);
         }
     }
 }
@@ -13942,17 +14063,17 @@ const nodeBuiltins = new Set([
     'timers/promises',
     'util/types'
 ]);
-function warnOnBuiltins(warn, dependencies) {
+function warnOnBuiltins(log, dependencies) {
     const externalBuiltins = dependencies
         .map(({ importPath }) => importPath)
         .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
     if (externalBuiltins.length === 0)
         return;
-    warn(errorMissingNodeBuiltins(externalBuiltins));
+    log(LOGLEVEL_WARN, logMissingNodeBuiltins(externalBuiltins));
 }
 
-function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets, onwarn }, { amd, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
-    warnOnBuiltins(onwarn, dependencies);
+function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
+    warnOnBuiltins(log, dependencies);
     const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
     const parameters = dependencies.map(m => m.name);
     const { n, getNonArrowFunctionIntro, _ } = snippets;
@@ -14177,19 +14298,19 @@ function trimEmptyImports(dependencies) {
     return [];
 }
 
-function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, outro, snippets, onwarn }, { compact, esModule, extend, freeze, externalLiveBindings, globals, interop, name, namespaceToStringTag, strict }) {
+function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, globals, interop, name, namespaceToStringTag, strict }) {
     const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
     const isNamespaced = name && name.includes('.');
     const useVariableAssignment = !extend && !isNamespaced;
     if (name && useVariableAssignment && !isLegal(name)) {
-        return error(errorIllegalIdentifierAsName(name));
+        return error(logIllegalIdentifierAsName(name));
     }
-    warnOnBuiltins(onwarn, dependencies);
+    warnOnBuiltins(log, dependencies);
     const external = trimEmptyImports(dependencies);
     const deps = external.map(dep => dep.globalName || 'null');
     const parameters = external.map(m => m.name);
     if (hasExports && !name) {
-        onwarn(errorMissingNameOptionForIifeExport());
+        log(LOGLEVEL_WARN, logMissingNameOptionForIifeExport());
     }
     if (namedExportsMode && hasExports) {
         if (extend) {
@@ -14381,14 +14502,14 @@ function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
         .map(part => (propertyPath += getPropertyAccess(part)))
         .join(`${_}&&${_}`);
 }
-function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, outro, snippets, onwarn }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, namespaceToStringTag, globals, noConflict, strict }) {
+function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, namespaceToStringTag, globals, noConflict, strict }) {
     const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
     const factoryVariable = compact ? 'f' : 'factory';
     const globalVariable = compact ? 'g' : 'global';
     if (hasExports && !name) {
-        return error(errorMissingNameOptionForUmdExport());
+        return error(logMissingNameOptionForUmdExport());
     }
-    warnOnBuiltins(onwarn, dependencies);
+    warnOnBuiltins(log, dependencies);
     const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
     const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
     const trimmedImports = trimEmptyImports(dependencies);
@@ -14498,7 +14619,7 @@ async function createAddons(options, outputPluginDriver, chunk) {
         return { banner, footer, intro, outro };
     }
     catch (error_) {
-        return error(errorAddonNotGenerated(error_.message, error_.hook, error_.plugin));
+        return error(logAddonNotGenerated(error_.message, error_.hook, error_.plugin));
     }
 }
 
@@ -14651,15 +14772,15 @@ function assignExportsToNames(exports, exportsByName, exportNamesByVariable) {
     }
 }
 
-function getExportMode(chunk, { exports: exportMode, name, format }, facadeModuleId, warn) {
+function getExportMode(chunk, { exports: exportMode, name, format }, facadeModuleId, log) {
     const exportKeys = chunk.getExportNames();
     if (exportMode === 'default') {
         if (exportKeys.length !== 1 || exportKeys[0] !== 'default') {
-            return error(errorIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
+            return error(logIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
         }
     }
     else if (exportMode === 'none' && exportKeys.length > 0) {
-        return error(errorIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
+        return error(logIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
     }
     if (exportMode === 'auto') {
         if (exportKeys.length === 0) {
@@ -14670,7 +14791,7 @@ function getExportMode(chunk, { exports: exportMode, name, format }, facadeModul
         }
         else {
             if (format !== 'es' && format !== 'system' && exportKeys.includes('default')) {
-                warn(errorMixedExport(facadeModuleId, name));
+                log(LOGLEVEL_WARN, logMixedExport(facadeModuleId, name));
             }
             exportMode = 'named';
         }
@@ -14747,7 +14868,8 @@ function addStaticDependencies(module, staticDependencies, handledModules, chunk
     }
 }
 
-// Four random characters from the private use area to minimize risk of conflicts
+// Four random characters from the private use area to minimize risk of
+// conflicts
 const hashPlaceholderLeft = '!~{';
 const hashPlaceholderRight = '}~';
 const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
@@ -14758,11 +14880,11 @@ const getHashPlaceholderGenerator = () => {
     let nextIndex = 0;
     return (optionName, hashSize = defaultHashSize) => {
         if (hashSize > maxHashSize) {
-            return error(errorFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
+            return error(logFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
         }
         const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
         if (placeholder.length > hashSize) {
-            return error(errorFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
+            return error(logFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
         }
         return placeholder;
     };
@@ -14829,14 +14951,14 @@ const removeUnreferencedAssets = (outputBundle) => {
 
 function renderNamePattern(pattern, patternName, replacements) {
     if (isPathFragment(pattern))
-        return error(errorFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
+        return error(logFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
     return pattern.replace(/\[(\w+)(:\d+)?]/g, (_match, type, size) => {
         if (!replacements.hasOwnProperty(type) || (size && type !== 'hash')) {
-            return error(errorFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
+            return error(logFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
         }
         const replacement = replacements[type](size && Number.parseInt(size.slice(1)));
         if (isPathFragment(replacement))
-            return error(errorFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
+            return error(logFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
         return replacement;
     });
 }
@@ -14861,13 +14983,13 @@ const NON_ASSET_EXTENSIONS = new Set([
     '.cjs',
     '.cts'
 ]);
-function getGlobalName(chunk, globals, hasExports, warn) {
+function getGlobalName(chunk, globals, hasExports, log) {
     const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
     if (globalName) {
         return globalName;
     }
     if (hasExports) {
-        warn(errorMissingGlobalName(chunk.id, chunk.variableName));
+        log(LOGLEVEL_WARN, logMissingGlobalName(chunk.id, chunk.variableName));
         return chunk.variableName;
     }
 }
@@ -14969,13 +15091,18 @@ class Chunk {
     }
     canModuleBeFacade(module, exposedVariables) {
         const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
                 return false;
             }
         }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
         for (const exposedVariable of exposedVariables) {
-            if (!(moduleExportNamesByVariable.has(exposedVariable) || exposedVariable.module === module)) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
                 return false;
             }
         }
@@ -15021,7 +15148,7 @@ class Chunk {
             assignExportsToNames(remainingExports, this.exportsByName, this.exportNamesByVariable);
         }
         if (this.outputOptions.preserveModules || (this.facadeModule && this.facadeModule.info.isEntry))
-            this.exportMode = getExportMode(this, this.outputOptions, this.facadeModule.id, this.inputOptions.onwarn);
+            this.exportMode = getExportMode(this, this.outputOptions, this.facadeModule.id, this.inputOptions.onLog);
     }
     generateFacades() {
         const facades = [];
@@ -15030,7 +15157,10 @@ class Chunk {
         for (const module of entryModules) {
             if (module.preserveSignature) {
                 for (const exportedVariable of module.getExportNamesByVariable().keys()) {
-                    exposedVariables.add(exportedVariable);
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
                 }
             }
         }
@@ -15166,7 +15296,7 @@ class Chunk {
         }
     }
     async render() {
-        const { dependencies, exportMode, facadeModule, inputOptions: { onwarn }, outputOptions, pluginDriver, snippets } = this;
+        const { dependencies, exportMode, facadeModule, inputOptions: { onLog }, outputOptions, pluginDriver, snippets } = this;
         const { format, hoistTransitiveImports, preserveModules } = outputOptions;
         // for static and dynamic entry points, add transitive dependencies to this
         // chunk's dependencies to avoid loading latency
@@ -15216,8 +15346,8 @@ class Chunk {
             intro,
             isEntryFacade: preserveModules || (facadeModule !== null && facadeModule.info.isEntry),
             isModuleFacade: facadeModule !== null,
+            log: onLog,
             namedExportsMode: exportMode !== 'default',
-            onwarn,
             outro,
             snippets,
             usesTopLevelAwait
@@ -15272,7 +15402,7 @@ class Chunk {
                 if (alternativeReexportModule) {
                     const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
                     if (exportingChunk !== exportChunk) {
-                        this.inputOptions.onwarn(errorCyclicCrossChunkReexport(
+                        this.inputOptions.onLog(LOGLEVEL_WARN, logCyclicCrossChunkReexport(
                         // Namespaces do not have an export name
                         variableModule.getExportNamesByVariable().get(variable)?.[0] || '*', variableModule.id, alternativeReexportModule.id, importingModule.id, this.outputOptions.preserveModules));
                     }
@@ -15460,7 +15590,7 @@ class Chunk {
                 dependency = this.externalChunkByModule.get(module);
                 imported = variable.name;
                 if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
-                    return error(errorUnexpectedNamedImport(module.id, imported, false));
+                    return error(logUnexpectedNamedImport(module.id, imported, false));
                 }
             }
             else {
@@ -15550,7 +15680,7 @@ class Chunk {
             if (exportName[0] === '*') {
                 const id = exportName.slice(1);
                 if (interop(id) === 'defaultOnly') {
-                    this.inputOptions.onwarn(errorUnexpectedNamespaceReexport(id));
+                    this.inputOptions.onLog(LOGLEVEL_WARN, logUnexpectedNamespaceReexport(id));
                 }
                 needsLiveBinding = externalLiveBindings;
                 dependency = this.externalChunkByModule.get(this.modulesById.get(id));
@@ -15572,7 +15702,7 @@ class Chunk {
                     dependency = this.externalChunkByModule.get(module);
                     imported = variable.name;
                     if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
-                        return error(errorUnexpectedNamedImport(module.id, imported, true));
+                        return error(logUnexpectedNamedImport(module.id, imported, true));
                     }
                     needsLiveBinding =
                         externalLiveBindings &&
@@ -15617,7 +15747,7 @@ class Chunk {
                 defaultVariableName: dep.defaultVariableName,
                 globalName: dep instanceof ExternalChunk &&
                     (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
-                    getGlobalName(dep, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onwarn),
+                    getGlobalName(dep, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
                 importPath,
                 imports,
                 isChunk: dep instanceof Chunk,
@@ -15641,7 +15771,7 @@ class Chunk {
     }
     // This method changes properties on the AST before rendering and must not be async
     renderModules(fileName) {
-        const { accessedGlobalsByScope, dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onwarn }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
+        const { accessedGlobalsByScope, dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onLog }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
         const { compact, dynamicImportFunction, format, freeze, namespaceToStringTag } = outputOptions;
         const { _, cnst, n } = snippets;
         this.setDynamicImportResolutions(fileName);
@@ -15714,7 +15844,7 @@ class Chunk {
         }
         const renderedSource = compact ? magicString : magicString.trim();
         if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
-            onwarn(errorEmptyChunk(this.getChunkName()));
+            onLog(LOGLEVEL_WARN, logEmptyChunk(this.getChunkName()));
         }
         return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
     }
@@ -16003,15 +16133,18 @@ function* concatLazy(iterables) {
  * those chunks that are already loaded for that dynamic entry and create
  * another round of chunks.
  */
-function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log) {
     const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
     const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
     // Each chunk is identified by its position in this array
-    const initialChunks = Object.values(getChunksBySignature(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks)));
+    const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
     // This mutates initialChunks but also clears
     // dynamicallyDependentEntriesByDynamicEntry as side effect
     removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...createChunks(allEntries, getChunksBySignature(initialChunks), minChunkSize));
+    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize, log).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
     return chunkDefinitions;
 }
 function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
@@ -16117,7 +16250,7 @@ function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule,
     }
     return dynamicallyDependentEntriesByDynamicEntry;
 }
-function getChunksBySignature(modulesWithDependentEntries) {
+function getChunksFromDependentEntries(modulesWithDependentEntries) {
     var _a;
     const chunkModules = Object.create(null);
     for (const { dependentEntries, modules } of modulesWithDependentEntries) {
@@ -16130,7 +16263,7 @@ function getChunksBySignature(modulesWithDependentEntries) {
             modules: []
         })).modules.push(...modules);
     }
-    return chunkModules;
+    return Object.values(chunkModules);
 }
 function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
     for (const [module, dependentEntries] of dependentEntriesByModule) {
@@ -16188,17 +16321,6 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
         chunkMask <<= 1n;
     }
 }
-function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
-    return minChunkSize === 0
-        ? Object.values(chunkModulesBySignature).map(({ modules }) => ({
-            alias: null,
-            modules
-        }))
-        : getOptimizedChunks(chunkModulesBySignature, allEntries.length, minChunkSize).map(({ modules }) => ({
-            alias: null,
-            modules
-        }));
-}
 /**
  * This function tries to get rid of small chunks by merging them with other
  * chunks.
@@ -16241,239 +16363,270 @@ function createChunks(allEntries, chunkModulesBySignature, minChunkSize) {
  * dependency side effects are AF.
  * For entry chunks, dependency and correlated side effects are the same.
  *
- * With these concepts, merging chunks is allowed if the correlated side effects
- * of each entry do not change. Thus, we are allowed to merge two chunks if
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
  * a) the dependency side effects of each chunk are a subset of the correlated
  *    side effects of the other chunk, so no additional side effects are
  *    triggered for any entry, or
- * b) The signature of chunk A is a subset of the signature of chunk B while the
- *    dependency side effects of A are a subset of the correlated side effects
- *    of B. Because in that scenario, whenever A is loaded, B is loaded as well.
- *    But there are cases when B is loaded where A is not loaded. So if we merge
- *    the chunks, all dependency side effects of A will be added to the
- *    correlated side effects of B, and as the latter is not allowed to change,
- *    the former need to be a subset of the latter.
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
  *
- * Another consideration when merging small chunks into other chunks is to avoid
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
  * that too much additional code is loaded. This is achieved when the dependent
- * entries of the small chunk are a subset of the dependent entries of the other
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
  * chunk. Because then when the small chunk is loaded, the other chunk was
  * loaded/in memory anyway, so at most when the other chunk is loaded, the
  * additional size of the small chunk is loaded unnecessarily.
  *
  * So the algorithm performs merges in two passes:
+ *
  * 1. First we try to merge small chunks A only into other chunks B if the
  *    dependent entries of A are a subset of the dependent entries of B and the
  *    dependency side effects of A are a subset of the correlated side effects
  *    of B.
  * 2. Only then for all remaining small chunks, we look for arbitrary merges
- *    following the above rules (a) and (b), starting with the smallest chunks
- *    to look for possible merge targets.
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
  */
-// TODO instead of picking the "closest" chunk, we could actually use a
-//  technique similar to what we do for side effects to compare the size of the
-//  static dependencies that are not part of the correlated dependencies
-function getOptimizedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize, log) {
     timeStart('optimize chunks', 3);
-    const chunkPartition = getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize);
-    console.log('Before eliminating small chunks, there were\n', Object.keys(chunkModulesBySignature).length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
-    if (chunkPartition.small.size > 0) {
-        mergeChunks(chunkPartition, minChunkSize);
-    }
-    console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
+    const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return initialChunks; // the actual modules
+    }
+    minChunkSize > 1 &&
+        log('info', logOptimizeChunkStatus(initialChunks.length, chunkPartition.small.size, 'Initially'));
+    mergeChunks(chunkPartition, minChunkSize);
+    minChunkSize > 1 &&
+        log('info', logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
-function getPartitionedChunks(chunkModulesBySignature, numberOfEntries, minChunkSize) {
+function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
     const smallChunks = [];
     const bigChunks = [];
     const chunkByModule = new Map();
-    const sideEffectsByEntry = [];
-    for (let index = 0; index < numberOfEntries; index++) {
-        sideEffectsByEntry.push(new Set());
-    }
-    for (const [signature, { dependentEntries, modules }] of Object.entries(chunkModulesBySignature)) {
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let containedAtoms = 1n;
+    for (const { dependentEntries, modules } of initialChunks) {
         const chunkDescription = {
-            correlatedSideEffects: new Set(),
+            containedAtoms,
+            correlatedAtoms: 0n,
             dependencies: new Set(),
             dependentChunks: new Set(),
             dependentEntries,
             modules,
             pure: true,
-            sideEffects: new Set(),
             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;
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure && (pure = !module.hasEffects());
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                size += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
         }
         chunkDescription.pure = pure;
         chunkDescription.size = size;
+        sizeByAtom.push(size);
         if (!pure) {
-            for (const entryIndex of dependentEntries) {
-                sideEffectsByEntry[entryIndex].add(signature);
-            }
-            // In the beginning, each chunk is only its own side effect. After
-            // merging, additional side effects can accumulate.
-            chunkDescription.sideEffects.add(signature);
+            sideEffectAtoms |= containedAtoms;
         }
         (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
+        containedAtoms <<= 1n;
     }
-    sortChunksAndAddDependenciesAndEffects([bigChunks, smallChunks], chunkByModule, sideEffectsByEntry);
+    // If there are no small chunks, we will not optimize
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
     return {
         big: new Set(bigChunks),
+        sideEffectAtoms,
+        sizeByAtom,
         small: new Set(smallChunks)
     };
 }
-function sortChunksAndAddDependenciesAndEffects(chunkLists, chunkByModule, sideEffectsByEntry) {
+function mergeChunks(chunkPartition, minChunkSize) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure && (bestTargetChunk.pure = pure);
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
+    const signatureByExternalModule = new Map();
+    let sideEffectAtoms = 0n;
+    const atomsByEntry = [];
+    for (let index = 0; index < numberOfEntries; index++) {
+        atomsByEntry.push(0n);
+    }
     for (const chunks of chunkLists) {
         chunks.sort(compareChunkSize);
         for (const chunk of chunks) {
-            const { dependencies, modules, correlatedSideEffects, dependentEntries } = chunk;
+            const { dependencies, dependentEntries, modules } = chunk;
             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);
-                    }
-                }
-            }
-            let firstEntry = true;
-            // Correlated side effects is the intersection of all entry side effects
-            for (const entryIndex of dependentEntries) {
-                const entryEffects = sideEffectsByEntry[entryIndex];
-                if (firstEntry) {
-                    for (const sideEffect of entryEffects) {
-                        correlatedSideEffects.add(sideEffect);
+                    if (dependency instanceof ExternalModule) {
+                        if (dependency.info.moduleSideEffects) {
+                            chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
+                                const signature = nextAtomSignature;
+                                nextAtomSignature <<= 1n;
+                                sideEffectAtoms |= signature;
+                                return signature;
+                            });
+                        }
                     }
-                    firstEntry = false;
-                }
-                else {
-                    for (const sideEffect of correlatedSideEffects) {
-                        if (!entryEffects.has(sideEffect)) {
-                            correlatedSideEffects.delete(sideEffect);
+                    else {
+                        const dependencyChunk = chunkByModule.get(dependency);
+                        if (dependencyChunk && dependencyChunk !== chunk) {
+                            dependencies.add(dependencyChunk);
+                            dependencyChunk.dependentChunks.add(chunk);
                         }
                     }
                 }
             }
+            const { containedAtoms } = chunk;
+            for (const entryIndex of dependentEntries) {
+                atomsByEntry[entryIndex] |= containedAtoms;
+            }
         }
     }
-}
-function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-    return sizeA - sizeB;
-}
-function mergeChunks(chunkPartition, minChunkSize) {
-    for (const allowArbitraryMerges of [false, true]) {
-        for (const mergedChunk of chunkPartition.small) {
-            let closestChunk = null;
-            let closestChunkDistance = Infinity;
-            const { modules, pure, size } = mergedChunk;
-            for (const targetChunk of concatLazy([chunkPartition.small, chunkPartition.big])) {
-                if (mergedChunk === targetChunk)
-                    continue;
-                // If both chunks are small, we also allow for unrelated merges during
-                // the first pass
-                const onlySubsetMerge = !allowArbitraryMerges && targetChunk.size >= minChunkSize;
-                const distance = getChunkEntryDistance(mergedChunk, targetChunk, onlySubsetMerge);
-                if (distance < closestChunkDistance &&
-                    isValidMerge(mergedChunk, targetChunk, onlySubsetMerge)) {
-                    closestChunk = targetChunk;
-                    closestChunkDistance = distance;
-                }
-            }
-            if (closestChunk) {
-                chunkPartition.small.delete(mergedChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).delete(closestChunk);
-                closestChunk.modules.push(...modules);
-                closestChunk.size += size;
-                closestChunk.pure && (closestChunk.pure = pure);
-                const { correlatedSideEffects, dependencies, dependentChunks, dependentEntries, sideEffects } = closestChunk;
-                for (const sideEffect of correlatedSideEffects) {
-                    if (!mergedChunk.correlatedSideEffects.has(sideEffect)) {
-                        correlatedSideEffects.delete(sideEffect);
-                    }
-                }
-                for (const entry of mergedChunk.dependentEntries) {
-                    dependentEntries.add(entry);
-                }
-                for (const sideEffect of mergedChunk.sideEffects) {
-                    sideEffects.add(sideEffect);
-                }
-                for (const dependency of mergedChunk.dependencies) {
-                    dependencies.add(dependency);
-                    dependency.dependentChunks.delete(mergedChunk);
-                    dependency.dependentChunks.add(closestChunk);
-                }
-                for (const dependentChunk of mergedChunk.dependentChunks) {
-                    dependentChunks.add(dependentChunk);
-                    dependentChunk.dependencies.delete(mergedChunk);
-                    dependentChunk.dependencies.add(closestChunk);
-                }
-                dependencies.delete(closestChunk);
-                dependentChunks.delete(closestChunk);
-                getChunksInPartition(closestChunk, minChunkSize, chunkPartition).add(closestChunk);
+    for (const chunks of chunkLists) {
+        for (const chunk of chunks) {
+            const { dependentEntries } = chunk;
+            // Correlated atoms are the intersection of all entry atoms
+            chunk.correlatedAtoms = -1n;
+            for (const entryIndex of dependentEntries) {
+                chunk.correlatedAtoms &= atomsByEntry[entryIndex];
             }
         }
     }
+    return sideEffectAtoms;
 }
-// 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, onlySubsetMerge) {
-    return !(hasTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, true) ||
-        hasTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, !onlySubsetMerge));
-}
-function hasTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, checkSideEffects) {
-    const { correlatedSideEffects } = dependencyChunk;
-    if (checkSideEffects) {
-        for (const sideEffect of dependentChunk.sideEffects) {
-            if (!correlatedSideEffects.has(sideEffect)) {
-                return true;
-            }
+function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
         }
     }
+    return bestTargetChunk;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * 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 getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
     const chunksToCheck = new Set(dependentChunk.dependencies);
-    for (const { dependencies, sideEffects } of chunksToCheck) {
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
         for (const dependency of dependencies) {
             if (dependency === dependencyChunk) {
-                return true;
+                return Infinity;
             }
             chunksToCheck.add(dependency);
         }
-        if (checkSideEffects) {
-            for (const sideEffect of sideEffects) {
-                if (!correlatedSideEffects.has(sideEffect)) {
-                    return true;
-                }
-            }
-        }
     }
-    return false;
-}
-function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
 }
-function getChunkEntryDistance({ dependentEntries: sourceEntries }, { dependentEntries: targetEntries }, enforceSubest) {
-    let distance = 0;
-    for (const entryIndex of targetEntries) {
-        if (!sourceEntries.has(entryIndex)) {
-            distance++;
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
         }
-    }
-    for (const entryIndex of sourceEntries) {
-        if (!targetEntries.has(entryIndex)) {
-            if (enforceSubest) {
-                return Infinity;
-            }
-            distance++;
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
         }
     }
-    return distance;
+    return size;
 }
 
 // ported from https://github.com/substack/node-commondir
@@ -16666,7 +16819,7 @@ class Link {
                         sourcesContent[sourceIndex] = content;
                     }
                     else if (content != null && sourcesContent[sourceIndex] !== content) {
-                        return error(errorConflictingSourcemapSources(filename));
+                        return error(logConflictingSourcemapSources(filename));
                     }
                     const tracedSegment = [segment[0], sourceIndex, line, column];
                     if (name) {
@@ -16716,12 +16869,12 @@ class Link {
         return null;
     }
 }
-function getLinkMap(warn) {
+function getLinkMap(log) {
     return function linkMap(source, map) {
         if (map.mappings) {
             return new Link(map, [source]);
         }
-        warn(errorSourcemapBroken(map.plugin));
+        log(LOGLEVEL_WARN, logSourcemapBroken(map.plugin));
         return new Link({
             mappings: [],
             names: []
@@ -16743,8 +16896,8 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
     }
     return sourcemapChain.reduce(linkMap, source);
 }
-function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, warn) {
-    const linkMap = getLinkMap(warn);
+function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, log) {
+    const linkMap = getLinkMap(log);
     const moduleSources = modules
         .filter(module => !module.excludeFromSourcemap)
         .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
@@ -16759,11 +16912,11 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     sourcesContent = (excludeContent ? null : sourcesContent);
     return new SourceMap({ file, mappings, names, sources, sourcesContent });
 }
-function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn) {
+function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log) {
     if (sourcemapChain.length === 0) {
         return originalSourcemap;
     }
-    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(warn));
+    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(log));
     const map = source.traceMappings();
     return { version: 3, ...map };
 }
@@ -16788,14 +16941,14 @@ function decodedSourcemap(map) {
     return { ...map, mappings };
 }
 
-async function renderChunks(chunks, bundle, pluginDriver, outputOptions, onwarn) {
+async function renderChunks(chunks, bundle, pluginDriver, outputOptions, log) {
     timeStart('render chunks', 2);
     reserveEntryChunksInBundle(chunks);
     const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
     timeEnd('render chunks', 2);
     timeStart('transform chunks', 2);
     const chunkGraph = getChunkGraph(chunks);
-    const { nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn);
+    const { nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log);
     const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, bundle);
     addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
     timeEnd('transform chunks', 2);
@@ -16814,7 +16967,7 @@ function getChunkGraph(chunks) {
         return [renderedChunkInfo.fileName, renderedChunkInfo];
     }));
 }
-async function transformChunk(magicString, fileName, usedModules, chunkGraph, options, outputPluginDriver, onwarn) {
+async function transformChunk(magicString, fileName, usedModules, chunkGraph, options, outputPluginDriver, log) {
     let map = null;
     const sourcemapChain = [];
     let code = await outputPluginDriver.hookReduceArg0('renderChunk', [magicString.toString(), chunkGraph[fileName], options, { chunks: chunkGraph }], (code, result, plugin) => {
@@ -16845,13 +16998,13 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         else
             resultingFile = resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
-        map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, onwarn);
+        map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, log);
         for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
             let sourcePath = map.sources[sourcesIndex];
             const sourcemapPath = `${resultingFile}.map`;
             const ignoreList = sourcemapIgnoreList(sourcePath, sourcemapPath);
             if (typeof ignoreList !== 'boolean') {
-                error(errorFailedValidation('sourcemapIgnoreList function must return a boolean.'));
+                error(logFailedValidation('sourcemapIgnoreList function must return a boolean.'));
             }
             if (ignoreList) {
                 if (map.x_google_ignoreList === undefined) {
@@ -16864,7 +17017,7 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
             if (sourcemapPathTransform) {
                 sourcePath = sourcemapPathTransform(sourcePath, sourcemapPath);
                 if (typeof sourcePath !== 'string') {
-                    error(errorFailedValidation(`sourcemapPathTransform function must return a string.`));
+                    error(logFailedValidation(`sourcemapPathTransform function must return a string.`));
                 }
             }
             map.sources[sourcesIndex] = normalize(sourcePath);
@@ -16876,7 +17029,7 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         map
     };
 }
-async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn) {
+async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log) {
     const nonHashedChunksWithPlaceholders = [];
     const renderedChunksByPlaceholder = new Map();
     const hashDependenciesByPlaceholder = new Map();
@@ -16889,7 +17042,7 @@ async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGrap
         const transformedChunk = {
             chunk,
             fileName,
-            ...(await transformChunk(magicString, fileName, usedModules, chunkGraph, outputOptions, pluginDriver, onwarn))
+            ...(await transformChunk(magicString, fileName, usedModules, chunkGraph, outputOptions, pluginDriver, log))
         };
         const { code } = transformedChunk;
         if (hashPlaceholder) {
@@ -17006,14 +17159,14 @@ class Bundle {
             const getHashPlaceholder = getHashPlaceholderGenerator();
             const chunks = await this.generateChunks(outputBundle, getHashPlaceholder);
             if (chunks.length > 1) {
-                validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onwarn);
+                validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onLog);
             }
             this.pluginDriver.setChunkInformation(this.facadeChunkByModule);
             for (const chunk of chunks) {
                 chunk.generateExports();
             }
             timeEnd('generate chunks', 2);
-            await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onwarn);
+            await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onLog);
         }
         catch (error_) {
             await this.pluginDriver.hookParallel('renderError', [error_]);
@@ -17076,7 +17229,7 @@ class Bundle {
                         });
                     }
                     catch (error_) {
-                        this.inputOptions.onwarn(errorChunkInvalid(file, error_));
+                        this.inputOptions.onLog(LOGLEVEL_WARN, logChunkInvalid(file, error_));
                     }
                 }
             }
@@ -17098,7 +17251,7 @@ class Bundle {
             ? [{ alias: null, modules: includedModules }]
             : preserveModules
                 ? includedModules.map(module => ({ alias: null, modules: [module] }))
-                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize)) {
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog)) {
             sortByExecutionOrder(modules);
             const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
             chunks.push(chunk);
@@ -17113,15 +17266,15 @@ class Bundle {
         return [...chunks, ...facades];
     }
 }
-function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
+function validateOptionsForMultiChunkOutput(outputOptions, log) {
     if (outputOptions.format === 'umd' || outputOptions.format === 'iife')
-        return error(errorInvalidOption('output.format', URL_OUTPUT_FORMAT, 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
+        return error(logInvalidOption('output.format', URL_OUTPUT_FORMAT, 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
     if (typeof outputOptions.file === 'string')
-        return error(errorInvalidOption('output.file', URL_OUTPUT_DIR, 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
+        return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
     if (outputOptions.sourcemapFile)
-        return error(errorInvalidOption('output.sourcemapFile', URL_OUTPUT_SOURCEMAPFILE, '"output.sourcemapFile" is only supported for single-file builds'));
+        return error(logInvalidOption('output.sourcemapFile', URL_OUTPUT_SOURCEMAPFILE, '"output.sourcemapFile" is only supported for single-file builds'));
     if (!outputOptions.amd.autoId && outputOptions.amd.id)
-        onWarn(errorInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
+        log(LOGLEVEL_WARN, logInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
 }
 function getIncludedModules(modulesById) {
     const includedModules = [];
@@ -17154,7 +17307,7 @@ function getExternalChunkByModule(modulesById, outputOptions, inputBase) {
 function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
     const existingAlias = manualChunkAliasByEntry.get(module);
     if (typeof existingAlias === 'string' && existingAlias !== alias) {
-        return error(errorCannotAssignModuleToChunk(module.id, alias, existingAlias));
+        return error(logCannotAssignModuleToChunk(module.id, alias, existingAlias));
     }
     manualChunkAliasByEntry.set(module, alias);
 }
@@ -22938,9 +23091,9 @@ const NO_CACHE = {
 function uncacheablePluginError(pluginName) {
     if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
         pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
-        return error(errorAnonymousPluginCache());
+        return error(logAnonymousPluginCache());
     }
-    return error(errorDuplicatePluginName(pluginName));
+    return error(logDuplicatePluginName(pluginName));
 }
 function getCacheForUncacheablePlugin(pluginName) {
     return {
@@ -22959,7 +23112,154 @@ function getCacheForUncacheablePlugin(pluginName) {
     };
 }
 
-async function transform(source, module, pluginDriver, warn) {
+async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}
+
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+    const { onwarn, onLog } = config;
+    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+    if (onLog) {
+        const minimalPriority = logLevelPriority[logLevel];
+        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+            if (level === LOGLEVEL_ERROR) {
+                return error(normalizeLog(handledLog));
+            }
+            if (logLevelPriority[level] >= minimalPriority) {
+                defaultOnLog(level, normalizeLog(handledLog));
+            }
+        });
+    }
+    return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn
+    ? (level, log) => {
+        if (level === LOGLEVEL_WARN) {
+            onwarn(addLogToString(log), warning => printLog(LOGLEVEL_WARN, normalizeLog(warning)));
+        }
+        else {
+            printLog(level, log);
+        }
+    }
+    : printLog;
+const addLogToString = (log) => {
+    Object.defineProperty(log, 'toString', {
+        value: () => getExtendedLogMessage(log),
+        writable: true
+    });
+    return log;
+};
+const normalizeLog = (log) => typeof log === 'string'
+    ? { message: log }
+    : typeof log === 'function'
+        ? normalizeLog(log())
+        : log;
+const getExtendedLogMessage = (log) => {
+    let prefix = '';
+    if (log.plugin) {
+        prefix += `(${log.plugin} plugin) `;
+    }
+    if (log.loc) {
+        prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
+    }
+    return prefix + log.message;
+};
+const defaultPrintLog = (level, log) => {
+    const message = getExtendedLogMessage(log);
+    switch (level) {
+        case LOGLEVEL_WARN: {
+            return console.warn(message);
+        }
+        case LOGLEVEL_DEBUG: {
+            return console.debug(message);
+        }
+        default: {
+            return console.info(message);
+        }
+    }
+};
+function warnUnknownOptions(passedOptions, validOptions, optionType, log, ignoredKeys = /$./) {
+    const validOptionSet = new Set(validOptions);
+    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
+    if (unknownOptions.length > 0) {
+        log(LOGLEVEL_WARN, logUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
+    }
+}
+const treeshakePresets = {
+    recommended: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: false
+    },
+    safest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: true,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: true
+    },
+    smallest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => false,
+        propertyReadSideEffects: false,
+        tryCatchDeoptimization: false,
+        unknownGlobalSideEffects: false
+    }
+};
+const generatedCodePresets = {
+    es2015: {
+        arrowFunctions: true,
+        constBindings: true,
+        objectShorthand: true,
+        reservedNamesAsProps: true,
+        symbols: true
+    },
+    es5: {
+        arrowFunctions: false,
+        constBindings: false,
+        objectShorthand: false,
+        reservedNamesAsProps: true,
+        symbols: false
+    }
+};
+const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
+const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
+    if (typeof value === 'string') {
+        const preset = presets[value];
+        if (preset) {
+            return preset;
+        }
+        error(logInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
+    }
+    return objectifyOption(value);
+};
+const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
+    const presetName = value?.preset;
+    if (presetName) {
+        const preset = presets[presetName];
+        if (preset) {
+            return { ...preset, ...value };
+        }
+        else {
+            error(logInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${printQuotedStringList(Object.keys(presets))}`, presetName));
+        }
+    }
+    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
+};
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+async function transform(source, module, pluginDriver, log) {
     const id = module.id;
     const sourcemapChain = [];
     let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
@@ -22981,7 +23281,7 @@ async function transform(source, module, pluginDriver, warn) {
             module.updateOptions(result);
             if (result.code == null) {
                 if (result.map || result.ast) {
-                    warn(errorNoTransformMapOrAstWithoutCode(plugin.name));
+                    log(LOGLEVEL_WARN, logNoTransformMapOrAstWithoutCode(plugin.name));
                 }
                 return previousCode;
             }
@@ -23000,6 +23300,14 @@ async function transform(source, module, pluginDriver, warn) {
         }
         return code;
     }
+    const getLogHandler = (handler) => (log, pos) => {
+        log = normalizeLog(log);
+        if (pos)
+            augmentCodeLocation(log, pos, currentSource, id);
+        log.id = id;
+        log.hook = 'transform';
+        handler(log);
+    };
     let code;
     try {
         code = await pluginDriver.hookReduceArg0('transform', [currentSource, id], transformReducer, (pluginContext, plugin) => {
@@ -23013,6 +23321,7 @@ async function transform(source, module, pluginDriver, warn) {
                 cache: customTransformCache
                     ? pluginContext.cache
                     : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
+                debug: getLogHandler(pluginContext.debug),
                 emitFile(emittedFile) {
                     emittedFiles.push(emittedFile);
                     return pluginDriver.emitFile(emittedFile);
@@ -23027,7 +23336,7 @@ async function transform(source, module, pluginDriver, warn) {
                     return pluginContext.error(error_);
                 },
                 getCombinedSourcemap() {
-                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn);
+                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log);
                     if (!combinedMap) {
                         const magicString = new MagicString(originalCode);
                         return magicString.generateMap({ hires: true, includeContent: true, source: id });
@@ -23042,23 +23351,16 @@ async function transform(source, module, pluginDriver, warn) {
                         sourcesContent: combinedMap.sourcesContent
                     });
                 },
+                info: getLogHandler(pluginContext.info),
                 setAssetSource() {
-                    return this.error(errorInvalidSetAssetSourceCall());
+                    return this.error(logInvalidSetAssetSourceCall());
                 },
-                warn(warning, pos) {
-                    if (typeof warning === 'string')
-                        warning = { message: warning };
-                    if (pos)
-                        augmentCodeLocation(warning, pos, currentSource, id);
-                    warning.id = id;
-                    warning.hook = 'transform';
-                    pluginContext.warn(warning);
-                }
+                warn: getLogHandler(pluginContext.warn)
             };
         });
     }
     catch (error_) {
-        return error(errorPluginError(error_, pluginName, { hook: 'transform', id }));
+        return error(logPluginError(error_, pluginName, { hook: 'transform', id }));
     }
     if (!customTransformCache && // files emitted by a transform hook need to be emitted again if the hook is skipped
         emittedFiles.length > 0)
@@ -23184,7 +23486,7 @@ class ModuleLoader {
             ? { code: source }
             : source != null && typeof source === 'object' && typeof source.code === 'string'
                 ? source
-                : error(errorBadLoader(id));
+                : error(logBadLoader(id));
         const cachedModule = this.graph.cachedModules.get(id);
         if (cachedModule &&
             !cachedModule.customTransformCache &&
@@ -23208,7 +23510,7 @@ class ModuleLoader {
         }
         else {
             module.updateOptions(sourceDescription);
-            module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options.onwarn));
+            module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options.onLog));
         }
     }
     async awaitLoadModulesPromise() {
@@ -23254,7 +23556,7 @@ class ModuleLoader {
         const existingModule = this.modulesById.get(id);
         if (existingModule instanceof Module) {
             if (importer && doAssertionsDiffer(assertions, existingModule.info.assertions)) {
-                this.options.onwarn(errorInconsistentImportAssertions(existingModule.info.assertions, assertions, id, importer));
+                this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAssertions(existingModule.info.assertions, assertions, id, importer));
             }
             await this.handleExistingModule(existingModule, isEntry, isPreload);
             return existingModule;
@@ -23303,10 +23605,10 @@ class ModuleLoader {
                 this.modulesById.set(id, externalModule);
             }
             else if (!(externalModule instanceof ExternalModule)) {
-                return error(errorInternalIdCannotBeExternal(source, importer));
+                return error(logInternalIdCannotBeExternal(source, importer));
             }
             else if (doAssertionsDiffer(externalModule.info.assertions, assertions)) {
-                this.options.onwarn(errorInconsistentImportAssertions(externalModule.info.assertions, assertions, source, importer));
+                this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAssertions(externalModule.info.assertions, assertions, source, importer));
             }
             return Promise.resolve(externalModule);
         }
@@ -23416,9 +23718,9 @@ class ModuleLoader {
     handleInvalidResolvedId(resolvedId, source, importer, assertions) {
         if (resolvedId === null) {
             if (isRelative(source)) {
-                return error(errorUnresolvedImport(source, importer));
+                return error(logUnresolvedImport(source, importer));
             }
-            this.options.onwarn(errorUnresolvedImportTreatedAsExternal(source, importer));
+            this.options.onLog(LOGLEVEL_WARN, logUnresolvedImportTreatedAsExternal(source, importer));
             return {
                 assertions,
                 external: true,
@@ -23430,7 +23732,7 @@ class ModuleLoader {
             };
         }
         else if (resolvedId.external && resolvedId.syntheticNamedExports) {
-            this.options.onwarn(errorExternalSyntheticExports(source, importer));
+            this.options.onLog(LOGLEVEL_WARN, logExternalSyntheticExports(source, importer));
         }
         return resolvedId;
     }
@@ -23438,14 +23740,14 @@ class ModuleLoader {
         const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT);
         if (resolveIdResult == null) {
             return error(implicitlyLoadedBefore === null
-                ? errorUnresolvedEntry(unresolvedId)
-                : errorUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
+                ? logUnresolvedEntry(unresolvedId)
+                : logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
         }
         if (resolveIdResult === false ||
             (typeof resolveIdResult === 'object' && resolveIdResult.external)) {
             return error(implicitlyLoadedBefore === null
-                ? errorEntryCannotBeExternal(unresolvedId)
-                : errorImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
+                ? logEntryCannotBeExternal(unresolvedId)
+                : logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
         }
         return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
             ? resolveIdResult
@@ -23470,7 +23772,7 @@ class ModuleLoader {
             const existingResolution = module.resolvedIds[specifier];
             if (existingResolution) {
                 if (doAssertionsDiffer(existingResolution.assertions, assertions)) {
-                    this.options.onwarn(errorInconsistentImportAssertions(existingResolution.assertions, assertions, specifier, importer));
+                    this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAssertions(existingResolution.assertions, assertions, specifier, importer));
                 }
                 return existingResolution;
             }
@@ -23538,18 +23840,18 @@ function generateAssetFileName(name, source, sourceHash, outputOptions, bundle)
         name: () => emittedName.slice(0, Math.max(0, emittedName.length - extname(emittedName).length))
     }), bundle);
 }
-function reserveFileNameInBundle(fileName, { bundle }, warn) {
+function reserveFileNameInBundle(fileName, { bundle }, log) {
     if (bundle[lowercaseBundleKeys].has(fileName.toLowerCase())) {
-        warn(errorFileNameConflict(fileName));
+        log(LOGLEVEL_WARN, logFileNameConflict(fileName));
     }
     else {
         bundle[fileName] = FILE_PLACEHOLDER;
     }
 }
+const emittedFileTypes = new Set(['chunk', 'asset', 'prebuilt-chunk']);
 function hasValidType(emittedFile) {
     return Boolean(emittedFile &&
-        (emittedFile.type === 'asset' ||
-            emittedFile.type === 'chunk'));
+        emittedFileTypes.has(emittedFile.type));
 }
 function hasValidName(emittedFile) {
     const validatedName = emittedFile.fileName || emittedFile.name;
@@ -23558,13 +23860,13 @@ function hasValidName(emittedFile) {
 function getValidSource(source, emittedFile, fileReferenceId) {
     if (!(typeof source === 'string' || source instanceof Uint8Array)) {
         const assetName = emittedFile.fileName || emittedFile.name || fileReferenceId;
-        return error(errorFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
+        return error(logFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
     }
     return source;
 }
 function getAssetFileName(file, referenceId) {
     if (typeof file.fileName !== 'string') {
-        return error(errorAssetNotFinalisedForFileName(file.name || referenceId));
+        return error(logAssetNotFinalisedForFileName(file.name || referenceId));
     }
     return file.fileName;
 }
@@ -23575,7 +23877,7 @@ function getChunkFileName(file, facadeChunkByModule) {
     if (facadeChunkByModule) {
         return facadeChunkByModule.get(file.module).getFileName();
     }
-    return error(errorChunkNotGeneratedForFileName(file.fileName || file.name));
+    return error(logChunkNotGeneratedForFileName(file.fileName || file.name));
 }
 class FileEmitter {
     constructor(graph, options, baseFileEmitter) {
@@ -23587,10 +23889,13 @@ class FileEmitter {
         this.outputFileEmitters = [];
         this.emitFile = (emittedFile) => {
             if (!hasValidType(emittedFile)) {
-                return error(errorFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
+                return error(logFailedValidation(`Emitted files must be of type "asset", "chunk" or "prebuilt-chunk", received "${emittedFile && emittedFile.type}".`));
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return this.emitPrebuiltChunk(emittedFile);
             }
             if (!hasValidName(emittedFile)) {
-                return error(errorFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
+                return error(logFailedValidation(`The "fileName" or "name" properties of emitted chunks and assets must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
             }
             if (emittedFile.type === 'chunk') {
                 return this.emitChunk(emittedFile);
@@ -23600,27 +23905,30 @@ class FileEmitter {
         this.finaliseAssets = () => {
             for (const [referenceId, emittedFile] of this.filesByReferenceId) {
                 if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
-                    return error(errorNoAssetSourceSet(emittedFile.name || referenceId));
+                    return error(logNoAssetSourceSet(emittedFile.name || referenceId));
             }
         };
         this.getFileName = (fileReferenceId) => {
             const emittedFile = this.filesByReferenceId.get(fileReferenceId);
             if (!emittedFile)
-                return error(errorFileReferenceIdNotFoundForFilename(fileReferenceId));
+                return error(logFileReferenceIdNotFoundForFilename(fileReferenceId));
             if (emittedFile.type === 'chunk') {
                 return getChunkFileName(emittedFile, this.facadeChunkByModule);
             }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return emittedFile.fileName;
+            }
             return getAssetFileName(emittedFile, fileReferenceId);
         };
         this.setAssetSource = (referenceId, requestedSource) => {
             const consumedFile = this.filesByReferenceId.get(referenceId);
             if (!consumedFile)
-                return error(errorAssetReferenceIdNotFoundForSetSource(referenceId));
+                return error(logAssetReferenceIdNotFoundForSetSource(referenceId));
             if (consumedFile.type !== 'asset') {
-                return error(errorFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
+                return error(logFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
             }
             if (consumedFile.source !== undefined) {
-                return error(errorAssetSourceAlreadySet(consumedFile.name || referenceId));
+                return error(logAssetSourceAlreadySet(consumedFile.name || referenceId));
             }
             const source = getValidSource(requestedSource, consumedFile, referenceId);
             if (this.output) {
@@ -23644,7 +23952,7 @@ class FileEmitter {
             });
             for (const emittedFile of this.filesByReferenceId.values()) {
                 if (emittedFile.fileName) {
-                    reserveFileNameInBundle(emittedFile.fileName, output, this.options.onwarn);
+                    reserveFileNameInBundle(emittedFile.fileName, output, this.options.onLog);
                 }
             }
             const consumedAssetsByHash = new Map();
@@ -23658,6 +23966,9 @@ class FileEmitter {
                         getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
                     }
                 }
+                else if (consumedFile.type === 'prebuilt-chunk') {
+                    this.output.bundle[consumedFile.fileName] = this.createPrebuiltChunk(consumedFile);
+                }
             }
             for (const [sourceHash, consumedFiles] of consumedAssetsByHash) {
                 this.finalizeAssetsWithSameSource(consumedFiles, sourceHash, output);
@@ -23684,6 +23995,27 @@ class FileEmitter {
         }
         return referenceId;
     }
+    createPrebuiltChunk(prebuiltChunk) {
+        return {
+            code: prebuiltChunk.code,
+            dynamicImports: [],
+            exports: prebuiltChunk.exports || [],
+            facadeModuleId: null,
+            fileName: prebuiltChunk.fileName,
+            implicitlyLoadedBefore: [],
+            importedBindings: {},
+            imports: [],
+            isDynamicEntry: false,
+            isEntry: false,
+            isImplicitEntry: false,
+            map: prebuiltChunk.map || null,
+            moduleIds: [],
+            modules: {},
+            name: prebuiltChunk.fileName,
+            referencedFiles: [],
+            type: 'chunk'
+        };
+    }
     emitAsset(emittedAsset) {
         const source = emittedAsset.source === undefined
             ? undefined
@@ -23710,7 +24042,7 @@ class FileEmitter {
     emitAssetWithReferenceId(consumedAsset, output) {
         const { fileName, source } = consumedAsset;
         if (fileName) {
-            reserveFileNameInBundle(fileName, output, this.options.onwarn);
+            reserveFileNameInBundle(fileName, output, this.options.onLog);
         }
         if (source !== undefined) {
             this.finalizeAdditionalAsset(consumedAsset, source, output);
@@ -23718,10 +24050,10 @@ class FileEmitter {
     }
     emitChunk(emittedChunk) {
         if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
-            return error(errorInvalidRollupPhaseForChunkEmission());
+            return error(logInvalidRollupPhaseForChunkEmission());
         }
         if (typeof emittedChunk.id !== 'string') {
-            return error(errorFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+            return error(logFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
         }
         const consumedChunk = {
             fileName: emittedChunk.fileName,
@@ -23739,6 +24071,29 @@ class FileEmitter {
         });
         return this.assignReferenceId(consumedChunk, emittedChunk.id);
     }
+    emitPrebuiltChunk(emitPrebuiltChunk) {
+        if (typeof emitPrebuiltChunk.code !== 'string') {
+            return error(logFailedValidation(`Emitted prebuilt chunks need to have a valid string code, received "${emitPrebuiltChunk.code}".`));
+        }
+        if (typeof emitPrebuiltChunk.fileName !== 'string' ||
+            isPathFragment(emitPrebuiltChunk.fileName)) {
+            return error(logFailedValidation(`The "fileName" property of emitted prebuilt chunks must be strings that are neither absolute nor relative paths, received "${emitPrebuiltChunk.fileName}".`));
+        }
+        const consumedPrebuiltChunk = {
+            code: emitPrebuiltChunk.code,
+            exports: emitPrebuiltChunk.exports,
+            fileName: emitPrebuiltChunk.fileName,
+            map: emitPrebuiltChunk.map,
+            referenceId: '',
+            type: 'prebuilt-chunk'
+        };
+        const referenceId = this.assignReferenceId(consumedPrebuiltChunk, consumedPrebuiltChunk.fileName);
+        if (this.output) {
+            this.output.bundle[consumedPrebuiltChunk.fileName] =
+                this.createPrebuiltChunk(consumedPrebuiltChunk);
+        }
+        return referenceId;
+    }
     finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, outputOptions }) {
         let { fileName, needsCodeReference, referenceId } = consumedFile;
         // Deduplicate assets if an explicit fileName is not provided
@@ -23797,7 +24152,26 @@ class FileEmitter {
     }
 }
 
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+    if (logLevelPriority[level] < logLevelPriority[logLevel]) {
+        return doNothing;
+    }
+    return (log, pos) => {
+        if (pos != null) {
+            logger(LOGLEVEL_WARN, logInvalidLogPosition(pluginName));
+        }
+        log = normalizeLog(log);
+        if (log.code && !log.pluginCode) {
+            log.pluginCode = log.code;
+        }
+        log.code = code;
+        log.plugin = pluginName;
+        logger(level, log);
+    };
+}
+
 function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, existingPluginNames) {
+    const { logLevel, onLog } = options;
     let cacheable = true;
     if (typeof plugin.cacheKey !== 'string') {
         if (plugin.name.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
@@ -23823,19 +24197,21 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     return {
         addWatchFile(id) {
             if (graph.phase >= BuildPhase.GENERATE) {
-                return this.error(errorInvalidRollupPhaseForAddWatchFile());
+                return this.error(logInvalidRollupPhaseForAddWatchFile());
             }
             graph.watchFiles[id] = true;
         },
         cache: cacheInstance,
+        debug: getLogHandler(LOGLEVEL_DEBUG, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
         emitFile: fileEmitter.emitFile.bind(fileEmitter),
         error(error_) {
-            return error(errorPluginError(error_, plugin.name));
+            return error(logPluginError(normalizeLog(error_), plugin.name));
         },
         getFileName: fileEmitter.getFileName,
         getModuleIds: () => graph.modulesById.keys(),
         getModuleInfo: graph.getModuleInfo,
         getWatchFiles: () => Object.keys(graph.watchFiles),
+        info: getLogHandler(LOGLEVEL_INFO, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
         load(resolvedId) {
             return graph.moduleLoader.preloadModule(resolvedId);
         },
@@ -23857,15 +24233,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             return graph.moduleLoader.resolveId(source, importer, custom, isEntry, assertions || EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
         },
         setAssetSource: fileEmitter.setAssetSource,
-        warn(warning) {
-            if (typeof warning === 'string')
-                warning = { message: warning };
-            if (warning.code)
-                warning.pluginCode = warning.code;
-            warning.code = 'PLUGIN_WARNING';
-            warning.plugin = plugin.name;
-            options.onwarn(warning);
-        }
+        warn: getLogHandler(LOGLEVEL_WARN, 'PLUGIN_WARNING', onLog, plugin.name, logLevel)
     };
 }
 
@@ -23877,6 +24245,7 @@ const inputHookNames = {
     closeWatcher: 1,
     load: 1,
     moduleParsed: 1,
+    onLog: 1,
     options: 1,
     resolveDynamicImport: 1,
     resolveId: 1,
@@ -23908,7 +24277,7 @@ class PluginDriver {
             for (const plugin of userPlugins) {
                 for (const hook of inputHooks) {
                     if (hook in plugin) {
-                        options.onwarn(errorInputHookInOutputPlugin(plugin.name, hook));
+                        options.onLog(LOGLEVEL_WARN, logInputHookInOutputPlugin(plugin.name, hook));
                     }
                 }
             }
@@ -24055,7 +24424,7 @@ class PluginDriver {
                 // action considered to be fulfilled since error being handled
                 this.unfulfilledActions.delete(action);
             }
-            return error(errorPluginError(error_, plugin.name, { hook: hookName }));
+            return error(logPluginError(error_, plugin.name, { hook: hookName }));
         });
     }
     /**
@@ -24077,7 +24446,7 @@ class PluginDriver {
             return handler.apply(context, parameters);
         }
         catch (error_) {
-            return error(errorPluginError(error_, plugin.name, { hook: hookName }));
+            return error(logPluginError(error_, plugin.name, { hook: hookName }));
         }
     }
 }
@@ -24109,12 +24478,12 @@ function getSortedValidatedPlugins(hookName, plugins, validateHandler = validate
 }
 function validateFunctionPluginHandler(handler, hookName, plugin) {
     if (typeof handler !== 'function') {
-        error(errorInvalidFunctionPluginHook(hookName, plugin.name));
+        error(logInvalidFunctionPluginHook(hookName, plugin.name));
     }
 }
 function validateAddonPluginHandler(handler, hookName, plugin) {
     if (typeof handler !== 'string' && typeof handler !== 'function') {
-        return error(errorInvalidAddonPluginHook(hookName, plugin.name));
+        return error(logInvalidAddonPluginHook(hookName, plugin.name));
     }
 }
 function noReturn() { }
@@ -24326,7 +24695,7 @@ class Graph {
         for (const module of this.implicitEntryModules) {
             for (const dependant of module.implicitlyLoadedAfter) {
                 if (!(dependant.info.isEntry || dependant.isIncluded())) {
-                    error(errorImplicitDependantIsNotIncluded(dependant));
+                    error(logImplicitDependantIsNotIncluded(dependant));
                 }
             }
         }
@@ -24334,7 +24703,7 @@ class Graph {
     sortModules() {
         const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
         for (const cyclePath of cyclePaths) {
-            this.options.onwarn(errorCircularDependency(cyclePath));
+            this.options.onLog(LOGLEVEL_WARN, logCircularDependency(cyclePath));
         }
         this.modules = orderedModules;
         for (const module of this.modules) {
@@ -24347,7 +24716,7 @@ class Graph {
             for (const importDescription of module.importDescriptions.values()) {
                 if (importDescription.name !== '*' &&
                     !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
-                    module.warn(errorMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
+                    module.log(LOGLEVEL_WARN, logMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
                 }
             }
         }
@@ -24376,25 +24745,68 @@ function formatAction([pluginName, hookName, parameters]) {
     }
     return action;
 }
-// We do not directly listen on process to avoid max listeners warnings for
-// complicated build processes
-const beforeExitEvent = 'beforeExit';
-const beforeExitEmitter = new EventEmitter();
-beforeExitEmitter.setMaxListeners(0);
-process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
+let handleBeforeExit = null;
+const rejectByPluginDriver = new Map();
 async function catchUnfinishedHookActions(pluginDriver, callback) {
-    let handleEmptyEventLoop;
     const emptyEventLoopPromise = new Promise((_, reject) => {
-        handleEmptyEventLoop = () => {
-            const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
-            reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
-                [...unfulfilledActions].map(formatAction).join('\n')));
-        };
-        beforeExitEmitter.once(beforeExitEvent, handleEmptyEventLoop);
+        rejectByPluginDriver.set(pluginDriver, reject);
+        if (!handleBeforeExit) {
+            // We only ever create a single event listener to avoid max listener and
+            // other issues
+            handleBeforeExit = () => {
+                for (const [pluginDriver, reject] of rejectByPluginDriver) {
+                    const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
+                    reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
+                        [...unfulfilledActions].map(formatAction).join('\n')));
+                }
+            };
+            process$1.once('beforeExit', handleBeforeExit);
+        }
     });
-    const result = await Promise.race([callback(), emptyEventLoopPromise]);
-    beforeExitEmitter.off(beforeExitEvent, handleEmptyEventLoop);
-    return result;
+    try {
+        return await Promise.race([callback(), emptyEventLoopPromise]);
+    }
+    finally {
+        rejectByPluginDriver.delete(pluginDriver);
+        if (rejectByPluginDriver.size === 0) {
+            process$1.off('beforeExit', handleBeforeExit);
+            handleBeforeExit = null;
+        }
+    }
+}
+
+function getLogger(plugins, onLog, watchMode, logLevel) {
+    plugins = getSortedValidatedPlugins('onLog', plugins);
+    const minimalPriority = logLevelPriority[logLevel];
+    const logger = (level, log, skipped = EMPTY_SET) => {
+        const logPriority = logLevelPriority[level];
+        if (logPriority < minimalPriority) {
+            return;
+        }
+        for (const plugin of plugins) {
+            if (skipped.has(plugin))
+                continue;
+            const { onLog: pluginOnLog } = plugin;
+            const getLogHandler = (level) => {
+                if (logLevelPriority[level] < minimalPriority) {
+                    return doNothing;
+                }
+                return log => logger(level, normalizeLog(log), new Set(skipped).add(plugin));
+            };
+            const handler = 'handler' in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+            if (handler.call({
+                debug: getLogHandler(LOGLEVEL_DEBUG),
+                error: (log) => error(normalizeLog(log)),
+                info: getLogHandler(LOGLEVEL_INFO),
+                meta: { rollupVersion: version$1, watchMode },
+                warn: getLogHandler(LOGLEVEL_WARN)
+            }, level, log) === false) {
+                return;
+            }
+        }
+        onLog(level, log);
+    };
+    return logger;
 }
 
 const leftCurlyBrace = "{".charCodeAt(0);
@@ -24493,7 +24905,7 @@ function importAssertions(Parser) {
         if (this.type !== tt.string) { this.unexpected(); }
         node.source = this.parseExprAtom();
 
-        if (this.type === this.assertToken) {
+        if (this.type === this.assertToken || this.type === tt._with) {
           this.next();
           const assertions = this.parseImportAssertions();
           if (assertions) {
@@ -24537,7 +24949,7 @@ function importAssertions(Parser) {
           if (this.type !== tt.string) { this.unexpected(); }
           node.source = this.parseExprAtom();
 
-          if (this.type === this.assertToken) {
+          if (this.type === this.assertToken || this.type === tt._with) {
             this.next();
             const assertions = this.parseImportAssertions();
             if (assertions) {
@@ -24574,7 +24986,7 @@ function importAssertions(Parser) {
           this.type === tt.string ? this.parseExprAtom() : this.unexpected();
       }
 
-      if (this.type === this.assertToken) {
+      if (this.type === this.assertToken || this.type == tt._with) {
         this.next();
         const assertions = this.parseImportAssertions();
         if (assertions) {
@@ -24648,100 +25060,16 @@ function ensureArray(items) {
     return [];
 }
 
-async function asyncFlatten(array) {
-    do {
-        array = (await Promise.all(array)).flat(Infinity);
-    } while (array.some((v) => v?.then));
-    return array;
-}
-
-const defaultOnWarn = warning => console.warn(warning.message || warning);
-function warnUnknownOptions(passedOptions, validOptions, optionType, warn, ignoredKeys = /$./) {
-    const validOptionSet = new Set(validOptions);
-    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
-    if (unknownOptions.length > 0) {
-        warn(errorUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
-    }
-}
-const treeshakePresets = {
-    recommended: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: EMPTY_ARRAY,
-        moduleSideEffects: () => true,
-        propertyReadSideEffects: true,
-        tryCatchDeoptimization: true,
-        unknownGlobalSideEffects: false
-    },
-    safest: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: true,
-        manualPureFunctions: EMPTY_ARRAY,
-        moduleSideEffects: () => true,
-        propertyReadSideEffects: true,
-        tryCatchDeoptimization: true,
-        unknownGlobalSideEffects: true
-    },
-    smallest: {
-        annotations: true,
-        correctVarValueBeforeDeclaration: false,
-        manualPureFunctions: EMPTY_ARRAY,
-        moduleSideEffects: () => false,
-        propertyReadSideEffects: false,
-        tryCatchDeoptimization: false,
-        unknownGlobalSideEffects: false
-    }
-};
-const generatedCodePresets = {
-    es2015: {
-        arrowFunctions: true,
-        constBindings: true,
-        objectShorthand: true,
-        reservedNamesAsProps: true,
-        symbols: true
-    },
-    es5: {
-        arrowFunctions: false,
-        constBindings: false,
-        objectShorthand: false,
-        reservedNamesAsProps: true,
-        symbols: false
-    }
-};
-const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
-const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
-    if (typeof value === 'string') {
-        const preset = presets[value];
-        if (preset) {
-            return preset;
-        }
-        error(errorInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
-    }
-    return objectifyOption(value);
-};
-const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
-    const presetName = value?.preset;
-    if (presetName) {
-        const preset = presets[presetName];
-        if (preset) {
-            return { ...preset, ...value };
-        }
-        else {
-            error(errorInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${printQuotedStringList(Object.keys(presets))}`, presetName));
-        }
-    }
-    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
-};
-const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
-
-async function normalizeInputOptions(config) {
+async function normalizeInputOptions(config, watchMode) {
     // These are options that may trigger special warnings or behaviour later
     // if the user did not select an explicit value
     const unsetOptions = new Set();
     const context = config.context ?? 'undefined';
-    const onwarn = getOnwarn(config);
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || LOGLEVEL_INFO;
+    const onLog = getLogger(plugins, getOnLog(config, logLevel), watchMode, logLevel);
     const strictDeprecations = config.strictDeprecations || false;
-    const maxParallelFileOps = getmaxParallelFileOps(config, onwarn, strictDeprecations);
+    const maxParallelFileOps = getMaxParallelFileOps(config, onLog, strictDeprecations);
     const options = {
         acorn: getAcorn(config),
         acornInjectPlugins: getAcornInjectPlugins(config),
@@ -24750,43 +25078,28 @@ async function normalizeInputOptions(config) {
         experimentalCacheExpiry: config.experimentalCacheExpiry ?? 10,
         experimentalLogSideEffects: config.experimentalLogSideEffects || false,
         external: getIdMatcher(config.external),
-        inlineDynamicImports: getInlineDynamicImports$1(config, onwarn, strictDeprecations),
+        inlineDynamicImports: getInlineDynamicImports$1(config, onLog, strictDeprecations),
         input: getInput(config),
+        logLevel,
         makeAbsoluteExternalsRelative: config.makeAbsoluteExternalsRelative ?? 'ifRelativeSource',
-        manualChunks: getManualChunks$1(config, onwarn, strictDeprecations),
+        manualChunks: getManualChunks$1(config, onLog, strictDeprecations),
         maxParallelFileOps,
         maxParallelFileReads: maxParallelFileOps,
         moduleContext: getModuleContext(config, context),
-        onwarn,
+        onLog,
+        onwarn: warning => onLog(LOGLEVEL_WARN, warning),
         perf: config.perf || false,
-        plugins: await normalizePluginOption(config.plugins),
+        plugins,
         preserveEntrySignatures: config.preserveEntrySignatures ?? 'exports-only',
-        preserveModules: getPreserveModules$1(config, onwarn, strictDeprecations),
+        preserveModules: getPreserveModules$1(config, onLog, strictDeprecations),
         preserveSymlinks: config.preserveSymlinks || false,
         shimMissingExports: config.shimMissingExports || false,
         strictDeprecations,
         treeshake: getTreeshake(config)
     };
-    warnUnknownOptions(config, [...Object.keys(options), 'watch'], 'input options', options.onwarn, /^(output)$/);
+    warnUnknownOptions(config, [...Object.keys(options), 'watch'], 'input options', onLog, /^(output)$/);
     return { options, unsetOptions };
 }
-const getOnwarn = (config) => {
-    const { onwarn } = config;
-    return onwarn
-        ? warning => {
-            warning.toString = () => {
-                let warningString = '';
-                if (warning.plugin)
-                    warningString += `(${warning.plugin} plugin) `;
-                if (warning.loc)
-                    warningString += `${relativeId(warning.loc.file)} (${warning.loc.line}:${warning.loc.column}) `;
-                warningString += warning.message;
-                return warningString;
-            };
-            onwarn(warning, defaultOnWarn);
-        }
-        : defaultOnWarn;
-};
 const getAcorn = (config) => ({
     ecmaVersion: 'latest',
     sourceType: 'module',
@@ -24821,10 +25134,10 @@ const getIdMatcher = (option) => {
     }
     return () => false;
 };
-const getInlineDynamicImports$1 = (config, warn, strictDeprecations) => {
+const getInlineDynamicImports$1 = (config, log, strictDeprecations) => {
     const configInlineDynamicImports = config.inlineDynamicImports;
     if (configInlineDynamicImports) {
-        warnDeprecationWithOptions('The "inlineDynamicImports" option is deprecated. Use the "output.inlineDynamicImports" option instead.', URL_OUTPUT_INLINEDYNAMICIMPORTS, true, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "inlineDynamicImports" option is deprecated. Use the "output.inlineDynamicImports" option instead.', URL_OUTPUT_INLINEDYNAMICIMPORTS, true, log, strictDeprecations);
     }
     return configInlineDynamicImports;
 };
@@ -24832,17 +25145,17 @@ const getInput = (config) => {
     const configInput = config.input;
     return configInput == null ? [] : typeof configInput === 'string' ? [configInput] : configInput;
 };
-const getManualChunks$1 = (config, warn, strictDeprecations) => {
+const getManualChunks$1 = (config, log, strictDeprecations) => {
     const configManualChunks = config.manualChunks;
     if (configManualChunks) {
-        warnDeprecationWithOptions('The "manualChunks" option is deprecated. Use the "output.manualChunks" option instead.', URL_OUTPUT_MANUALCHUNKS, true, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "manualChunks" option is deprecated. Use the "output.manualChunks" option instead.', URL_OUTPUT_MANUALCHUNKS, true, log, strictDeprecations);
     }
     return configManualChunks;
 };
-const getmaxParallelFileOps = (config, warn, strictDeprecations) => {
+const getMaxParallelFileOps = (config, log, strictDeprecations) => {
     const maxParallelFileReads = config.maxParallelFileReads;
     if (typeof maxParallelFileReads === 'number') {
-        warnDeprecationWithOptions('The "maxParallelFileReads" option is deprecated. Use the "maxParallelFileOps" option instead.', URL_MAXPARALLELFILEOPS, true, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "maxParallelFileReads" option is deprecated. Use the "maxParallelFileOps" option instead.', URL_MAXPARALLELFILEOPS, true, log, strictDeprecations);
     }
     const maxParallelFileOps = config.maxParallelFileOps ?? maxParallelFileReads;
     if (typeof maxParallelFileOps === 'number') {
@@ -24866,10 +25179,10 @@ const getModuleContext = (config, context) => {
     }
     return () => context;
 };
-const getPreserveModules$1 = (config, warn, strictDeprecations) => {
+const getPreserveModules$1 = (config, log, strictDeprecations) => {
     const configPreserveModules = config.preserveModules;
     if (configPreserveModules) {
-        warnDeprecationWithOptions('The "preserveModules" option is deprecated. Use the "output.preserveModules" option instead.', URL_OUTPUT_PRESERVEMODULES, true, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "preserveModules" option is deprecated. Use the "output.preserveModules" option instead.', URL_OUTPUT_PRESERVEMODULES, true, log, strictDeprecations);
     }
     return configPreserveModules;
 };
@@ -24906,7 +25219,7 @@ const getHasModuleSideEffects = (moduleSideEffectsOption) => {
         return id => ids.has(id);
     }
     if (moduleSideEffectsOption) {
-        error(errorInvalidOption('treeshake.moduleSideEffects', URL_TREESHAKE_MODULESIDEEFFECTS, 'please use one of false, "no-external", a function or an array'));
+        error(logInvalidOption('treeshake.moduleSideEffects', URL_TREESHAKE_MODULESIDEEFFECTS, 'please use one of false, "no-external", a function or an array'));
     }
     return () => true;
 };
@@ -24946,7 +25259,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: config.esModule ?? 'if-default-prop',
         experimentalDeepDynamicChunkOptimization: getExperimentalDeepDynamicChunkOptimization(config, inputOptions),
-        experimentalMinChunkSize: config.experimentalMinChunkSize || 0,
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
         exports: getExports(config, unsetOptions),
         extend: config.extend || false,
         externalImportAssertions: config.externalImportAssertions ?? true,
@@ -24992,17 +25305,17 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         systemNullSetters: config.systemNullSetters ?? true,
         validate: config.validate || false
     };
-    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onwarn);
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onLog);
     return { options: outputOptions, unsetOptions };
 }
 const getFile = (config, preserveModules, inputOptions) => {
     const { file } = config;
     if (typeof file === 'string') {
         if (preserveModules) {
-            return error(errorInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
+            return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
         }
         if (!Array.isArray(inputOptions.input))
-            return error(errorInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when providing named inputs'));
+            return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when providing named inputs'));
     }
     return file;
 };
@@ -25029,7 +25342,7 @@ const getFormat = (config) => {
             return configFormat;
         }
         default: {
-            return error(errorInvalidOption('output.format', URL_OUTPUT_FORMAT, `Valid values are "amd", "cjs", "system", "es", "iife" or "umd"`, configFormat));
+            return error(logInvalidOption('output.format', URL_OUTPUT_FORMAT, `Valid values are "amd", "cjs", "system", "es", "iife" or "umd"`, configFormat));
         }
     }
 };
@@ -25037,7 +25350,7 @@ const getInlineDynamicImports = (config, inputOptions) => {
     const inlineDynamicImports = (config.inlineDynamicImports ?? inputOptions.inlineDynamicImports) || false;
     const { input } = inputOptions;
     if (inlineDynamicImports && (Array.isArray(input) ? input : Object.keys(input)).length > 1) {
-        return error(errorInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
+        return error(logInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
     }
     return inlineDynamicImports;
 };
@@ -25045,10 +25358,10 @@ const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
     const preserveModules = (config.preserveModules ?? inputOptions.preserveModules) || false;
     if (preserveModules) {
         if (inlineDynamicImports) {
-            return error(errorInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, `this option is not supported for "output.preserveModules"`));
+            return error(logInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, `this option is not supported for "output.preserveModules"`));
         }
         if (inputOptions.preserveEntrySignatures === false) {
-            return error(errorInvalidOption('preserveEntrySignatures', URL_PRESERVEENTRYSIGNATURES, 'setting this option to false is not supported for "output.preserveModules"'));
+            return error(logInvalidOption('preserveEntrySignatures', URL_PRESERVEENTRYSIGNATURES, 'setting this option to false is not supported for "output.preserveModules"'));
         }
     }
     return preserveModules;
@@ -25076,10 +25389,10 @@ const getAmd = (config) => {
         ...config.amd
     };
     if ((mergedOption.autoId || mergedOption.basePath) && mergedOption.id) {
-        return error(errorInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
+        return error(logInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
     }
     if (mergedOption.basePath && !mergedOption.autoId) {
-        return error(errorInvalidOption('output.amd.basePath', URL_OUTPUT_AMD_BASEPATH, 'this option only works with "output.amd.autoId"'));
+        return error(logInvalidOption('output.amd.basePath', URL_OUTPUT_AMD_BASEPATH, 'this option only works with "output.amd.autoId"'));
     }
     return mergedOption.autoId
         ? {
@@ -25106,7 +25419,7 @@ const getAddon = (config, name) => {
 const getDir = (config, file) => {
     const { dir } = config;
     if (typeof dir === 'string' && typeof file === 'string') {
-        return error(errorInvalidOption('output.dir', URL_OUTPUT_DIR, 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
+        return error(logInvalidOption('output.dir', URL_OUTPUT_DIR, 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
     }
     return dir;
 };
@@ -25115,7 +25428,7 @@ const getDynamicImportFunction = (config, inputOptions, format) => {
     if (configDynamicImportFunction) {
         warnDeprecation(`The "output.dynamicImportFunction" option is deprecated. Use the "renderDynamicImport" plugin hook instead.`, URL_RENDERDYNAMICIMPORT, true, inputOptions);
         if (format !== 'es') {
-            inputOptions.onwarn(errorInvalidOption('output.dynamicImportFunction', URL_OUTPUT_DYNAMICIMPORTFUNCTION, 'this option is ignored for formats other than "es"'));
+            inputOptions.onLog(LOGLEVEL_WARN, logInvalidOption('output.dynamicImportFunction', URL_OUTPUT_DYNAMICIMPORTFUNCTION, 'this option is ignored for formats other than "es"'));
         }
     }
     return configDynamicImportFunction;
@@ -25140,7 +25453,7 @@ function getExports(config, unsetOptions) {
         unsetOptions.add('exports');
     }
     else if (!['default', 'named', 'none', 'auto'].includes(configExports)) {
-        return error(errorInvalidExportOptionValue(configExports));
+        return error(logInvalidExportOptionValue(configExports));
     }
     return configExports || 'auto';
 }
@@ -25183,7 +25496,7 @@ const getInterop = (config) => {
 };
 const validateInterop = (interop) => {
     if (!ALLOWED_INTEROP_TYPES.has(interop)) {
-        return error(errorInvalidOption('output.interop', URL_OUTPUT_INTEROP, 
+        return error(logInvalidOption('output.interop', URL_OUTPUT_INTEROP, 
         // eslint-disable-next-line unicorn/prefer-spread
         `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
     }
@@ -25193,10 +25506,10 @@ const getManualChunks = (config, inlineDynamicImports, preserveModules, inputOpt
     const configManualChunks = config.manualChunks || inputOptions.manualChunks;
     if (configManualChunks) {
         if (inlineDynamicImports) {
-            return error(errorInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.inlineDynamicImports"'));
+            return error(logInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.inlineDynamicImports"'));
         }
         if (preserveModules) {
-            return error(errorInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.preserveModules"'));
+            return error(logInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.preserveModules"'));
         }
     }
     return configManualChunks || {};
@@ -25214,9 +25527,9 @@ const getSourcemapBaseUrl = (config) => {
     const { sourcemapBaseUrl } = config;
     if (sourcemapBaseUrl) {
         if (isValidUrl(sourcemapBaseUrl)) {
-            return sourcemapBaseUrl;
+            return addTrailingSlashIfMissed(sourcemapBaseUrl);
         }
-        return error(errorInvalidOption('output.sourcemapBaseUrl', URL_OUTPUT_SOURCEMAPBASEURL, `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
+        return error(logInvalidOption('output.sourcemapBaseUrl', URL_OUTPUT_SOURCEMAPBASEURL, `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
     }
 };
 
@@ -25264,13 +25577,13 @@ async function rollupInternal(rawInputOptions, watcher) {
         closed: false,
         async generate(rawOutputOptions) {
             if (result.closed)
-                return error(errorAlreadyClosed());
+                return error(logAlreadyClosed());
             return handleGenerateWrite(false, inputOptions, unsetInputOptions, rawOutputOptions, graph);
         },
         watchFiles: Object.keys(graph.watchFiles),
         async write(rawOutputOptions) {
             if (result.closed)
-                return error(errorAlreadyClosed());
+                return error(logAlreadyClosed());
             return handleGenerateWrite(true, inputOptions, unsetInputOptions, rawOutputOptions, graph);
         }
     };
@@ -25278,21 +25591,34 @@ async function rollupInternal(rawInputOptions, watcher) {
         result.getTimings = getTimings;
     return result;
 }
-async function getInputOptions(rawInputOptions, watchMode) {
-    if (!rawInputOptions) {
+async function getInputOptions(initialInputOptions, watchMode) {
+    if (!initialInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    const rawPlugins = getSortedValidatedPlugins('options', await normalizePluginOption(rawInputOptions.plugins));
-    const { options, unsetOptions } = await normalizeInputOptions(await rawPlugins.reduce(applyOptionHook(watchMode), Promise.resolve(rawInputOptions)));
+    const processedInputOptions = await getProcessedInputOptions(initialInputOptions, watchMode);
+    const { options, unsetOptions } = await normalizeInputOptions(processedInputOptions, watchMode);
     normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
     return { options, unsetOptions };
 }
-function applyOptionHook(watchMode) {
-    return async (inputOptions, plugin) => {
-        const handler = 'handler' in plugin.options ? plugin.options.handler : plugin.options;
-        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) ||
-            inputOptions);
-    };
+async function getProcessedInputOptions(inputOptions, watchMode) {
+    const plugins = getSortedValidatedPlugins('options', await normalizePluginOption(inputOptions.plugins));
+    const logLevel = inputOptions.logLevel || LOGLEVEL_INFO;
+    const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), watchMode, logLevel);
+    for (const plugin of plugins) {
+        const { name, options } = plugin;
+        const handler = 'handler' in options ? options.handler : options;
+        const processedOptions = await handler.call({
+            debug: getLogHandler(LOGLEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
+            error: (error_) => error(logPluginError(normalizeLog(error_), name, { hook: 'onLog' })),
+            info: getLogHandler(LOGLEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
+            meta: { rollupVersion: version$1, watchMode },
+            warn: getLogHandler(LOGLEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel)
+        }, inputOptions);
+        if (processedOptions) {
+            inputOptions = processedOptions;
+        }
+    }
+    return inputOptions;
 }
 function normalizePlugins(plugins, anonymousPrefix) {
     for (const [index, plugin] of plugins.entries()) {
@@ -25309,7 +25635,7 @@ async function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, raw
         if (isWrite) {
             timeStart('WRITE', 1);
             if (!outputOptions.dir && !outputOptions.file) {
-                return error(errorMissingFileOrDirOption());
+                return error(logMissingFileOrDirOption());
             }
             await Promise.all(Object.values(generated).map(chunk => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
             await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);
@@ -25332,7 +25658,7 @@ async function getOutputOptionsAndPluginDriver(rawOutputOptions, inputPluginDriv
 }
 function getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver) {
     return normalizeOutputOptions(outputPluginDriver.hookReduceArg0Sync('outputOptions', [rawOutputOptions], (outputOptions, result) => result || outputOptions, pluginContext => {
-        const emitError = () => pluginContext.error(errorCannotEmitFromOptionsHook());
+        const emitError = () => pluginContext.error(logCannotEmitFromOptionsHook());
         return {
             ...pluginContext,
             emitFile: emitError,