rollup 3.24.1 → 3.25.0

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.24.1
-	Sat, 10 Jun 2023 04:40:07 GMT - commit be39a579ac40a1f97d1b8e491aade0cd8717d22b
+	Rollup.js v3.25.0
+	Sun, 11 Jun 2023 05:02:46 GMT - commit 23c111c87145d15b0de032a6c7eeb6596764d1cf
 
 	https://github.com/rollup/rollup
 
@@ -15,7 +15,7 @@ import { createHash as createHash$1 } from 'node:crypto';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version$1 = "3.24.1";
+var version$1 = "3.25.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -1971,6 +1971,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;
@@ -2149,21 +2232,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,
@@ -2172,61 +2255,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}.`
@@ -2234,21 +2317,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,
@@ -2257,7 +2340,7 @@ function errorCyclicCrossChunkReexport(exportName, exporter, reexporter, importe
         reexporter
     };
 }
-function errorDeprecation(deprecation, urlSnippet, plugin) {
+function logDeprecation(deprecation, urlSnippet, plugin) {
     return {
         code: DEPRECATED_FEATURE,
         message: deprecation,
@@ -2265,20 +2348,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,
@@ -2286,39 +2369,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.`
@@ -2330,46 +2419,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,
@@ -2377,7 +2472,7 @@ function errorInvalidAddonPluginHook(hook, plugin) {
         plugin
     };
 }
-function errorInvalidFunctionPluginHook(hook, plugin) {
+function logInvalidFunctionPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
@@ -2385,32 +2480,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,
@@ -2421,7 +2516,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,
@@ -2430,19 +2525,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();
@@ -2451,21 +2546,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,
@@ -2473,14 +2568,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,
@@ -2488,14 +2583,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,
@@ -2504,14 +2599,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)';
@@ -2526,10 +2629,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;
@@ -2542,7 +2643,7 @@ function errorPluginError(error, plugin, { hook, id } = {}) {
     }
     return error;
 }
-function errorShimmedExport(id, binding) {
+function logShimmedExport(id, binding) {
     return {
         binding,
         code: SHIMMED_EXPORT,
@@ -2550,7 +2651,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`,
@@ -2558,13 +2659,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,
@@ -2578,7 +2679,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,
@@ -2587,14 +2688,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,
@@ -2603,7 +2704,7 @@ function errorUnexpectedNamedImport(id, imported, isReexport) {
         url: getRollupUrl(URL_OUTPUT_INTEROP)
     };
 }
-function errorUnexpectedNamespaceReexport(id) {
+function logUnexpectedNamespaceReexport(id) {
     return {
         code: UNEXPECTED_NAMED_IMPORT,
         exporter: id,
@@ -2611,25 +2712,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,
@@ -2637,7 +2738,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,
@@ -2646,7 +2747,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,
@@ -2658,96 +2759,25 @@ 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);
+        log(LOGLEVEL_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;
-    }
-    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 {
     constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath, assertions) {
         this.options = options;
@@ -2830,7 +2860,7 @@ class ExternalModule {
             }
         }
         const importersArray = [...importersSet];
-        this.options.onwarn(errorUnusedExternalImports(this.id, unused, importersArray));
+        this.options.onLog(LOGLEVEL_WARN, logUnusedExternalImports(this.id, unused, importersArray));
     }
 }
 
@@ -8325,7 +8355,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()) {
@@ -8533,9 +8563,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) {
@@ -9580,7 +9610,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);
             }
         }
     }
@@ -9626,7 +9656,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;
@@ -9733,10 +9763,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 = {
@@ -11849,29 +11879,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);
@@ -11891,19 +11898,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);
             }
@@ -12264,7 +12260,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);
             }
         }
     }
@@ -12511,7 +12507,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) {
@@ -13154,6 +13150,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) {
@@ -13330,7 +13349,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);
     }
@@ -13656,7 +13675,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;
     }
@@ -13675,7 +13694,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);
@@ -13812,13 +13831,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 };
     }
@@ -13863,6 +13886,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,
@@ -13871,8 +13895,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);
@@ -13932,7 +13955,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;
         }
@@ -13949,10 +13972,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) {
@@ -14066,7 +14085,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);
         }
@@ -14107,7 +14126,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 {
@@ -14145,7 +14164,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];
         }
@@ -14153,7 +14172,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];
         }
@@ -14229,7 +14248,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() {
@@ -14237,7 +14256,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);
         }
     }
 }
@@ -14538,17 +14557,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;
@@ -14773,19 +14792,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) {
@@ -14977,14 +14996,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);
@@ -15094,7 +15113,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));
     }
 }
 
@@ -15247,15 +15266,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) {
@@ -15266,7 +15285,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';
         }
@@ -15343,7 +15362,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;
@@ -15354,11 +15374,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;
     };
@@ -15425,14 +15445,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;
     });
 }
@@ -15457,13 +15477,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;
     }
 }
@@ -15622,7 +15642,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 = [];
@@ -15770,7 +15790,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
@@ -15820,8 +15840,8 @@ class Chunk {
             intro,
             isEntryFacade: preserveModules || (facadeModule !== null && facadeModule.info.isEntry),
             isModuleFacade: facadeModule !== null,
+            log: onLog,
             namedExportsMode: exportMode !== 'default',
-            onwarn,
             outro,
             snippets,
             usesTopLevelAwait
@@ -15876,7 +15896,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));
                     }
@@ -16064,7 +16084,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 {
@@ -16154,7 +16174,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));
@@ -16176,7 +16196,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 &&
@@ -16221,7 +16241,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,
@@ -16245,7 +16265,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);
@@ -16318,7 +16338,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 };
     }
@@ -16607,7 +16627,7 @@ 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
@@ -16615,7 +16635,7 @@ function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize) {
     // This mutates initialChunks but also clears
     // dynamicallyDependentEntriesByDynamicEntry as side effect
     removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize).map(({ modules }) => ({
+    chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize, log).map(({ modules }) => ({
         alias: null,
         modules
     })));
@@ -16871,7 +16891,7 @@ function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesBy
  *    following the rule (a), starting with the smallest chunks to look for
  *    possible merge targets.
  */
-function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize) {
+function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize, log) {
     timeStart('optimize chunks', 3);
     const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
     if (!chunkPartition) {
@@ -16879,10 +16899,10 @@ function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize) {
         return initialChunks; // the actual modules
     }
     minChunkSize > 1 &&
-        console.log('Before eliminating small chunks, there were\n', initialChunks.length, 'chunks, of which\n', chunkPartition.small.size, 'were below minChunkSize.');
+        log('info', logOptimizeChunkStatus(initialChunks.length, chunkPartition.small.size, 'Initially'));
     mergeChunks(chunkPartition, minChunkSize);
     minChunkSize > 1 &&
-        console.log('After merging chunks,\n', chunkPartition.small.size + chunkPartition.big.size, 'chunks remain, of which\n', chunkPartition.small.size, 'are below minChunkSize.');
+        log('info', logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
     timeEnd('optimize chunks', 3);
     return [...chunkPartition.small, ...chunkPartition.big];
 }
@@ -17293,7 +17313,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) {
@@ -17343,12 +17363,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: []
@@ -17370,8 +17390,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));
@@ -17386,11 +17406,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 };
 }
@@ -17415,14 +17435,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);
@@ -17441,7 +17461,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) => {
@@ -17472,13 +17492,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) {
@@ -17491,7 +17511,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);
@@ -17503,7 +17523,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();
@@ -17516,7 +17536,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) {
@@ -17633,14 +17653,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_]);
@@ -17703,7 +17723,7 @@ class Bundle {
                         });
                     }
                     catch (error_) {
-                        this.inputOptions.onwarn(errorChunkInvalid(file, error_));
+                        this.inputOptions.onLog(LOGLEVEL_WARN, logChunkInvalid(file, error_));
                     }
                 }
             }
@@ -17725,7 +17745,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);
@@ -17740,15 +17760,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 = [];
@@ -17781,7 +17801,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);
 }
@@ -23565,9 +23585,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 {
@@ -23586,7 +23606,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);
@@ -23608,7 +23775,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;
             }
@@ -23627,6 +23794,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) => {
@@ -23640,6 +23815,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);
@@ -23654,7 +23830,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 });
@@ -23669,23 +23845,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)
@@ -23811,7 +23980,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 &&
@@ -23835,7 +24004,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() {
@@ -23881,7 +24050,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;
@@ -23930,10 +24099,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);
         }
@@ -24043,9 +24212,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,
@@ -24057,7 +24226,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;
     }
@@ -24065,14 +24234,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
@@ -24097,7 +24266,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;
             }
@@ -24165,9 +24334,9 @@ 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;
@@ -24185,13 +24354,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;
 }
@@ -24202,7 +24371,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) {
@@ -24214,13 +24383,13 @@ class FileEmitter {
         this.outputFileEmitters = [];
         this.emitFile = (emittedFile) => {
             if (!hasValidType(emittedFile)) {
-                return error(errorFailedValidation(`Emitted files must be of type "asset", "chunk" or "prebuilt-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 chunks and assets 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);
@@ -24230,13 +24399,13 @@ 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);
             }
@@ -24248,12 +24417,12 @@ class FileEmitter {
         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) {
@@ -24277,7 +24446,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();
@@ -24367,7 +24536,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);
@@ -24375,10 +24544,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,
@@ -24398,11 +24567,11 @@ class FileEmitter {
     }
     emitPrebuiltChunk(emitPrebuiltChunk) {
         if (typeof emitPrebuiltChunk.code !== 'string') {
-            return error(errorFailedValidation(`Emitted prebuilt chunks need to have a valid string code, received "${emitPrebuiltChunk.code}".`));
+            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(errorFailedValidation(`The "fileName" property of emitted prebuilt chunks must be strings that are neither absolute nor relative paths, received "${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,
@@ -24477,7 +24646,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) ||
@@ -24503,19 +24691,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);
         },
@@ -24537,15 +24727,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)
     };
 }
 
@@ -24557,6 +24739,7 @@ const inputHookNames = {
     closeWatcher: 1,
     load: 1,
     moduleParsed: 1,
+    onLog: 1,
     options: 1,
     resolveDynamicImport: 1,
     resolveId: 1,
@@ -24588,7 +24771,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));
                     }
                 }
             }
@@ -24735,7 +24918,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 }));
         });
     }
     /**
@@ -24757,7 +24940,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 }));
         }
     }
 }
@@ -24789,12 +24972,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() { }
@@ -25006,7 +25189,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));
                 }
             }
         }
@@ -25014,7 +25197,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) {
@@ -25027,7 +25210,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);
                 }
             }
         }
@@ -25086,6 +25269,40 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
     }
 }
 
+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);
 const space = " ".charCodeAt(0);
 
@@ -25337,100 +25554,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),
@@ -25439,43 +25572,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',
@@ -25510,10 +25628,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;
 };
@@ -25521,17 +25639,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') {
@@ -25555,10 +25673,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;
 };
@@ -25595,7 +25713,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;
 };
@@ -25681,17 +25799,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;
 };
@@ -25718,7 +25836,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));
         }
     }
 };
@@ -25726,7 +25844,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;
 };
@@ -25734,10 +25852,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;
@@ -25765,10 +25883,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
         ? {
@@ -25795,7 +25913,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;
 };
@@ -25804,7 +25922,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;
@@ -25829,7 +25947,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';
 }
@@ -25872,7 +25990,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));
     }
@@ -25882,10 +26000,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 || {};
@@ -25905,7 +26023,7 @@ const getSourcemapBaseUrl = (config) => {
         if (isValidUrl(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)}`));
     }
 };
 
@@ -25953,13 +26071,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);
         }
     };
@@ -25967,21 +26085,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()) {
@@ -25998,7 +26129,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]);
@@ -26021,7 +26152,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,
@@ -26057,7 +26188,8 @@ async function writeOutputFile(outputFile, outputOptions) {
 }
 /**
  * Auxiliary function for defining rollup configuration
- * Mainly to facilitate IDE code prompts, after all, export default does not prompt, even if you add @type annotations, it is not accurate
+ * Mainly to facilitate IDE code prompts, after all, export default does not
+ * prompt, even if you add @type annotations, it is not accurate
  * @param options
  */
 function defineConfig(options) {
@@ -26222,17 +26354,20 @@ const commandAliases = {
     w: 'watch'
 };
 const EMPTY_COMMAND_OPTIONS = { external: [], globals: undefined };
-async function mergeOptions(config, rawCommandOptions = EMPTY_COMMAND_OPTIONS, defaultOnWarnHandler = defaultOnWarn) {
+async function mergeOptions(config, watchMode, rawCommandOptions = EMPTY_COMMAND_OPTIONS, printLog) {
     const command = getCommandOptions(rawCommandOptions);
-    const inputOptions = await mergeInputOptions(config, command, defaultOnWarnHandler);
-    const warn = inputOptions.onwarn;
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || LOGLEVEL_INFO;
+    const onLog = getOnLog(config, logLevel, printLog);
+    const log = getLogger(plugins, onLog, watchMode, logLevel);
+    const inputOptions = await mergeInputOptions(config, command, plugins, log, onLog);
     if (command.output) {
         Object.assign(command, command.output);
     }
     const outputOptionsArray = ensureArray(config.output);
     if (outputOptionsArray.length === 0)
         outputOptionsArray.push({});
-    const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn)));
+    const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, log)));
     warnUnknownOptions(command, [
         ...Object.keys(inputOptions),
         ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapIgnoreList' && option !== 'sourcemapPathTransform'),
@@ -26246,7 +26381,7 @@ async function mergeOptions(config, rawCommandOptions = EMPTY_COMMAND_OPTIONS, d
         'stdin',
         'waitForBundleInput',
         'configPlugin'
-    ], 'CLI flags', warn, /^_$|output$|config/);
+    ], 'CLI flags', log, /^_$|output$|config/);
     inputOptions.output = outputOptions;
     return inputOptions;
 }
@@ -26269,7 +26404,7 @@ function getCommandOptions(rawCommandOptions) {
             : undefined
     };
 }
-async function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
+function mergeInputOptions(config, overrides, plugins, log, onLog) {
     const getOption = (name) => overrides[name] ?? config[name];
     const inputOptions = {
         acorn: getOption('acorn'),
@@ -26281,14 +26416,16 @@ async function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
         external: getExternal(config, overrides),
         inlineDynamicImports: getOption('inlineDynamicImports'),
         input: getOption('input') || [],
+        logLevel: getOption('logLevel'),
         makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
         manualChunks: getOption('manualChunks'),
         maxParallelFileOps: getOption('maxParallelFileOps'),
         maxParallelFileReads: getOption('maxParallelFileReads'),
         moduleContext: getOption('moduleContext'),
-        onwarn: getOnWarn(config, defaultOnWarnHandler),
+        onLog,
+        onwarn: undefined,
         perf: getOption('perf'),
-        plugins: await normalizePluginOption(config.plugins),
+        plugins,
         preserveEntrySignatures: getOption('preserveEntrySignatures'),
         preserveModules: getOption('preserveModules'),
         preserveSymlinks: getOption('preserveSymlinks'),
@@ -26297,7 +26434,7 @@ async function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
         treeshake: getObjectOption(config, overrides, 'treeshake', objectifyOptionWithPresets(treeshakePresets, 'treeshake', URL_TREESHAKE, 'false, true, ')),
         watch: getWatch(config, overrides)
     };
-    warnUnknownOptions(config, Object.keys(inputOptions), 'input options', inputOptions.onwarn, /^output$/);
+    warnUnknownOptions(config, Object.keys(inputOptions), 'input options', log, /^output$/);
     return inputOptions;
 }
 const getExternal = (config, overrides) => {
@@ -26306,7 +26443,6 @@ const getExternal = (config, overrides) => {
         ? (source, importer, isResolved) => configExternal(source, importer, isResolved) || overrides.external.includes(source)
         : [...ensureArray(configExternal), ...overrides.external];
 };
-const getOnWarn = (config, defaultOnWarnHandler) => config.onwarn ? warning => config.onwarn(warning, defaultOnWarnHandler) : defaultOnWarnHandler;
 const getObjectOption = (config, overrides, name, objectifyValue = objectifyOption) => {
     const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
     const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
@@ -26325,7 +26461,7 @@ const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
     }
     return objectifyValue(optionValue);
 };
-async function mergeOutputOptions(config, overrides, warn) {
+async function mergeOutputOptions(config, overrides, log) {
     const getOption = (name) => overrides[name] ?? config[name];
     const outputOptions = {
         amd: getObjectOption(config, overrides, 'amd'),
@@ -26377,7 +26513,7 @@ async function mergeOutputOptions(config, overrides, warn) {
         systemNullSetters: getOption('systemNullSetters'),
         validate: getOption('validate')
     };
-    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', warn);
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', log);
     return outputOptions;
 }
 
@@ -26465,10 +26601,10 @@ function watch(configs) {
     return emitter;
 }
 async function watchInternal(configs, emitter) {
-    const optionsList = await Promise.all(ensureArray(configs).map(config => mergeOptions(config)));
+    const optionsList = await Promise.all(ensureArray(configs).map(config => mergeOptions(config, true)));
     const watchOptionsList = optionsList.filter(config => config.watch !== false);
     if (watchOptionsList.length === 0) {
-        return error(errorInvalidOption('watch', URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
+        return error(logInvalidOption('watch', URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
     }
     await loadFsEvents();
     const { Watcher } = await import('./watch.js');