rollup 3.0.0-1 → 3.0.0-4

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.0.0-1
-	Fri, 08 Jul 2022 11:35:32 GMT - commit 48ce34db70ebc2b4c1be38e6b8b02881be90b9f1
+	Rollup.js v3.0.0-3
+	Mon, 15 Aug 2022 04:43:13 GMT - commit 84a4a595851ef71494b6f2ab558968bfbc148bdb
 
 	https://github.com/rollup/rollup
 
@@ -9,12 +9,13 @@
 */
 'use strict';
 
+const node_path = require('node:path');
 const require$$0 = require('path');
-const process$1 = require('process');
-const perf_hooks = require('perf_hooks');
-const crypto = require('crypto');
-const require$$0$1 = require('fs');
-const require$$0$2 = require('events');
+const process$1 = require('node:process');
+const node_perf_hooks = require('node:perf_hooks');
+const node_crypto = require('node:crypto');
+const node_fs = require('node:fs');
+const node_events = require('node:events');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -27,7 +28,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "3.0.0-1";
+var version$1 = "3.0.0-3";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -162,13 +163,13 @@ function normalize(path) {
 }
 
 function getAliasName(id) {
-    const base = require$$0.basename(id);
-    return base.substring(0, base.length - require$$0.extname(id).length);
+    const base = node_path.basename(id);
+    return base.substring(0, base.length - node_path.extname(id).length);
 }
 function relativeId(id) {
     if (!isAbsolute(id))
         return id;
-    return relative(require$$0.resolve(), id);
+    return relative(node_path.resolve(), id);
 }
 function isPathFragment(name) {
     // starting with "/", "./", "../", "C:/"
@@ -176,17 +177,17 @@ function isPathFragment(name) {
 }
 const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
 function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
-    let relativePath = normalize(relative(require$$0.dirname(importerId), targetPath));
+    let relativePath = normalize(relative(node_path.dirname(importerId), targetPath));
     if (stripJsExtension && relativePath.endsWith('.js')) {
         relativePath = relativePath.slice(0, -3);
     }
     if (ensureFileName) {
         if (relativePath === '')
-            return '../' + require$$0.basename(targetPath);
+            return '../' + node_path.basename(targetPath);
         if (UPPER_DIR_REGEX.test(relativePath)) {
             return relativePath
                 .split('/')
-                .concat(['..', require$$0.basename(targetPath)])
+                .concat(['..', node_path.basename(targetPath)])
                 .join('/');
         }
     }
@@ -194,8 +195,10 @@ function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName)
 }
 
 function error(base) {
-    if (!(base instanceof Error))
+    if (!(base instanceof Error)) {
         base = Object.assign(new Error(base.message), base);
+        Object.defineProperty(base, 'name', { value: 'RollupError' });
+    }
     throw base;
 }
 function augmentCodeLocation(props, pos, source, id) {
@@ -213,335 +216,545 @@ function augmentCodeLocation(props, pos, source, id) {
         props.frame = getCodeFrame(source, line, column);
     }
 }
-var Errors;
-(function (Errors) {
-    Errors["ADDON_ERROR"] = "ADDON_ERROR";
-    Errors["ALREADY_CLOSED"] = "ALREADY_CLOSED";
-    Errors["ASSET_NOT_FINALISED"] = "ASSET_NOT_FINALISED";
-    Errors["ASSET_NOT_FOUND"] = "ASSET_NOT_FOUND";
-    Errors["ASSET_SOURCE_ALREADY_SET"] = "ASSET_SOURCE_ALREADY_SET";
-    Errors["ASSET_SOURCE_MISSING"] = "ASSET_SOURCE_MISSING";
-    Errors["BAD_LOADER"] = "BAD_LOADER";
-    Errors["CANNOT_EMIT_FROM_OPTIONS_HOOK"] = "CANNOT_EMIT_FROM_OPTIONS_HOOK";
-    Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
-    Errors["CHUNK_INVALID"] = "CHUNK_INVALID";
-    Errors["CIRCULAR_REEXPORT"] = "CIRCULAR_REEXPORT";
-    Errors["CYCLIC_CROSS_CHUNK_REEXPORT"] = "CYCLIC_CROSS_CHUNK_REEXPORT";
-    Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
-    Errors["EXTERNAL_SYNTHETIC_EXPORTS"] = "EXTERNAL_SYNTHETIC_EXPORTS";
-    Errors["FILE_NAME_CONFLICT"] = "FILE_NAME_CONFLICT";
-    Errors["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
-    Errors["INPUT_HOOK_IN_OUTPUT_PLUGIN"] = "INPUT_HOOK_IN_OUTPUT_PLUGIN";
-    Errors["INVALID_CHUNK"] = "INVALID_CHUNK";
-    Errors["INVALID_EXPORT_OPTION"] = "INVALID_EXPORT_OPTION";
-    Errors["INVALID_EXTERNAL_ID"] = "INVALID_EXTERNAL_ID";
-    Errors["INVALID_OPTION"] = "INVALID_OPTION";
-    Errors["INVALID_PLUGIN_HOOK"] = "INVALID_PLUGIN_HOOK";
-    Errors["INVALID_ROLLUP_PHASE"] = "INVALID_ROLLUP_PHASE";
-    Errors["INVALID_TLA_FORMAT"] = "INVALID_TLA_FORMAT";
-    Errors["MISSING_EXPORT"] = "MISSING_EXPORT";
-    Errors["MISSING_IMPLICIT_DEPENDANT"] = "MISSING_IMPLICIT_DEPENDANT";
-    Errors["MIXED_EXPORTS"] = "MIXED_EXPORTS";
-    Errors["NAMESPACE_CONFLICT"] = "NAMESPACE_CONFLICT";
-    Errors["AMBIGUOUS_EXTERNAL_NAMESPACES"] = "AMBIGUOUS_EXTERNAL_NAMESPACES";
-    Errors["NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE"] = "NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE";
-    Errors["PLUGIN_ERROR"] = "PLUGIN_ERROR";
-    Errors["PREFER_NAMED_EXPORTS"] = "PREFER_NAMED_EXPORTS";
-    Errors["SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT"] = "SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT";
-    Errors["UNEXPECTED_NAMED_IMPORT"] = "UNEXPECTED_NAMED_IMPORT";
-    Errors["UNRESOLVED_ENTRY"] = "UNRESOLVED_ENTRY";
-    Errors["UNRESOLVED_IMPORT"] = "UNRESOLVED_IMPORT";
-    Errors["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-})(Errors || (Errors = {}));
+// 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_IMPORT_OPTIONS = 'DUPLICATE_IMPORT_OPTIONS', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FAIL_AFTER_WARNINGS = 'FAIL_AFTER_WARNINGS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', 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_CONFIG = 'MISSING_CONFIG', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_EXTERNAL_CONFIG = 'MISSING_EXTERNAL_CONFIG', 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', ONLY_INLINE_SOURCEMAPS = 'ONLY_INLINE_SOURCEMAPS', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', PREFER_NAMED_EXPORTS = 'PREFER_NAMED_EXPORTS', 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', TRANSPILED_ESM_CONFIG = 'TRANSPILED_ESM_CONFIG', 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 errAddonNotGenerated(message, hook, plugin) {
     return {
-        code: Errors.ADDON_ERROR,
-        message: `Could not retrieve ${hook}. Check configuration of plugin ${plugin}.
+        code: ADDON_ERROR,
+        message: `Could not retrieve "${hook}". Check configuration of plugin "${plugin}".
 \tError Message: ${message}`
     };
 }
+function errAlreadyClosed() {
+    return {
+        code: ALREADY_CLOSED,
+        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
+    };
+}
+function errAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
+    return {
+        binding,
+        code: AMBIGUOUS_EXTERNAL_NAMESPACES,
+        ids: sources,
+        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${binding}" from one of the external modules ${printQuotedStringList(sources.map(module => relativeId(module)))}, guessing "${relativeId(usedModule)}".`,
+        reexporter: reexportingModule
+    };
+}
+function errAnonymousPluginCache() {
+    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 errAssetNotFinalisedForFileName(name) {
     return {
-        code: Errors.ASSET_NOT_FINALISED,
+        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 errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+    return {
+        code: ASSET_NOT_FOUND,
+        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
+    };
+}
+function errAssetSourceAlreadySet(name) {
+    return {
+        code: ASSET_SOURCE_ALREADY_SET,
+        message: `Unable to set the source for asset "${name}", source already set.`
+    };
+}
+function errNoAssetSourceSet(assetName) {
+    return {
+        code: ASSET_SOURCE_MISSING,
+        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+    };
+}
+function errBadLoader(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 errCannotCallNamespace(name) {
+    return {
+        code: CANNOT_CALL_NAMESPACE,
+        message: `Cannot call a namespace ("${name}").`
+    };
+}
 function errCannotEmitFromOptionsHook() {
     return {
-        code: Errors.CANNOT_EMIT_FROM_OPTIONS_HOOK,
+        code: CANNOT_EMIT_FROM_OPTIONS_HOOK,
         message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
     };
 }
 function errChunkNotGeneratedForFileName(name) {
     return {
-        code: Errors.CHUNK_NOT_GENERATED,
+        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 errChunkInvalid({ fileName, code }, exception) {
     const errorProps = {
-        code: Errors.CHUNK_INVALID,
+        code: CHUNK_INVALID,
         message: `Chunk "${fileName}" is not valid JavaScript: ${exception.message}.`
     };
     augmentCodeLocation(errorProps, exception.loc, code, fileName);
     return errorProps;
 }
-function errCircularReexport(exportName, importedModule) {
+function errCircularDependency(cyclePath) {
+    return {
+        code: CIRCULAR_DEPENDENCY,
+        ids: cyclePath,
+        message: `Circular dependency: ${cyclePath.map(relativeId).join(' -> ')}`
+    };
+}
+function errCircularReexport(exportName, exporter) {
     return {
-        code: Errors.CIRCULAR_REEXPORT,
-        id: importedModule,
-        message: `"${exportName}" cannot be exported from ${relativeId(importedModule)} as it is a reexport that references itself.`
+        code: CIRCULAR_REEXPORT,
+        exporter,
+        message: `"${exportName}" cannot be exported from "${relativeId(exporter)}" as it is a reexport that references itself.`
     };
 }
 function errCyclicCrossChunkReexport(exportName, exporter, reexporter, importer) {
     return {
-        code: Errors.CYCLIC_CROSS_CHUNK_REEXPORT,
+        code: CYCLIC_CROSS_CHUNK_REEXPORT,
         exporter,
-        importer,
-        message: `Export "${exportName}" of module ${relativeId(exporter)} was reexported through module ${relativeId(reexporter)} while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in ${relativeId(importer)} to point directly to the exporting module or do not use "preserveModules" to ensure these modules end up in the same chunk.`,
+        id: importer,
+        message: `Export "${exportName}" of module "${relativeId(exporter)}" was reexported through module "${relativeId(reexporter)}" while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in "${relativeId(importer)}" to point directly to the exporting module or do not use "preserveModules" to ensure these modules end up in the same chunk.`,
         reexporter
     };
 }
-function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+function errDeprecation(deprecation) {
     return {
-        code: Errors.ASSET_NOT_FOUND,
-        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
+        code: DEPRECATED_FEATURE,
+        ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
     };
 }
-function errAssetSourceAlreadySet(name) {
+function errDuplicateImportOptions() {
     return {
-        code: Errors.ASSET_SOURCE_ALREADY_SET,
-        message: `Unable to set the source for asset "${name}", source already set.`
+        code: DUPLICATE_IMPORT_OPTIONS,
+        message: 'Either use --input, or pass input path as argument'
     };
 }
-function errNoAssetSourceSet(assetName) {
+function errDuplicatePluginName(plugin) {
     return {
-        code: Errors.ASSET_SOURCE_MISSING,
-        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+        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 errBadLoader(id) {
+function errEmptyChunk(chunkName) {
     return {
-        code: Errors.BAD_LOADER,
-        message: `Error loading ${relativeId(id)}: plugin load hook should return a string, a { code, map } object, or nothing/null`
+        code: EMPTY_BUNDLE,
+        message: `Generated an empty chunk: "${chunkName}".`,
+        names: [chunkName]
     };
 }
-function errDeprecation(deprecation) {
+function errEval(id) {
     return {
-        code: Errors.DEPRECATED_FEATURE,
-        ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
+        code: EVAL,
+        id,
+        message: `Use of eval in "${relativeId(id)}" is strongly discouraged as it poses security risks and may cause issues with minification.`,
+        url: 'https://rollupjs.org/guide/en/#avoiding-eval'
     };
 }
-function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
+function errExternalSyntheticExports(id, importer) {
     return {
-        code: Errors.FILE_NOT_FOUND,
-        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+        code: EXTERNAL_SYNTHETIC_EXPORTS,
+        exporter: id,
+        message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
+    };
+}
+function errFailAfterWarnings() {
+    return {
+        code: FAIL_AFTER_WARNINGS,
+        message: 'Warnings occurred and --failAfterWarnings flag present.'
     };
 }
 function errFileNameConflict(fileName) {
     return {
-        code: Errors.FILE_NAME_CONFLICT,
+        code: FILE_NAME_CONFLICT,
         message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
     };
 }
+function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
+    return {
+        code: FILE_NOT_FOUND,
+        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+    };
+}
+function errIllegalIdentifierAsName(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: 'https://rollupjs.org/guide/en/#outputextend'
+    };
+}
+function errIllegalImportReassignment(name, importingId) {
+    return {
+        code: ILLEGAL_REASSIGNMENT,
+        message: `Illegal reassignment of import "${name}" in "${relativeId(importingId)}".`
+    };
+}
 function errInputHookInOutputPlugin(pluginName, hookName) {
     return {
-        code: Errors.INPUT_HOOK_IN_OUTPUT_PLUGIN,
+        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 errCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
     return {
-        code: Errors.INVALID_CHUNK,
-        message: `Cannot assign ${relativeId(moduleId)} to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
+        code: INVALID_CHUNK,
+        message: `Cannot assign "${relativeId(moduleId)}" to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
     };
 }
 function errInvalidExportOptionValue(optionValue) {
     return {
-        code: Errors.INVALID_EXPORT_OPTION,
-        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}"`,
+        code: INVALID_EXPORT_OPTION,
+        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}".`,
         url: `https://rollupjs.org/guide/en/#outputexports`
     };
 }
 function errIncompatibleExportOptionValue(optionValue, keys, entryModule) {
     return {
-        code: 'INVALID_EXPORT_OPTION',
-        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${keys.join(', ')}`
+        code: INVALID_EXPORT_OPTION,
+        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${printQuotedStringList(keys)}`,
+        url: 'https://rollupjs.org/guide/en/#outputexports'
     };
 }
 function errInternalIdCannotBeExternal(source, importer) {
     return {
-        code: Errors.INVALID_EXTERNAL_ID,
-        message: `'${source}' is imported as an external by ${relativeId(importer)}, but is already an existing non-external module id.`
+        code: INVALID_EXTERNAL_ID,
+        message: `"${source}" is imported as an external by "${relativeId(importer)}", but is already an existing non-external module id.`
     };
 }
 function errInvalidOption(option, urlHash, explanation, value) {
     return {
-        code: Errors.INVALID_OPTION,
+        code: INVALID_OPTION,
         message: `Invalid value ${value !== undefined ? `${JSON.stringify(value)} ` : ''}for option "${option}" - ${explanation}.`,
         url: `https://rollupjs.org/guide/en/#${urlHash}`
     };
 }
+function errInvalidAddonPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a string, a function hook or an object with a "handler" string or function.`,
+        plugin
+    };
+}
+function errInvalidFunctionPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a function hook or an object with a "handler" function.`,
+        plugin
+    };
+}
 function errInvalidRollupPhaseForAddWatchFile() {
     return {
-        code: Errors.INVALID_ROLLUP_PHASE,
-        message: `Cannot call addWatchFile after the build has finished.`
+        code: INVALID_ROLLUP_PHASE,
+        message: `Cannot call "addWatchFile" after the build has finished.`
     };
 }
 function errInvalidRollupPhaseForChunkEmission() {
     return {
-        code: Errors.INVALID_ROLLUP_PHASE,
+        code: INVALID_ROLLUP_PHASE,
         message: `Cannot emit chunks after module loading has finished.`
     };
 }
+function errInvalidSetAssetSourceCall() {
+    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 errInvalidFormatForTopLevelAwait(id, format) {
     return {
-        code: Errors.INVALID_TLA_FORMAT,
+        code: INVALID_TLA_FORMAT,
         id,
-        message: `Module format ${format} does not support top-level await. Use the "es" or "system" output formats rather.`
+        message: `Module format "${format}" does not support top-level await. Use the "es" or "system" output formats rather.`
+    };
+}
+function errMissingConfig() {
+    return {
+        code: MISSING_CONFIG,
+        message: 'Config file must export an options object, or an array of options objects',
+        url: 'https://rollupjs.org/guide/en/#configuration-files'
     };
 }
-function errMissingExport(exportName, importingModule, importedModule) {
+function errMissingExport(binding, importingModule, exporter) {
     return {
-        code: Errors.MISSING_EXPORT,
-        message: `'${exportName}' is not exported by ${relativeId(importedModule)}, imported by ${relativeId(importingModule)}`,
+        binding,
+        code: MISSING_EXPORT,
+        exporter,
+        id: importingModule,
+        message: `"${binding}" is not exported by "${relativeId(exporter)}", imported by "${relativeId(importingModule)}".`,
         url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
     };
 }
+function errMissingExternalConfig(file) {
+    return {
+        code: MISSING_EXTERNAL_CONFIG,
+        message: `Could not resolve config file "${file}"`
+    };
+}
+function errMissingGlobalName(externalId, guess) {
+    return {
+        code: MISSING_GLOBAL_NAME,
+        id: externalId,
+        message: `No name was provided for external module "${externalId}" in "output.globals" – guessing "${guess}".`,
+        names: [guess],
+        url: 'https://rollupjs.org/guide/en/#outputglobals'
+    };
+}
 function errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
     return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        code: MISSING_IMPLICIT_DEPENDANT,
         message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
     };
 }
 function errUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
     return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        code: MISSING_IMPLICIT_DEPENDANT,
         message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
     };
 }
 function errImplicitDependantIsNotIncluded(module) {
     const implicitDependencies = Array.from(module.implicitlyLoadedBefore, dependency => relativeId(dependency.id)).sort();
     return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        code: MISSING_IMPLICIT_DEPENDANT,
         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 errMissingNameOptionForIifeExport() {
+    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: 'https://rollupjs.org/guide/en/#outputname'
+    };
+}
+function errMissingNameOptionForUmdExport() {
+    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: 'https://rollupjs.org/guide/en/#outputname'
+    };
+}
+function errMissingNodeBuiltins(externalBuiltins) {
+    return {
+        code: MISSING_NODE_BUILTINS,
+        ids: externalBuiltins,
+        message: `Creating a browser bundle that depends on Node.js built-in modules (${printQuotedStringList(externalBuiltins)}). You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`
+    };
+}
+function errMissingFileOrDirOption() {
+    return {
+        code: MISSING_OPTION,
+        message: 'You must specify "output.file" or "output.dir" for the build.',
+        url: 'https://rollupjs.org/guide/en/#outputdir'
+    };
+}
 function errMixedExport(facadeModuleId, name) {
     return {
-        code: Errors.MIXED_EXPORTS,
+        code: MIXED_EXPORTS,
         id: facadeModuleId,
-        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}["default"]\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning`,
+        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}.default\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning.`,
         url: `https://rollupjs.org/guide/en/#outputexports`
     };
 }
-function errNamespaceConflict(name, reexportingModuleId, sources) {
+function errModuleLevelDirective(directive, id) {
     return {
-        code: Errors.NAMESPACE_CONFLICT,
-        message: `Conflicting namespaces: "${relativeId(reexportingModuleId)}" re-exports "${name}" from one of the modules ${printQuotedStringList(sources.map(moduleId => relativeId(moduleId)))} (will be ignored)`,
-        name,
-        reexporter: reexportingModuleId,
-        sources
+        code: MODULE_LEVEL_DIRECTIVE,
+        id,
+        message: `Module level directives cause errors when bundled, "${directive}" in "${relativeId(id)}" was ignored.`
     };
 }
-function errAmbiguousExternalNamespaces(name, reexportingModule, usedModule, sources) {
+function errNamespaceConflict(binding, reexportingModuleId, sources) {
     return {
-        code: Errors.AMBIGUOUS_EXTERNAL_NAMESPACES,
-        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${name}" from one of the external modules ${printQuotedStringList(sources.map(module => relativeId(module)))}, guessing "${relativeId(usedModule)}".`,
-        name,
-        reexporter: reexportingModule,
-        sources
+        binding,
+        code: NAMESPACE_CONFLICT,
+        ids: sources,
+        message: `Conflicting namespaces: "${relativeId(reexportingModuleId)}" re-exports "${binding}" from one of the modules ${printQuotedStringList(sources.map(moduleId => relativeId(moduleId)))} (will be ignored).`,
+        reexporter: reexportingModuleId
     };
 }
 function errNoTransformMapOrAstWithoutCode(pluginName) {
     return {
-        code: Errors.NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
+        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 errOnlyInlineSourcemapsForStdout() {
+    return {
+        code: ONLY_INLINE_SOURCEMAPS,
+        message: 'Only inline sourcemaps are supported when bundling to stdout.'
+    };
+}
+function errParseError(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)';
+    }
+    else if (!moduleId.endsWith('.js')) {
+        message += ' (Note that you need plugins to import files that are not JavaScript)';
+    }
+    return {
+        cause: error,
+        code: PARSE_ERROR,
+        id: moduleId,
+        message
+    };
+}
+function errPluginError(error, plugin, { hook, id } = {}) {
+    if (typeof error === 'string')
+        error = { message: error };
+    if (error.code && error.code !== PLUGIN_ERROR) {
+        error.pluginCode = error.code;
+    }
+    error.code = PLUGIN_ERROR;
+    error.plugin = plugin;
+    if (hook) {
+        error.hook = hook;
+    }
+    if (id) {
+        error.id = id;
+    }
+    return error;
+}
 function errPreferNamedExports(facadeModuleId) {
     const file = relativeId(facadeModuleId);
     return {
-        code: Errors.PREFER_NAMED_EXPORTS,
+        code: PREFER_NAMED_EXPORTS,
         id: facadeModuleId,
         message: `Entry module "${file}" is implicitly using "default" export mode, which means for CommonJS output that its default export is assigned to "module.exports". For many tools, such CommonJS output will not be interchangeable with the original ES module. If this is intended, explicitly set "output.exports" to either "auto" or "default", otherwise you might want to consider changing the signature of "${file}" to use named exports only.`,
         url: `https://rollupjs.org/guide/en/#outputexports`
     };
 }
-function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+function errShimmedExport(id, binding) {
+    return {
+        binding,
+        code: SHIMMED_EXPORT,
+        exporter: id,
+        message: `Missing export "${binding}" has been shimmed in module "${relativeId(id)}".`
+    };
+}
+function errSourcemapBroken(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`,
+        plugin,
+        url: `https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect`
+    };
+}
+function errInvalidSourcemapForError(error, id, column, line, pos) {
     return {
-        code: Errors.SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
+        cause: error,
+        code: SOURCEMAP_ERROR,
         id,
-        message: `Module "${relativeId(id)}" that is marked with 'syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}' needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
+        loc: {
+            column,
+            file: id,
+            line
+        },
+        message: `Error when using sourcemap for reporting an error: ${error.message}`,
+        pos
+    };
+}
+function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+    return {
+        code: SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
+        exporter: id,
+        message: `Module "${relativeId(id)}" that is marked with \`syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}\` needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
             ? `an explicit export named "${syntheticNamedExportsOption}"`
             : 'a default export'} that does not reexport an unresolved named export of the same module.`
     };
 }
+function errThisIsUndefined() {
+    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: `https://rollupjs.org/guide/en/#error-this-is-undefined`
+    };
+}
+function errTranspiledEsmConfig(fileName) {
+    return {
+        code: TRANSPILED_ESM_CONFIG,
+        message: `While loading the Rollup configuration from "${relativeId(fileName)}", Node tried to require an ES module from a CommonJS file, which is not supported. A common cause is if there is a package.json file with "type": "module" in the same folder. You can try to fix this by changing the extension of your configuration file to ".cjs" or ".mjs" depending on the content, which will prevent Rollup from trying to preprocess the file but rather hand it to Node directly.`
+    };
+}
 function errUnexpectedNamedImport(id, imported, isReexport) {
     const importType = isReexport ? 'reexport' : 'import';
     return {
-        code: Errors.UNEXPECTED_NAMED_IMPORT,
-        id,
-        message: `The named export "${imported}" was ${importType}ed from the external module ${relativeId(id)} even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `The named export "${imported}" was ${importType}ed from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
         url: 'https://rollupjs.org/guide/en/#outputinterop'
     };
 }
 function errUnexpectedNamespaceReexport(id) {
     return {
-        code: Errors.UNEXPECTED_NAMED_IMPORT,
-        id,
-        message: `There was a namespace "*" reexport from the external module ${relativeId(id)} even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `There was a namespace "*" reexport from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
         url: 'https://rollupjs.org/guide/en/#outputinterop'
     };
 }
+function errUnknownOption(optionType, unknownOptions, validOptions) {
+    return {
+        code: UNKNOWN_OPTION,
+        message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.join(', ')}`
+    };
+}
 function errEntryCannotBeExternal(unresolvedId) {
     return {
-        code: Errors.UNRESOLVED_ENTRY,
-        message: `Entry module cannot be external (${relativeId(unresolvedId)}).`
+        code: UNRESOLVED_ENTRY,
+        message: `Entry module "${relativeId(unresolvedId)}" cannot be external.`
     };
 }
 function errUnresolvedEntry(unresolvedId) {
     return {
-        code: Errors.UNRESOLVED_ENTRY,
-        message: `Could not resolve entry module (${relativeId(unresolvedId)}).`
+        code: UNRESOLVED_ENTRY,
+        message: `Could not resolve entry module "${relativeId(unresolvedId)}".`
     };
 }
 function errUnresolvedImport(source, importer) {
     return {
-        code: Errors.UNRESOLVED_IMPORT,
-        message: `Could not resolve '${source}' from ${relativeId(importer)}`
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `Could not resolve "${source}" from "${relativeId(importer)}"`
     };
 }
 function errUnresolvedImportTreatedAsExternal(source, importer) {
     return {
-        code: Errors.UNRESOLVED_IMPORT,
-        importer: relativeId(importer),
-        message: `'${source}' is imported by ${relativeId(importer)}, but could not be resolved – treating it as an external dependency`,
-        source,
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `"${source}" is imported by "${relativeId(importer)}", but could not be resolved – treating it as an external dependency.`,
         url: 'https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency'
     };
 }
-function errExternalSyntheticExports(source, importer) {
+function errUnusedExternalImports(externalId, names, importers) {
     return {
-        code: Errors.EXTERNAL_SYNTHETIC_EXPORTS,
-        importer: relativeId(importer),
-        message: `External '${source}' can not have 'syntheticNamedExports' enabled.`,
-        source
+        code: UNUSED_EXTERNAL_IMPORT,
+        exporter: externalId,
+        ids: importers,
+        message: `${printQuotedStringList(names, [
+            'is',
+            'are'
+        ])} imported from external module "${externalId}" but never used in ${printQuotedStringList(importers.map(importer => relativeId(importer)))}.`,
+        names
     };
 }
 function errFailedValidation(message) {
     return {
-        code: Errors.VALIDATION_ERROR,
+        code: VALIDATION_ERROR,
         message
     };
 }
-function errAlreadyClosed() {
-    return {
-        code: Errors.ALREADY_CLOSED,
-        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
-    };
-}
 function warnDeprecation(deprecation, activeDeprecation, options) {
     warnDeprecationWithOptions(deprecation, activeDeprecation, options.onwarn, options.strictDeprecations);
 }
@@ -560,14 +773,7 @@ function warnUnknownOptions(passedOptions, validOptions, optionType, warn, ignor
     const validOptionSet = new Set(validOptions);
     const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
     if (unknownOptions.length > 0) {
-        warn({
-            code: 'UNKNOWN_OPTION',
-            message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${[
-                ...validOptionSet
-            ]
-                .sort()
-                .join(', ')}`
-        });
+        warn(errUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
     }
 }
 const treeshakePresets = {
@@ -2161,7 +2367,7 @@ class ExternalChunk {
         const { paths } = this.options;
         return (this.fileName =
             (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
-                (this.renormalizeRenderPath ? normalize(require$$0.relative(this.inputBase, this.id)) : this.id));
+                (this.renormalizeRenderPath ? normalize(node_path.relative(this.inputBase, this.id)) : this.id));
     }
     getImportPath(importer) {
         return escapeId(this.renormalizeRenderPath
@@ -2529,13 +2735,7 @@ class ExternalModule {
             }
         }
         const importersArray = [...importersSet];
-        this.options.onwarn({
-            code: 'UNUSED_EXTERNAL_IMPORT',
-            message: `${printQuotedStringList(unused, ['is', 'are'])} imported from external module "${this.id}" but never used in ${printQuotedStringList(importersArray.map(importer => relativeId(importer)))}.`,
-            names: unused,
-            source: this.id,
-            sources: importersArray
-        });
+        this.options.onwarn(errUnusedExternalImports(this.id, unused, importersArray));
     }
 }
 
@@ -5240,10 +5440,10 @@ const SequenceExpression$1 = 'SequenceExpression';
 
 // this looks ridiculous, but it prevents sourcemap tooling from mistaking
 // this for an actual sourceMappingURL
-exports.SOURCEMAPPING_URL = 'sourceMa';
-exports.SOURCEMAPPING_URL += 'ppingURL';
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
 const whiteSpaceNoNewline = '[ \\f\\r\\t\\v\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]';
-const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${exports.SOURCEMAPPING_URL}=.+`);
+const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${SOURCEMAPPING_URL}=.+`);
 
 const ANNOTATION_KEY = '_rollupAnnotations';
 const INVALID_COMMENT_KEY = '_rollupRemoved';
@@ -7734,10 +7934,7 @@ class Identifier extends NodeBase {
         }
     }
     disallowImportReassignment() {
-        return this.context.error({
-            code: 'ILLEGAL_REASSIGNMENT',
-            message: `Illegal reassignment to import '${this.name}'`
-        }, this.start);
+        return this.context.error(errIllegalImportReassignment(this.name, this.context.module.id), this.start);
     }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
@@ -7933,10 +8130,7 @@ class ExpressionStatement extends NodeBase {
             this.parent.type === Program$1) {
             this.context.warn(
             // This is necessary, because either way (deleting or not) can lead to errors.
-            {
-                code: 'MODULE_LEVEL_DIRECTIVE',
-                message: `Module level directives cause errors when bundled, '${this.directive}' was ignored.`
-            }, this.start);
+            errModuleLevelDirective(this.directive, this.context.module.id), this.start);
         }
     }
     render(code, options) {
@@ -8950,10 +9144,7 @@ class MemberExpression extends NodeBase {
                 if (this.variable) {
                     this.context.includeVariableInModule(this.variable);
                 }
-                this.context.warn({
-                    code: 'ILLEGAL_NAMESPACE_REASSIGNMENT',
-                    message: `Illegal reassignment to import '${this.object.name}'`
-                }, this.start);
+                this.context.warn(errIllegalImportReassignment(this.object.name, this.context.module.id), this.start);
             }
         }
     }
@@ -8993,14 +9184,7 @@ function resolveNamespaceVariables(baseVariable, path, astContext) {
     const variable = baseVariable.context.traceExport(exportName);
     if (!variable) {
         const fileName = baseVariable.context.fileName;
-        astContext.warn({
-            code: 'MISSING_EXPORT',
-            exporter: relativeId(fileName),
-            importer: relativeId(astContext.fileName),
-            message: `'${exportName}' is not exported by '${relativeId(fileName)}'`,
-            missing: exportName,
-            url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
-        }, path[0].pos);
+        astContext.warn(errMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
         return 'undefined';
     }
     return resolveNamespaceVariables(variable, path.slice(1), astContext);
@@ -9090,17 +9274,10 @@ class CallExpression extends CallExpressionBase {
         if (this.callee instanceof Identifier) {
             const variable = this.scope.findVariable(this.callee.name);
             if (variable.isNamespace) {
-                this.context.warn({
-                    code: 'CANNOT_CALL_NAMESPACE',
-                    message: `Cannot call a namespace ('${this.callee.name}')`
-                }, this.start);
+                this.context.warn(errCannotCallNamespace(this.callee.name), this.start);
             }
             if (this.callee.name === 'eval') {
-                this.context.warn({
-                    code: 'EVAL',
-                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
-                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
-                }, this.start);
+                this.context.warn(errEval(this.context.module.id), this.start);
             }
         }
         this.interaction = {
@@ -9145,10 +9322,6 @@ class CallExpression extends CallExpressionBase {
             this.callee.include(context, false);
         }
         this.callee.includeCallArguments(context, this.arguments);
-        const returnExpression = this.getReturnExpression();
-        if (!returnExpression.included) {
-            returnExpression.include(context, false);
-        }
     }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         this.callee.render(code, options, {
@@ -9518,15 +9691,6 @@ class MultiExpression extends ExpressionEntity {
         }
         return false;
     }
-    include(context, includeChildrenRecursively) {
-        // This is only relevant to include values that do not have an AST representation,
-        // such as UnknownArrayExpression. Thus we only need to include them once.
-        for (const expression of this.expressions) {
-            if (!expression.included) {
-                expression.include(context, includeChildrenRecursively);
-            }
-        }
-    }
 }
 
 class ConditionalExpression extends NodeBase {
@@ -10447,6 +10611,7 @@ class ImportExpression extends NodeBase {
     }
     setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName) {
         const { format } = options;
+        this.inlineNamespace = null;
         this.resolution = resolution;
         this.resolutionString = resolutionString;
         this.namespaceExportName = namespaceExportName;
@@ -10787,7 +10952,7 @@ class MetaProperty extends NodeBase {
         const chunkId = this.preliminaryChunkId;
         if (referenceId) {
             const fileName = pluginDriver.getFileName(referenceId);
-            const relativePath = normalize(require$$0.relative(require$$0.dirname(chunkId), fileName));
+            const relativePath = normalize(node_path.relative(node_path.dirname(chunkId), fileName));
             const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
                 {
                     chunkId,
@@ -11357,10 +11522,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
             const name = this.tag.name;
             const variable = this.scope.findVariable(name);
             if (variable.isNamespace) {
-                this.context.warn({
-                    code: 'CANNOT_CALL_NAMESPACE',
-                    message: `Cannot call a namespace ('${name}')`
-                }, this.start);
+                this.context.warn(errCannotCallNamespace(name), this.start);
             }
         }
     }
@@ -11610,11 +11772,7 @@ class ThisExpression extends NodeBase {
         this.alias =
             this.scope.findLexicalBoundary() instanceof ModuleScope ? this.context.moduleContext : null;
         if (this.alias === 'undefined') {
-            this.context.warn({
-                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: `https://rollupjs.org/guide/en/#error-this-is-undefined`
-            }, this.start);
+            this.context.warn(errThisIsUndefined(), this.start);
         }
     }
     render(code) {
@@ -12304,7 +12462,7 @@ function getPersistedLabel(label, level) {
 function timeStartImpl(label, level = 3) {
     label = getPersistedLabel(label, level);
     const startMemory = process$1.memoryUsage().heapUsed;
-    const startTime = perf_hooks.performance.now();
+    const startTime = node_perf_hooks.performance.now();
     const timer = timers.get(label);
     if (timer === undefined) {
         timers.set(label, {
@@ -12326,7 +12484,7 @@ function timeEndImpl(label, level = 3) {
     if (timer !== undefined) {
         const currentMemory = process$1.memoryUsage().heapUsed;
         timer.memory += currentMemory - timer.startMemory;
-        timer.time += perf_hooks.performance.now() - timer.startTime;
+        timer.time += node_perf_hooks.performance.now() - timer.startTime;
         timer.totalMemory = Math.max(timer.totalMemory, currentMemory);
     }
 }
@@ -12339,7 +12497,26 @@ function getTimings() {
 }
 let timeStart = NOOP;
 let timeEnd = NOOP;
-const TIMED_PLUGIN_HOOKS = ['load', 'resolveDynamicImport', 'resolveId', 'transform'];
+const TIMED_PLUGIN_HOOKS = [
+    'augmentChunkHash',
+    'buildEnd',
+    'buildStart',
+    'generateBundle',
+    'load',
+    'moduleParsed',
+    'options',
+    'outputOptions',
+    'renderChunk',
+    'renderDynamicImport',
+    'renderStart',
+    'resolveDynamicImport',
+    'resolveFileUrl',
+    'resolveId',
+    'resolveImportMeta',
+    'shouldTransformCachedModule',
+    'transform',
+    'writeBundle'
+];
 function getPluginWithTimers(plugin, index) {
     for (const hook of TIMED_PLUGIN_HOOKS) {
         if (hook in plugin) {
@@ -12353,13 +12530,6 @@ function getPluginWithTimers(plugin, index) {
                 timeStart(timerLabel, 4);
                 const result = func.apply(this, args);
                 timeEnd(timerLabel, 4);
-                if (result && typeof result.then === 'function') {
-                    timeStart(`${timerLabel} (async)`, 4);
-                    return result.then((hookResult) => {
-                        timeEnd(`${timerLabel} (async)`, 4);
-                        return hookResult;
-                    });
-                }
                 return result;
             };
         }
@@ -12554,8 +12724,8 @@ class Module {
         });
     }
     basename() {
-        const base = require$$0.basename(this.id);
-        const ext = require$$0.extname(this.id);
+        const base = node_path.basename(this.id);
+        const ext = node_path.extname(this.id);
         return makeLegal(ext ? base.slice(0, -ext.length) : base);
     }
     bindReferences() {
@@ -12837,6 +13007,7 @@ class Module {
         return { source, usesTopLevelAwait };
     }
     setSource({ ast, code, customTransformCache, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles, ...moduleOptions }) {
+        timeStart('generate ast', 3);
         this.info.code = code;
         this.originalCode = originalCode;
         this.originalSourcemap = originalSourcemap;
@@ -12847,11 +13018,11 @@ class Module {
         this.transformDependencies = transformDependencies;
         this.customTransformCache = customTransformCache;
         this.updateOptions(moduleOptions);
-        timeStart('generate ast', 3);
         if (!ast) {
             ast = this.tryParse();
         }
         timeEnd('generate ast', 3);
+        timeStart('analyze ast', 3);
         this.resolvedIds = resolvedIds || Object.create(null);
         // By default, `id` is the file name. Custom resolvers and loaders
         // can change that, but it makes sense to use it for the source file name
@@ -12860,7 +13031,6 @@ class Module {
             filename: (this.excludeFromSourcemap ? null : fileName),
             indentExclusionRanges: []
         });
-        timeStart('analyse ast', 3);
         this.astContext = {
             addDynamicImport: this.addDynamicImport.bind(this),
             addExport: this.addExport.bind(this),
@@ -12893,7 +13063,7 @@ class Module {
         this.namespace = new NamespaceVariable(this.astContext);
         this.ast = new Program(ast, { context: this.astContext, type: 'Module' }, this.scope);
         this.info.ast = ast;
-        timeEnd('analyse ast', 3);
+        timeEnd('analyze ast', 3);
     }
     toJSON() {
         return {
@@ -12937,18 +13107,7 @@ class Module {
             return this.graph.contextParse(this.info.code);
         }
         catch (err) {
-            let message = err.message.replace(/ \(\d+:\d+\)$/, '');
-            if (this.id.endsWith('.json')) {
-                message += ' (Note that you need @rollup/plugin-json to import JSON files)';
-            }
-            else if (!this.id.endsWith('.js')) {
-                message += ' (Note that you need plugins to import files that are not JavaScript)';
-            }
-            return this.error({
-                code: 'PARSE_ERROR',
-                message,
-                parserError: err
-            }, err.pos);
+            return this.error(errParseError(err, this.id), err.pos);
         }
     }
     updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
@@ -13074,17 +13233,7 @@ class Module {
                 code = this.originalCode;
             }
             catch (err) {
-                this.options.onwarn({
-                    code: 'SOURCEMAP_ERROR',
-                    id: this.id,
-                    loc: {
-                        column,
-                        file: this.id,
-                        line
-                    },
-                    message: `Error when using sourcemap for reporting an error: ${err.message}`,
-                    pos
-                });
+                this.options.onwarn(errInvalidSourcemapForError(err, this.id, column, line, pos));
             }
             augmentCodeLocation(props, { column, line }, code, this.id);
         }
@@ -13222,12 +13371,7 @@ class Module {
         }
     }
     shimMissingExport(name) {
-        this.options.onwarn({
-            code: 'SHIMMED_EXPORT',
-            exporter: relativeId(this.id),
-            exportName: name,
-            message: `Missing export "${name}" has been shimmed in module ${relativeId(this.id)}.`
-        });
+        this.options.onwarn(errShimmedExport(this.id, name));
         this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
 }
@@ -13464,39 +13608,35 @@ function removeExtensionFromRelativeAmdId(id) {
 }
 
 const builtins = {
-    assert: true,
-    buffer: true,
-    console: true,
-    constants: true,
-    domain: true,
-    events: true,
-    http: true,
-    https: true,
-    os: true,
-    path: true,
-    process: true,
-    punycode: true,
-    querystring: true,
-    stream: true,
-    string_decoder: true,
-    timers: true,
-    tty: true,
-    url: true,
-    util: true,
-    vm: true,
-    zlib: true
+    assert: 1,
+    buffer: 1,
+    console: 1,
+    constants: 1,
+    domain: 1,
+    events: 1,
+    http: 1,
+    https: 1,
+    os: 1,
+    path: 1,
+    process: 1,
+    punycode: 1,
+    querystring: 1,
+    stream: 1,
+    string_decoder: 1,
+    timers: 1,
+    tty: 1,
+    url: 1,
+    util: 1,
+    vm: 1,
+    zlib: 1
 };
 function warnOnBuiltins(warn, dependencies) {
     const externalBuiltins = dependencies
         .map(({ importPath }) => importPath)
-        .filter(importPath => importPath in builtins);
+        .filter(importPath => importPath in builtins || importPath.startsWith('node:'));
     if (!externalBuiltins.length)
         return;
-    warn({
-        code: 'MISSING_NODE_BUILTINS',
-        message: `Creating a browser bundle that depends on Node.js built-in modules (${printQuotedStringList(externalBuiltins)}). You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`,
-        modules: externalBuiltins
-    });
+    warn(errMissingNodeBuiltins(externalBuiltins));
 }
 
 function amd(magicString, { accessedGlobals, dependencies, exports, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets, onwarn }, { amd, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
@@ -13734,24 +13874,18 @@ function trimEmptyImports(dependencies) {
 }
 
 function iife(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, namedExportsMode, outro, snippets, onwarn }, { compact, esModule, extend, freeze, externalLiveBindings, globals, interop, name, namespaceToStringTag, strict }) {
-    const { _, cnst, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
+    const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
     const isNamespaced = name && name.includes('.');
     const useVariableAssignment = !extend && !isNamespaced;
     if (name && useVariableAssignment && !isLegal(name)) {
-        return error({
-            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".`
-        });
+        return error(errIllegalIdentifierAsName(name));
     }
     warnOnBuiltins(onwarn, dependencies);
     const external = trimEmptyImports(dependencies);
     const deps = external.map(dep => dep.globalName || 'null');
     const args = external.map(m => m.name);
     if (hasExports && !name) {
-        onwarn({
-            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.`
-        });
+        onwarn(errMissingNameOptionForIifeExport());
     }
     if (namedExportsMode && hasExports) {
         if (extend) {
@@ -13773,7 +13907,7 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (hasExports) {
         if (name && !(extend && namedExportsMode)) {
             wrapperIntro =
-                (useVariableAssignment ? `${cnst} ${name}` : `this${keypath(name, getPropertyAccess)}`) +
+                (useVariableAssignment ? `var ${name}` : `this${keypath(name, getPropertyAccess)}`) +
                     `${_}=${_}${wrapperIntro}`;
         }
         if (isNamespaced) {
@@ -13945,10 +14079,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
     const factoryVar = compact ? 'f' : 'factory';
     const globalVar = compact ? 'g' : 'global';
     if (hasExports && !name) {
-        return error({
-            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.'
-        });
+        return error(errMissingNameOptionForUmdExport());
     }
     warnOnBuiltins(onwarn, dependencies);
     const amdDeps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.importPath)}'`);
@@ -14039,7 +14170,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
 
 const finalisers = { amd, cjs, es, iife, system, umd };
 
-const createHash = () => crypto.createHash('sha256');
+const createHash = () => node_crypto.createHash('sha256');
 
 // Four random characters from the private use area to minimize risk of conflicts
 const hashPlaceholderLeft = '\uf7f9\ue4d3';
@@ -14094,7 +14225,7 @@ function makeUnique(name, existingNames) {
     const existingNamesLowercase = new Set(Object.keys(existingNames).map(key => key.toLowerCase()));
     if (!existingNamesLowercase.has(name.toLocaleLowerCase()))
         return name;
-    const ext = require$$0.extname(name);
+    const ext = node_path.extname(name);
     name = name.substring(0, name.length - ext.length);
     let uniqueName, uniqueIndex = 1;
     while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
@@ -14107,13 +14238,13 @@ function generateAssetFileName(name, source, outputOptions, bundle) {
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
         ? outputOptions.assetFileNames({ name, source, type: 'asset' })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => require$$0.extname(emittedName).substring(1),
-        extname: () => require$$0.extname(emittedName),
+        ext: () => node_path.extname(emittedName).substring(1),
+        extname: () => node_path.extname(emittedName),
         hash: size => createHash()
             .update(source)
             .digest('hex')
             .substring(0, size || defaultHashSize),
-        name: () => emittedName.substring(0, emittedName.length - require$$0.extname(emittedName).length)
+        name: () => emittedName.substring(0, emittedName.length - node_path.extname(emittedName).length)
     }), bundle);
 }
 function reserveFileNameInBundle(fileName, bundle, warn) {
@@ -14602,19 +14733,14 @@ function addStaticDependencies(module, staticDependencies, handledModules, chunk
     }
 }
 
-const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
+const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.mts', '.cjs', '.cts'];
 function getGlobalName(chunk, globals, hasExports, warn) {
     const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
     if (globalName) {
         return globalName;
     }
     if (hasExports) {
-        warn({
-            code: 'MISSING_GLOBAL_NAME',
-            guess: chunk.variableName,
-            message: `No name was provided for external module '${chunk.id}' in output.globals – guessing '${chunk.variableName}'`,
-            source: chunk.id
-        });
+        warn(errMissingGlobalName(chunk.id, chunk.variableName));
         return chunk.variableName;
     }
 }
@@ -14719,17 +14845,6 @@ class Chunk {
         const moduleExportNamesByVariable = module.getExportNamesByVariable();
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
-                if (moduleExportNamesByVariable.size === 0 &&
-                    module.isUserDefinedEntryPoint &&
-                    module.preserveSignature === 'strict' &&
-                    this.unsetOptions.has('preserveEntrySignatures')) {
-                    this.inputOptions.onwarn({
-                        code: 'EMPTY_FACADE',
-                        id: module.id,
-                        message: `To preserve the export signature of the entry module "${relativeId(module.id)}", an empty facade chunk was created. This often happens when creating a bundle for a web app where chunks are placed in script tags and exports are ignored. In this case it is recommended to set "preserveEntrySignatures: false" to avoid this and reduce the number of chunks. Otherwise if this is intentional, set "preserveEntrySignatures: 'strict'" explicitly to silence this warning.`,
-                        url: 'https://rollupjs.org/guide/en/#preserveentrysignatures'
-                    });
-                }
                 return false;
             }
         }
@@ -14800,7 +14915,7 @@ class Chunk {
                     if (module.preserveSignature) {
                         this.strictFacade = needsStrictFacade;
                     }
-                    this.assignFacadeName(requiredFacades.shift(), module);
+                    this.assignFacadeName(requiredFacades.shift(), module, this.outputOptions.preserveModules);
                 }
             }
             for (const facadeName of requiredFacades) {
@@ -14865,6 +14980,7 @@ class Chunk {
         return escapeId(getImportPath(importer, this.getFileName(), this.outputOptions.format === 'amd', true));
     }
     getPreliminaryFileName() {
+        var _a;
         if (this.preliminaryFileName) {
             return this.preliminaryFileName;
         }
@@ -14872,16 +14988,13 @@ class Chunk {
         let hashPlaceholder = null;
         const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
         if (file) {
-            fileName = require$$0.basename(file);
-        }
-        else if (preserveModules) {
-            fileName = this.generateIdPreserveModules();
+            fileName = node_path.basename(file);
         }
         else if (this.fileName !== null) {
             fileName = this.fileName;
         }
         else {
-            const [pattern, patternName] = this.facadeModule && this.facadeModule.isUserDefinedEntryPoint
+            const [pattern, patternName] = preserveModules || ((_a = this.facadeModule) === null || _a === void 0 ? void 0 : _a.isUserDefinedEntryPoint)
                 ? [entryFileNames, 'output.entryFileNames']
                 : [chunkFileNames, 'output.chunkFileNames'];
             fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
@@ -14941,13 +15054,10 @@ class Chunk {
         }
         const preliminaryFileName = this.getPreliminaryFileName();
         const { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait } = this.renderModules(preliminaryFileName.fileName);
-        timeStart('render format', 2);
         const renderedDependencies = [...this.getRenderedDependencies().values()];
         const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
         const hasExports = renderedExports.length !== 0 ||
             renderedDependencies.some(dep => (dep.reexports && dep.reexports.length !== 0));
-        // TODO Lukas Note: Mention in docs, that users/plugins are responsible to do their own caching
-        // TODO Lukas adapt plugin hook graphs and order in docs
         const { intro, outro, banner, footer } = await createAddons(outputOptions, pluginDriver, this.getRenderedChunkInfo());
         finalisers[format](renderedSource, {
             accessedGlobals,
@@ -14969,7 +15079,6 @@ class Chunk {
             magicString.prepend(banner);
         if (footer)
             magicString.append(footer);
-        timeEnd('render format', 2);
         return {
             chunk: this,
             magicString,
@@ -14995,12 +15104,15 @@ class Chunk {
             }
         }
     }
-    assignFacadeName({ fileName, name }, facadedModule) {
+    assignFacadeName({ fileName, name }, facadedModule, preservePath) {
         if (fileName) {
             this.fileName = fileName;
         }
         else {
-            this.name = this.outputOptions.sanitizeFileName(name || getChunkNameFromModule(facadedModule));
+            this.name = this.outputOptions.sanitizeFileName(name ||
+                (preservePath
+                    ? this.getPreserveModulesChunkNameFromModule(facadedModule)
+                    : getChunkNameFromModule(facadedModule)));
         }
     }
     checkCircularDependencyImport(variable, importingModule) {
@@ -15047,46 +15159,6 @@ class Chunk {
             this.includedReexportsByModule.set(module, includedReexports);
         }
     }
-    generateIdPreserveModules() {
-        const [{ id }] = this.orderedModules;
-        const { entryFileNames, format, preserveModulesRoot, sanitizeFileName } = this.outputOptions;
-        const sanitizedId = sanitizeFileName(id.split(QUERY_HASH_REGEX, 1)[0]);
-        let path;
-        const patternOpt = this.unsetOptions.has('entryFileNames')
-            ? '[name][assetExtname].js'
-            : entryFileNames;
-        const pattern = typeof patternOpt === 'function' ? patternOpt(this.getPreRenderedChunkInfo()) : patternOpt;
-        if (isAbsolute(sanitizedId)) {
-            const currentDir = require$$0.dirname(sanitizedId);
-            const extension = require$$0.extname(sanitizedId);
-            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
-                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
-                ext: () => extension.substring(1),
-                extname: () => extension,
-                format: () => format,
-                name: () => this.getChunkName()
-            });
-            const currentPath = `${currentDir}/${fileName}`;
-            if (preserveModulesRoot && currentPath.startsWith(preserveModulesRoot)) {
-                path = currentPath.slice(preserveModulesRoot.length).replace(/^[\\/]/, '');
-            }
-            else {
-                path = relative(this.inputBase, currentPath);
-            }
-        }
-        else {
-            const extension = require$$0.extname(sanitizedId);
-            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
-                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
-                ext: () => extension.substring(1),
-                extname: () => extension,
-                format: () => format,
-                name: () => getAliasName(sanitizedId)
-            });
-            path = `_virtual/${fileName}`;
-        }
-        return makeUnique(normalize(path), this.bundle);
-    }
     generateVariableName() {
         if (this.manualChunkAlias) {
             return this.manualChunkAlias;
@@ -15275,6 +15347,25 @@ class Chunk {
             type: 'chunk'
         });
     }
+    getPreserveModulesChunkNameFromModule(module) {
+        const predefinedChunkName = getPredefinedChunkNameFromModule(module);
+        if (predefinedChunkName)
+            return predefinedChunkName;
+        const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
+        const sanitizedId = sanitizeFileName(module.id.split(QUERY_HASH_REGEX, 1)[0]);
+        const extName = node_path.extname(sanitizedId);
+        const idWithoutExtension = NON_ASSET_EXTENSIONS.includes(extName)
+            ? sanitizedId.slice(0, -extName.length)
+            : sanitizedId;
+        if (isAbsolute(idWithoutExtension)) {
+            return preserveModulesRoot && node_path.resolve(idWithoutExtension).startsWith(preserveModulesRoot)
+                ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[\\/]/, '')
+                : relative(this.inputBase, idWithoutExtension);
+        }
+        else {
+            return `_virtual/${node_path.basename(idWithoutExtension)}`;
+        }
+    }
     getReexportSpecifiers() {
         const { externalLiveBindings, interop } = this.outputOptions;
         const reexportSpecifiers = new Map();
@@ -15447,12 +15538,7 @@ class Chunk {
         }
         const renderedSource = compact ? magicString : magicString.trim();
         if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
-            const chunkName = this.getChunkName();
-            onwarn({
-                chunkName,
-                code: 'EMPTY_BUNDLE',
-                message: `Generated an empty chunk: "${chunkName}"`
-            });
+            onwarn(errEmptyChunk(this.getChunkName()));
         }
         return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
     }
@@ -15581,8 +15667,12 @@ class Chunk {
     }
 }
 function getChunkNameFromModule(module) {
-    var _a, _b, _c, _d;
-    return ((_d = (_b = (_a = module.chunkNames.find(({ isUserDefined }) => isUserDefined)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = module.chunkNames[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : getAliasName(module.id));
+    var _a;
+    return (_a = getPredefinedChunkNameFromModule(module)) !== null && _a !== void 0 ? _a : getAliasName(module.id);
+}
+function getPredefinedChunkNameFromModule(module) {
+    var _a, _b, _c;
+    return ((_b = (_a = module.chunkNames.find(({ isUserDefined }) => isUserDefined)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = module.chunkNames[0]) === null || _c === void 0 ? void 0 : _c.name);
 }
 function getImportedBindingsPerDependency(renderedDependencies, resolveFileName) {
     const importedBindingsPerDependency = {};
@@ -15745,7 +15835,7 @@ function commondir(files) {
     if (files.length === 0)
         return '/';
     if (files.length === 1)
-        return require$$0.dirname(files[0]);
+        return node_path.dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegements = file.split(/\/+|\\+/);
         let i;
@@ -15810,12 +15900,12 @@ function analyseModuleExecution(entryModules) {
 }
 function getCyclePath(module, parent, parents) {
     const cycleSymbol = Symbol(module.id);
-    const path = [relativeId(module.id)];
+    const path = [module.id];
     let nextModule = parent;
     module.cycles.add(cycleSymbol);
     while (nextModule !== module) {
         nextModule.cycles.add(cycleSymbol);
-        path.push(relativeId(nextModule.id));
+        path.push(nextModule.id);
         nextModule = parents.get(nextModule);
     }
     path.push(path[0]);
@@ -15987,14 +16077,7 @@ function getLinkMap(warn) {
         if (map.mappings) {
             return new Link(map, [source]);
         }
-        warn({
-            code: 'SOURCEMAP_BROKEN',
-            message: `Sourcemap is likely to be incorrect: a plugin (${map.plugin}) was used to transform ` +
-                "files, but didn't generate a sourcemap for the transformation. Consult the plugin " +
-                'documentation for help',
-            plugin: map.plugin,
-            url: `https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect`
-        });
+        warn(errSourcemapBroken(map.plugin));
         return new Link({
             mappings: [],
             names: []
@@ -16009,9 +16092,9 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
     else {
         const sources = originalSourcemap.sources;
         const sourcesContent = originalSourcemap.sourcesContent || [];
-        const directory = require$$0.dirname(id) || '.';
+        const directory = node_path.dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
-        const baseSources = sources.map((source, i) => new Source(require$$0.resolve(directory, sourceRoot, source), sourcesContent[i]));
+        const baseSources = sources.map((source, i) => new Source(node_path.resolve(directory, sourceRoot, source), sourcesContent[i]));
         source = new Link(originalSourcemap, baseSources);
     }
     return sourcemapChain.reduce(linkMap, source);
@@ -16025,9 +16108,9 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     const source = bundleSourcemapChain.reduce(linkMap, link);
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
-        const directory = require$$0.dirname(file);
-        sources = sources.map((source) => require$$0.relative(directory, source));
-        file = require$$0.basename(file);
+        const directory = node_path.dirname(file);
+        sources = sources.map((source) => node_path.relative(directory, source));
+        file = node_path.basename(file);
     }
     sourcesContent = (excludeContent ? null : sourcesContent);
     return new SourceMap({ file, mappings, names, sources, sourcesContent });
@@ -16060,12 +16143,16 @@ function decodedSourcemap(map) {
 }
 
 async function renderChunks(chunks, outputBundle, pluginDriver, outputOptions, onwarn) {
+    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 hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle);
-    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
+    timeEnd('transform chunks', 2);
 }
 function reserveEntryChunksInBundle(chunks) {
     for (const chunk of chunks) {
@@ -16103,14 +16190,14 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
     if (!compact && code[code.length - 1] !== '\n')
         code += '\n';
     if (sourcemap) {
-        timeStart('sourcemap', 2);
+        timeStart('sourcemaps', 3);
         let file;
         if (options.file)
-            file = require$$0.resolve(options.sourcemapFile || options.file);
+            file = node_path.resolve(options.sourcemapFile || options.file);
         else if (options.dir)
-            file = require$$0.resolve(options.dir, fileName);
+            file = node_path.resolve(options.dir, fileName);
         else
-            file = require$$0.resolve(fileName);
+            file = node_path.resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
         map = collapseSourcemaps(file, decodedMap, usedModules, sourcemapChain, options.sourcemapExcludeSources, onwarn);
         map.sources = map.sources
@@ -16125,7 +16212,7 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
             return sourcePath;
         })
             .map(normalize);
-        timeEnd('sourcemap', 2);
+        timeEnd('sourcemaps', 3);
     }
     return {
         code,
@@ -16208,22 +16295,40 @@ function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlac
     }
     return hashesByPlaceholder;
 }
-function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders) {
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
     for (const { chunk, code, fileName, map } of renderedChunksByPlaceholder.values()) {
-        const updatedCode = replacePlaceholders(code, hashesByPlaceholder);
+        let updatedCode = replacePlaceholders(code, hashesByPlaceholder);
         const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
         if (map) {
             map.file = replacePlaceholders(map.file, hashesByPlaceholder);
+            updatedCode += emitSourceMapAndGetComment(finalFileName, map, pluginDriver, options);
         }
         outputBundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
     for (const { chunk, code, fileName, map } of nonHashedChunksWithPlaceholders) {
-        const updatedCode = hashesByPlaceholder.size
+        let updatedCode = hashesByPlaceholder.size
             ? replacePlaceholders(code, hashesByPlaceholder)
             : code;
+        if (map) {
+            updatedCode += emitSourceMapAndGetComment(fileName, map, pluginDriver, options);
+        }
         outputBundle[fileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
 }
+function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, sourcemapBaseUrl }) {
+    let url;
+    if (sourcemap === 'inline') {
+        url = map.toUrl();
+    }
+    else {
+        const sourcemapFileName = `${node_path.basename(fileName)}.map`;
+        url = sourcemapBaseUrl
+            ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
+            : sourcemapFileName;
+        pluginDriver.emitFile({ fileName: `${fileName}.map`, source: map.toString(), type: 'asset' });
+    }
+    return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
+}
 
 class Bundle {
     constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
@@ -16239,9 +16344,10 @@ class Bundle {
         timeStart('GENERATE', 1);
         const outputBundle = Object.create(null);
         this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions);
-        // TODO Lukas rethink time measuring points
         try {
+            timeStart('initialize render', 2);
             await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
+            timeEnd('initialize render', 2);
             timeStart('generate chunks', 2);
             const getHashPlaceholder = getHashPlaceholderGenerator();
             const chunks = await this.generateChunks(outputBundle, getHashPlaceholder);
@@ -16249,24 +16355,24 @@ class Bundle {
                 validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onwarn);
             }
             this.pluginDriver.setChunkInformation(this.facadeChunkByModule);
-            timeEnd('generate chunks', 2);
-            timeStart('render chunks', 2);
             for (const chunk of chunks) {
                 chunk.generateExports();
             }
+            timeEnd('generate chunks', 2);
             await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onwarn);
-            timeEnd('render chunks', 2);
         }
         catch (err) {
             await this.pluginDriver.hookParallel('renderError', [err]);
             throw err;
         }
+        timeStart('generate bundle', 2);
         await this.pluginDriver.hookSeq('generateBundle', [
             this.outputOptions,
             outputBundle,
             isWrite
         ]);
         this.finaliseAssets(outputBundle);
+        timeEnd('generate bundle', 2);
         timeEnd('GENERATE', 1);
         return outputBundle;
     }
@@ -21946,37 +22052,6 @@ Parser.acorn = {
   nonASCIIwhitespace: nonASCIIwhitespace
 };
 
-class Queue {
-    constructor(maxParallel) {
-        this.maxParallel = maxParallel;
-        this.queue = [];
-        this.workerCount = 0;
-    }
-    run(task) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({ reject, resolve, task });
-            this.work();
-        });
-    }
-    async work() {
-        if (this.workerCount >= this.maxParallel)
-            return;
-        this.workerCount++;
-        let entry;
-        while ((entry = this.queue.shift())) {
-            const { reject, resolve, task } = entry;
-            try {
-                const result = await task();
-                resolve(result);
-            }
-            catch (err) {
-                reject(err);
-            }
-        }
-        this.workerCount--;
-    }
-}
-
 function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry) {
     let skipped = null;
     let replaceContext = null;
@@ -22009,7 +22084,7 @@ async function resolveId(source, importer, preserveSymlinks, pluginDriver, modul
     // absolute path is created. Absolute importees therefore shortcircuit the
     // resolve call and require no special handing on our part.
     // See https://nodejs.org/api/path.html#path_path_resolve_paths
-    return addJsExtensionIfNecessary(importer ? require$$0.resolve(require$$0.dirname(importer), source) : require$$0.resolve(source), preserveSymlinks);
+    return addJsExtensionIfNecessary(importer ? node_path.resolve(node_path.dirname(importer), source) : node_path.resolve(source), preserveSymlinks);
 }
 async function addJsExtensionIfNecessary(file, preserveSymlinks) {
     var _a, _b;
@@ -22017,13 +22092,13 @@ async function addJsExtensionIfNecessary(file, preserveSymlinks) {
 }
 async function findFile(file, preserveSymlinks) {
     try {
-        const stats = await require$$0$1.promises.lstat(file);
+        const stats = await node_fs.promises.lstat(file);
         if (!preserveSymlinks && stats.isSymbolicLink())
-            return await findFile(await require$$0$1.promises.realpath(file), preserveSymlinks);
+            return await findFile(await node_fs.promises.realpath(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
-            const name = require$$0.basename(file);
-            const files = await require$$0$1.promises.readdir(require$$0.dirname(file));
+            const name = node_path.basename(file);
+            const files = await node_fs.promises.readdir(node_path.dirname(file));
             if (files.includes(name))
                 return file;
         }
@@ -22035,22 +22110,6 @@ async function findFile(file, preserveSymlinks) {
 
 const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
 const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
-function throwPluginError(err, plugin, { hook, id } = {}) {
-    if (typeof err === 'string')
-        err = { message: err };
-    if (err.code && err.code !== Errors.PLUGIN_ERROR) {
-        err.pluginCode = err.code;
-    }
-    err.code = Errors.PLUGIN_ERROR;
-    err.plugin = plugin;
-    if (hook) {
-        err.hook = hook;
-    }
-    if (id) {
-        err.id = id;
-    }
-    return error(err);
-}
 
 function createPluginCache(cache) {
     return {
@@ -22111,15 +22170,9 @@ const NO_CACHE = {
 function uncacheablePluginError(pluginName) {
     if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
         pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
-        return error({
-            code: 'ANONYMOUS_PLUGIN_CACHE',
-            message: 'A plugin is trying to use the Rollup cache but is not declaring a plugin name or cacheKey.'
-        });
+        return error(errAnonymousPluginCache());
     }
-    return error({
-        code: 'DUPLICATE_PLUGIN_NAME',
-        message: `The plugin name ${pluginName} 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).`
-    });
+    return error(errDuplicatePluginName(pluginName));
 }
 function getCacheForUncacheablePlugin(pluginName) {
     return {
@@ -22222,10 +22275,7 @@ async function transform(source, module, pluginDriver, warn) {
                     });
                 },
                 setAssetSource() {
-                    return this.error({
-                        code: 'INVALID_SETASSETSOURCE',
-                        message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
-                    });
+                    return this.error(errInvalidSetAssetSourceCall());
                 },
                 warn(warning, pos) {
                     if (typeof warning === 'string')
@@ -22240,7 +22290,7 @@ async function transform(source, module, pluginDriver, warn) {
         });
     }
     catch (err) {
-        throwPluginError(err, pluginName, { hook: 'transform', id });
+        return error(errPluginError(err, pluginName, { hook: 'transform', id }));
     }
     if (!customTransformCache) {
         // files emitted by a transform hook need to be emitted again if the hook is skipped
@@ -22280,7 +22330,6 @@ class ModuleLoader {
         this.hasModuleSideEffects = options.treeshake
             ? options.treeshake.moduleSideEffects
             : () => true;
-        this.readQueue = new Queue(options.maxParallelFileReads);
     }
     async addAdditionalModules(unresolvedModules) {
         const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null))));
@@ -22356,13 +22405,11 @@ class ModuleLoader {
         }));
     }
     async addModuleSource(id, importer, module) {
-        timeStart('load modules', 3);
         let source;
         try {
-            source = await this.readQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await require$$0$1.promises.readFile(id, 'utf8')); });
+            source = await this.graph.fileOperationQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await node_fs.promises.readFile(id, 'utf8')); });
         }
         catch (err) {
-            timeEnd('load modules', 3);
             let msg = `Could not load ${id}`;
             if (importer)
                 msg += ` (imported by ${relativeId(importer)})`;
@@ -22370,7 +22417,6 @@ class ModuleLoader {
             err.message = msg;
             throw err;
         }
-        timeEnd('load modules', 3);
         const sourceDescription = typeof source === 'string'
             ? { code: source }
             : source != null && typeof source === 'object' && typeof source.code === 'string'
@@ -22658,8 +22704,8 @@ class ModuleLoader {
 function normalizeRelativeExternalId(source, importer) {
     return isRelative(source)
         ? importer
-            ? require$$0.resolve(importer, '..', source)
-            : require$$0.resolve(source)
+            ? node_path.resolve(importer, '..', source)
+            : node_path.resolve(source)
         : source;
 }
 function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
@@ -22724,7 +22770,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     else {
         cacheInstance = getCacheForUncacheablePlugin(plugin.name);
     }
-    const context = {
+    return {
         addWatchFile(id) {
             if (graph.phase >= BuildPhase.GENERATE) {
                 return this.error(errInvalidRollupPhaseForAddWatchFile());
@@ -22734,7 +22780,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
         cache: cacheInstance,
         emitFile: fileEmitter.emitFile.bind(fileEmitter),
         error(err) {
-            return throwPluginError(err, plugin.name);
+            return error(errPluginError(err, plugin.name));
         },
         getFileName: fileEmitter.getFileName,
         getModuleIds: () => graph.modulesById.keys(),
@@ -22774,9 +22820,9 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             options.onwarn(warning);
         }
     };
-    return context;
 }
 
+// This will make sure no input hook is omitted
 const inputHookNames = {
     buildEnd: 1,
     buildStart: 1,
@@ -22792,18 +22838,13 @@ const inputHookNames = {
     watchChange: 1
 };
 const inputHooks = Object.keys(inputHookNames);
-function throwInvalidHookError(hookName, pluginName) {
-    return error({
-        code: 'INVALID_PLUGIN_HOOK',
-        message: `Error running plugin hook ${hookName} for ${pluginName}, expected a function hook.`
-    });
-}
 class PluginDriver {
     constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
         this.graph = graph;
         this.options = options;
-        this.unfulfilledActions = new Set();
         this.pluginCache = pluginCache;
+        this.sortedPlugins = new Map();
+        this.unfulfilledActions = new Set();
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
         this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
         this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
@@ -22834,21 +22875,21 @@ class PluginDriver {
     }
     // chains, first non-null result stops and returns
     hookFirst(hookName, args, replaceContext, skipped) {
-        let promise = Promise.resolve(undefined);
-        for (const plugin of this.plugins) {
+        let promise = Promise.resolve(null);
+        for (const plugin of this.getSortedPlugins(hookName)) {
             if (skipped && skipped.has(plugin))
                 continue;
             promise = promise.then(result => {
                 if (result != null)
                     return result;
-                return this.runHook(hookName, args, plugin, false, replaceContext);
+                return this.runHook(hookName, args, plugin, replaceContext);
             });
         }
         return promise;
     }
     // chains synchronously, first non-null result stops and returns
     hookFirstSync(hookName, args, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             if (result != null)
                 return result;
@@ -22856,56 +22897,58 @@ class PluginDriver {
         return null;
     }
     // parallel, ignores returns
-    hookParallel(hookName, args, replaceContext) {
-        const promises = [];
-        for (const plugin of this.plugins) {
-            const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-            if (!hookPromise)
-                continue;
-            promises.push(hookPromise);
+    async hookParallel(hookName, args, replaceContext) {
+        const parallelPromises = [];
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (plugin[hookName].sequential) {
+                await Promise.all(parallelPromises);
+                parallelPromises.length = 0;
+                await this.runHook(hookName, args, plugin, replaceContext);
+            }
+            else {
+                parallelPromises.push(this.runHook(hookName, args, plugin, replaceContext));
+            }
         }
-        return Promise.all(promises).then(() => { });
+        await Promise.all(parallelPromises);
     }
     // chains, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0(hookName, [arg0, ...rest], reduce, replaceContext) {
         let promise = Promise.resolve(arg0);
-        for (const plugin of this.plugins) {
-            promise = promise.then(arg0 => {
-                const args = [arg0, ...rest];
-                const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-                if (!hookPromise)
-                    return arg0;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin));
-            });
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(arg0 => this.runHook(hookName, [arg0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin)));
         }
         return promise;
     }
     // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0Sync(hookName, [arg0, ...rest], reduce, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const args = [arg0, ...rest];
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             arg0 = reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin);
         }
         return arg0;
     }
-    // chains, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
-    hookReduceValue(hookName, initialValue, args, reduce, replaceContext) {
-        let promise = Promise.resolve(initialValue);
-        for (const plugin of this.plugins) {
-            promise = promise.then(value => {
-                const hookPromise = this.runHook(hookName, args, plugin, true, replaceContext);
-                if (!hookPromise)
-                    return value;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), value, result, plugin));
-            });
+    // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
+    async hookReduceValue(hookName, initialValue, args, reducer) {
+        const results = [];
+        const parallelResults = [];
+        for (const plugin of this.getSortedPlugins(hookName, validateAddonPluginHandler)) {
+            if (plugin[hookName].sequential) {
+                results.push(...(await Promise.all(parallelResults)));
+                parallelResults.length = 0;
+                results.push(await this.runHook(hookName, args, plugin));
+            }
+            else {
+                parallelResults.push(this.runHook(hookName, args, plugin));
+            }
         }
-        return promise;
+        results.push(...(await Promise.all(parallelResults)));
+        return results.reduce(reducer, await initialValue);
     }
     // chains synchronously, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
     hookReduceValueSync(hookName, initialValue, args, reduce, replaceContext) {
         let acc = initialValue;
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             acc = reduce.call(this.pluginContexts.get(plugin), acc, result, plugin);
         }
@@ -22914,31 +22957,32 @@ class PluginDriver {
     // chains, ignores returns
     hookSeq(hookName, args, replaceContext) {
         let promise = Promise.resolve();
-        for (const plugin of this.plugins) {
-            promise = promise.then(() => this.runHook(hookName, args, plugin, false, replaceContext));
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(() => this.runHook(hookName, args, plugin, replaceContext));
         }
-        return promise;
+        return promise.then(noReturn);
+    }
+    getSortedPlugins(hookName, validateHandler) {
+        return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
     }
-    runHook(hookName, args, plugin, permitValues, hookContext) {
+    // Implementation signature
+    runHook(hookName, args, plugin, replaceContext) {
+        // We always filter for plugins that support the hook before running it
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         let action = null;
         return Promise.resolve()
             .then(() => {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                if (permitValues)
-                    return hook;
-                return throwInvalidHookError(hookName, plugin.name);
+            if (typeof handler !== 'function') {
+                return handler;
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            const hookResult = hook.apply(context, args);
-            if (!hookResult || !hookResult.then) {
+            const hookResult = handler.apply(context, args);
+            if (!(hookResult === null || hookResult === void 0 ? void 0 : hookResult.then)) {
                 // short circuit for non-thenables and non-Promises
                 return hookResult;
             }
@@ -22963,7 +23007,7 @@ class PluginDriver {
                 // action considered to be fulfilled since error being handled
                 this.unfulfilledActions.delete(action);
             }
-            return throwPluginError(err, plugin.name, { hook: hookName });
+            return error(errPluginError(err, plugin.name, { hook: hookName }));
         });
     }
     /**
@@ -22971,29 +23015,92 @@ class PluginDriver {
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
      * @param args Arguments passed to the plugin hook.
      * @param plugin The acutal plugin
-     * @param hookContext When passed, the plugin context can be overridden.
+     * @param replaceContext When passed, the plugin context can be overridden.
      */
-    runHookSync(hookName, args, plugin, hookContext) {
+    runHookSync(hookName, args, plugin, replaceContext) {
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         try {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                return throwInvalidHookError(hookName, plugin.name);
-            }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            return hook.apply(context, args);
+            return handler.apply(context, args);
         }
         catch (err) {
-            return throwPluginError(err, plugin.name, { hook: hookName });
+            return error(errPluginError(err, plugin.name, { hook: hookName }));
         }
     }
 }
+function getSortedValidatedPlugins(hookName, plugins, validateHandler = validateFunctionPluginHandler) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                validateHandler(hook.handler, hookName, plugin);
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            else {
+                validateHandler(hook, hookName, plugin);
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}
+function validateFunctionPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'function') {
+        error(errInvalidFunctionPluginHook(hookName, plugin.name));
+    }
+}
+function validateAddonPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'string' && typeof handler !== 'function') {
+        return error(errInvalidAddonPluginHook(hookName, plugin.name));
+    }
+}
+function noReturn() { }
+
+class Queue {
+    constructor(maxParallel) {
+        this.maxParallel = maxParallel;
+        this.queue = [];
+        this.workerCount = 0;
+    }
+    run(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ reject, resolve, task });
+            this.work();
+        });
+    }
+    async work() {
+        if (this.workerCount >= this.maxParallel)
+            return;
+        this.workerCount++;
+        let entry;
+        while ((entry = this.queue.shift())) {
+            const { reject, resolve, task } = entry;
+            try {
+                const result = await task();
+                resolve(result);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+        this.workerCount--;
+    }
+}
 
 function normalizeEntryModules(entryModules) {
     if (Array.isArray(entryModules)) {
@@ -23058,15 +23165,16 @@ class Graph {
         this.pluginDriver = new PluginDriver(this, options, options.plugins, this.pluginCache);
         this.acornParser = Parser.extend(...options.acornInjectPlugins);
         this.moduleLoader = new ModuleLoader(this, this.modulesById, this.options, this.pluginDriver);
+        this.fileOperationQueue = new Queue(options.maxParallelFileOps);
     }
     async build() {
         timeStart('generate module graph', 2);
         await this.generateModuleGraph();
         timeEnd('generate module graph', 2);
-        timeStart('sort modules', 2);
+        timeStart('sort and bind modules', 2);
         this.phase = BuildPhase.ANALYSE;
         this.sortModules();
-        timeEnd('sort modules', 2);
+        timeEnd('sort and bind modules', 2);
         timeStart('mark included statements', 2);
         this.includeStatements();
         timeEnd('mark included statements', 2);
@@ -23178,12 +23286,7 @@ class Graph {
     sortModules() {
         const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
         for (const cyclePath of cyclePaths) {
-            this.options.onwarn({
-                code: 'CIRCULAR_DEPENDENCY',
-                cycle: cyclePath,
-                importer: cyclePath[0],
-                message: `Circular dependency: ${cyclePath.join(' -> ')}`
-            });
+            this.options.onwarn(errCircularDependency(cyclePath));
         }
         this.modules = orderedModules;
         for (const module of this.modules) {
@@ -23196,12 +23299,7 @@ class Graph {
             for (const importDescription of module.importDescriptions.values()) {
                 if (importDescription.name !== '*' &&
                     !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
-                    module.warn({
-                        code: 'NON_EXISTENT_EXPORT',
-                        message: `Non-existent export '${importDescription.name}' is imported from ${relativeId(importDescription.module.id)}`,
-                        name: importDescription.name,
-                        source: importDescription.module.id
-                    }, importDescription.start);
+                    module.warn(errMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
                 }
             }
         }
@@ -23228,7 +23326,7 @@ function formatAction([pluginName, hookName, args]) {
 // We do not directly listen on process to avoid max listeners warnings for
 // complicated build processes
 const beforeExitEvent = 'beforeExit';
-const beforeExitEmitter = new require$$0$2.EventEmitter();
+const beforeExitEmitter = new node_events.EventEmitter();
 beforeExitEmitter.setMaxListeners(0);
 process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
 async function catchUnfinishedHookActions(pluginDriver, callback) {
@@ -23247,13 +23345,14 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
 }
 
 function normalizeInputOptions(config) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     // 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 = (_a = config.context) !== null && _a !== void 0 ? _a : 'undefined';
     const onwarn = getOnwarn(config);
     const strictDeprecations = config.strictDeprecations || false;
+    const maxParallelFileOps = getmaxParallelFileOps(config, onwarn, strictDeprecations);
     const options = {
         acorn: getAcorn(config),
         acornInjectPlugins: getAcornInjectPlugins(config),
@@ -23263,14 +23362,15 @@ function normalizeInputOptions(config) {
         external: getIdMatcher(config.external),
         inlineDynamicImports: getInlineDynamicImports$1(config, onwarn, strictDeprecations),
         input: getInput(config),
-        makeAbsoluteExternalsRelative: (_c = config.makeAbsoluteExternalsRelative) !== null && _c !== void 0 ? _c : true,
+        makeAbsoluteExternalsRelative: (_c = config.makeAbsoluteExternalsRelative) !== null && _c !== void 0 ? _c : 'ifRelativeSource',
         manualChunks: getManualChunks$1(config, onwarn, strictDeprecations),
-        maxParallelFileReads: getMaxParallelFileReads(config),
+        maxParallelFileOps,
+        maxParallelFileReads: maxParallelFileOps,
         moduleContext: getModuleContext(config, context),
         onwarn,
         perf: config.perf || false,
         plugins: ensureArray$1(config.plugins),
-        preserveEntrySignatures: getPreserveEntrySignatures(config, unsetOptions),
+        preserveEntrySignatures: (_d = config.preserveEntrySignatures) !== null && _d !== void 0 ? _d : 'exports-only',
         preserveModules: getPreserveModules$1(config, onwarn, strictDeprecations),
         preserveSymlinks: config.preserveSymlinks || false,
         shimMissingExports: config.shimMissingExports || false,
@@ -23346,12 +23446,17 @@ const getManualChunks$1 = (config, warn, strictDeprecations) => {
     }
     return configManualChunks;
 };
-const getMaxParallelFileReads = (config) => {
+const getmaxParallelFileOps = (config, warn, strictDeprecations) => {
+    var _a;
     const maxParallelFileReads = config.maxParallelFileReads;
     if (typeof maxParallelFileReads === 'number') {
-        if (maxParallelFileReads <= 0)
+        warnDeprecationWithOptions('The "maxParallelFileReads" option is deprecated. Use the "maxParallelFileOps" option instead.', true, warn, strictDeprecations);
+    }
+    const maxParallelFileOps = (_a = config.maxParallelFileOps) !== null && _a !== void 0 ? _a : maxParallelFileReads;
+    if (typeof maxParallelFileOps === 'number') {
+        if (maxParallelFileOps <= 0)
             return Infinity;
-        return maxParallelFileReads;
+        return maxParallelFileOps;
     }
     return 20;
 };
@@ -23363,19 +23468,12 @@ const getModuleContext = (config, context) => {
     if (configModuleContext) {
         const contextByModuleId = Object.create(null);
         for (const [key, moduleContext] of Object.entries(configModuleContext)) {
-            contextByModuleId[require$$0.resolve(key)] = moduleContext;
+            contextByModuleId[node_path.resolve(key)] = moduleContext;
         }
         return id => contextByModuleId[id] || context;
     }
     return () => context;
 };
-const getPreserveEntrySignatures = (config, unsetOptions) => {
-    const configPreserveEntrySignatures = config.preserveEntrySignatures;
-    if (configPreserveEntrySignatures == null) {
-        unsetOptions.add('preserveEntrySignatures');
-    }
-    return configPreserveEntrySignatures !== null && configPreserveEntrySignatures !== void 0 ? configPreserveEntrySignatures : 'strict';
-};
 const getPreserveModules$1 = (config, warn, strictDeprecations) => {
     const configPreserveModules = config.preserveModules;
     if (configPreserveModules) {
@@ -23576,7 +23674,7 @@ const getPreserveModulesRoot = (config) => {
     if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
         return undefined;
     }
-    return require$$0.resolve(preserveModulesRoot);
+    return node_path.resolve(preserveModulesRoot);
 };
 const getAmd = (config) => {
     const mergedOption = {
@@ -23655,7 +23753,7 @@ const getGeneratedCode = (config, preferConst) => {
         arrowFunctions: configWithPreset.arrowFunctions === true,
         constBindings: configWithPreset.constBindings === true || preferConst,
         objectShorthand: configWithPreset.objectShorthand === true,
-        reservedNamesAsProps: configWithPreset.reservedNamesAsProps === true,
+        reservedNamesAsProps: configWithPreset.reservedNamesAsProps !== false,
         symbols: configWithPreset.symbols === true
     };
 };
@@ -23748,7 +23846,9 @@ async function rollupInternal(rawInputOptions, watcher) {
     timeStart('BUILD', 1);
     await catchUnfinishedHookActions(graph.pluginDriver, async () => {
         try {
+            timeStart('initialize', 2);
             await graph.pluginDriver.hookParallel('buildStart', [inputOptions]);
+            timeEnd('initialize', 2);
             await graph.build();
         }
         catch (err) {
@@ -23792,17 +23892,15 @@ async function getInputOptions(rawInputOptions, watchMode) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    const rawPlugins = ensureArray$1(rawInputOptions.plugins);
+    const rawPlugins = getSortedValidatedPlugins('options', ensureArray$1(rawInputOptions.plugins));
     const { options, unsetOptions } = normalizeInputOptions(await rawPlugins.reduce(applyOptionHook(watchMode), Promise.resolve(rawInputOptions)));
     normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
     return { options, unsetOptions };
 }
 function applyOptionHook(watchMode) {
     return async (inputOptions, plugin) => {
-        if (plugin.options) {
-            return ((await plugin.options.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
-        }
-        return inputOptions;
+        const handler = 'handler' in plugin.options ? plugin.options.handler : plugin.options;
+        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
     };
 }
 function normalizePlugins(plugins, anonymousPrefix) {
@@ -23818,14 +23916,13 @@ function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutput
         const bundle = new Bundle(outputOptions, unsetOptions, inputOptions, outputPluginDriver, graph);
         const generated = await bundle.generate(isWrite);
         if (isWrite) {
+            timeStart('WRITE', 1);
             if (!outputOptions.dir && !outputOptions.file) {
-                return error({
-                    code: 'MISSING_OPTION',
-                    message: 'You must specify "output.file" or "output.dir" for the build.'
-                });
+                return error(errMissingFileOrDirOption());
             }
-            await Promise.all(Object.values(generated).map(chunk => writeOutputFile(chunk, outputOptions)));
+            await Promise.all(Object.values(generated).map(chunk => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
             await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);
+            timeEnd('WRITE', 1);
         }
         return createOutput(generated);
     });
@@ -23879,35 +23976,10 @@ function getSortingFileType(file) {
     return SortingFileType.SECONDARY_CHUNK;
 }
 async function writeOutputFile(outputFile, outputOptions) {
-    const fileName = require$$0.resolve(outputOptions.dir || require$$0.dirname(outputOptions.file), outputFile.fileName);
+    const fileName = node_path.resolve(outputOptions.dir || node_path.dirname(outputOptions.file), outputFile.fileName);
     // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
-    await require$$0$1.promises.mkdir(require$$0.dirname(fileName), { recursive: true });
-    let writeSourceMapPromise;
-    let source;
-    if (outputFile.type === 'asset') {
-        source = outputFile.source;
-    }
-    else {
-        source = outputFile.code;
-        if (outputOptions.sourcemap && outputFile.map) {
-            let url;
-            if (outputOptions.sourcemap === 'inline') {
-                url = outputFile.map.toUrl();
-            }
-            else {
-                const { sourcemapBaseUrl } = outputOptions;
-                const sourcemapFileName = `${require$$0.basename(outputFile.fileName)}.map`;
-                url = sourcemapBaseUrl
-                    ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
-                    : sourcemapFileName;
-                writeSourceMapPromise = require$$0$1.promises.writeFile(`${fileName}.map`, outputFile.map.toString());
-            }
-            if (outputOptions.sourcemap !== 'hidden') {
-                source += `//# ${exports.SOURCEMAPPING_URL}=${url}\n`;
-            }
-        }
-    }
-    return Promise.all([require$$0$1.promises.writeFile(fileName, source), writeSourceMapPromise]);
+    await node_fs.promises.mkdir(node_path.dirname(fileName), { recursive: true });
+    return node_fs.promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
 }
 /**
  * Auxiliary function for defining rollup configuration
@@ -23918,7 +23990,7 @@ function defineConfig(options) {
     return options;
 }
 
-class WatchEmitter extends require$$0$2.EventEmitter {
+class WatchEmitter extends node_events.EventEmitter {
     constructor() {
         super();
         this.awaitedHandlers = Object.create(null);
@@ -23963,6 +24035,12 @@ exports.createFilter = createFilter;
 exports.defaultOnWarn = defaultOnWarn;
 exports.defineConfig = defineConfig;
 exports.ensureArray = ensureArray$1;
+exports.errDuplicateImportOptions = errDuplicateImportOptions;
+exports.errFailAfterWarnings = errFailAfterWarnings;
+exports.errMissingConfig = errMissingConfig;
+exports.errMissingExternalConfig = errMissingExternalConfig;
+exports.errOnlyInlineSourcemapsForStdout = errOnlyInlineSourcemapsForStdout;
+exports.errTranspiledEsmConfig = errTranspiledEsmConfig;
 exports.error = error;
 exports.fseventsImporter = fseventsImporter;
 exports.generatedCodePresets = generatedCodePresets;