rollup 3.0.0-2 → 3.0.0-3

package/dist/es/shared/rollup.js

@@ -1,13 +1,13 @@
 /*
   @license
 	Rollup.js v3.0.0-2
-	Fri, 15 Jul 2022 15:25:15 GMT - commit 13b0ef8778ca5ccfd54b113ef545bf235a4c7e34
+	Sat, 30 Jul 2022 12:51:34 GMT - commit 41906cedefbc03640d6e8ca23ce6975f3bb5c6a1
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import require$$0, { resolve, extname, basename, dirname, relative as relative$1, win32, posix, isAbsolute as isAbsolute$1 } from 'path';
+import require$$0, { resolve, basename, extname, dirname, relative as relative$1, win32, posix, isAbsolute as isAbsolute$1 } from 'path';
 import process$1 from 'process';
 import { performance } from 'perf_hooks';
 import { createHash as createHash$1 } from 'crypto';
@@ -1891,8 +1891,10 @@ function printQuotedStringList(list, verbs) {
 }
 
 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) {
@@ -1910,335 +1912,500 @@ 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_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', 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', 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 errDuplicatePluginName(plugin) {
     return {
-        code: Errors.ASSET_SOURCE_ALREADY_SET,
-        message: `Unable to set the source for asset "${name}", source already 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 errNoAssetSourceSet(assetName) {
+function errEmptyChunk(chunkName) {
     return {
-        code: Errors.ASSET_SOURCE_MISSING,
-        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+        code: EMPTY_BUNDLE,
+        message: `Generated an empty chunk: "${chunkName}".`,
+        names: [chunkName]
     };
 }
-function errBadLoader(id) {
+function errEval(id) {
     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: 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 errDeprecation(deprecation) {
+function errExternalSyntheticExports(id, importer) {
     return {
-        code: Errors.DEPRECATED_FEATURE,
-        ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
+        code: EXTERNAL_SYNTHETIC_EXPORTS,
+        exporter: id,
+        message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
+    };
+}
+function errFileNameConflict(fileName) {
+    return {
+        code: FILE_NAME_CONFLICT,
+        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
     };
 }
 function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
     return {
-        code: Errors.FILE_NOT_FOUND,
+        code: FILE_NOT_FOUND,
         message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
     };
 }
-function errFileNameConflict(fileName) {
+function errIllegalIdentifierAsName(name) {
     return {
-        code: Errors.FILE_NAME_CONFLICT,
-        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
+        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 errInvalidPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for "${plugin}", expected a function hook.`,
+        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 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 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 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 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);
 }
@@ -2400,13 +2567,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));
     }
 }
 
@@ -7603,10 +7764,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()) {
@@ -7802,10 +7960,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) {
@@ -8819,10 +8974,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);
             }
         }
     }
@@ -8862,14 +9014,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);
@@ -8959,17 +9104,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 = {
@@ -10303,6 +10441,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;
@@ -11213,10 +11352,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);
             }
         }
     }
@@ -11466,11 +11602,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) {
@@ -12805,18 +12937,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 }) {
@@ -12942,17 +13063,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);
         }
@@ -13090,12 +13201,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);
     }
 }
@@ -13360,11 +13466,7 @@ function warnOnBuiltins(warn, dependencies) {
         .filter(importPath => importPath in builtins);
     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 }) {
@@ -13602,24 +13704,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) {
@@ -13641,7 +13737,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) {
@@ -13813,10 +13909,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)}'`);
@@ -14477,12 +14570,7 @@ function getGlobalName(chunk, globals, hasExports, warn) {
         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;
     }
 }
@@ -15280,12 +15368,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 };
     }
@@ -15647,12 +15730,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]);
@@ -15824,14 +15907,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: []
@@ -21846,22 +21922,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 {
@@ -21922,15 +21982,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 {
@@ -22033,10 +22087,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')
@@ -22051,7 +22102,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
@@ -22541,7 +22592,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(),
@@ -22599,12 +22650,6 @@ 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;
@@ -22741,7 +22786,7 @@ class PluginDriver {
             if (typeof hook !== 'function') {
                 if (permitValues)
                     return hook;
-                return throwInvalidHookError(hookName, plugin.name);
+                return error(errInvalidPluginHook(hookName, plugin.name));
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
             const hookResult = hook.apply(context, args);
@@ -22770,7 +22815,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 }));
         });
     }
     /**
@@ -22791,13 +22836,13 @@ class PluginDriver {
         try {
             // permit values allows values to be returned instead of a functional hook
             if (typeof hook !== 'function') {
-                return throwInvalidHookError(hookName, plugin.name);
+                return error(errInvalidPluginHook(hookName, plugin.name));
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
             return hook.apply(context, args);
         }
         catch (err) {
-            return throwPluginError(err, plugin.name, { hook: hookName });
+            return error(errPluginError(err, plugin.name, { hook: hookName }));
         }
     }
 }
@@ -23017,12 +23062,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) {
@@ -23035,12 +23075,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);
                 }
             }
         }
@@ -23100,14 +23135,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 = {
@@ -23754,10 +23782,7 @@ function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutput
         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 => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
             await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);