rollup 3.1.0 → 3.2.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.1.0
-	Wed, 12 Oct 2022 08:54:50 GMT - commit f7b768992209a970c240799cdff12a4fa437c0d4
+	Rollup.js v3.2.0
+	Sat, 15 Oct 2022 04:47:20 GMT - commit 585de6d1bc569c4f1d49654cae1044cefa277fb7
 
 	https://github.com/rollup/rollup
 
@@ -9,13 +9,14 @@
 */
 import { resolve, basename, extname, dirname, relative as relative$1 } from 'node:path';
 import require$$0$1, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$1 } from 'path';
-import process$1 from 'node:process';
+import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
 import { createHash as createHash$1 } from 'node:crypto';
 import { promises } from 'node:fs';
 import { EventEmitter } from 'node:events';
+import * as tty from 'tty';
 
-var version$1 = "3.1.0";
+var version$1 = "3.2.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1582,16 +1583,16 @@ function relative(from, to) {
     return toParts.join('/');
 }
 
-const needsEscapeRegEx = /[\\'\r\n\u2028\u2029]/;
-const quoteNewlineRegEx = /(['\r\n\u2028\u2029])/g;
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
 const backSlashRegEx = /\\/g;
 function escapeId(id) {
-    if (!id.match(needsEscapeRegEx))
+    if (!needsEscapeRegEx.test(id))
         return id;
     return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
 }
 
-const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[\\|/])/;
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[/\\|])/;
 const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
 function isAbsolute(path) {
     return ABSOLUTE_PATH_REGEX.test(path);
@@ -1606,7 +1607,7 @@ function normalize(path) {
 
 function getAliasName(id) {
     const base = basename(id);
-    return base.substring(0, base.length - extname(id).length);
+    return base.slice(0, Math.max(0, base.length - extname(id).length));
 }
 function relativeId(id) {
     if (!isAbsolute(id))
@@ -1627,10 +1628,7 @@ function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName)
         if (relativePath === '')
             return '../' + basename(targetPath);
         if (UPPER_DIR_REGEX.test(relativePath)) {
-            return relativePath
-                .split('/')
-                .concat(['..', basename(targetPath)])
-                .join('/');
+            return [...relativePath.split('/'), '..', basename(targetPath)].join('/');
         }
     }
     return !relativePath ? '.' : relativePath.startsWith('..') ? relativePath : './' + relativePath;
@@ -1675,7 +1673,7 @@ function formatAssertions$1(assertions, { getObject }) {
         return null;
     }
     const assertionEntries = Object.entries(assertions).map(([key, value]) => [key, `'${value}'`]);
-    if (assertionEntries.length) {
+    if (assertionEntries.length > 0) {
         return getObject(assertionEntries, { lineBreakIndent: null });
     }
     return null;
@@ -1786,9 +1784,9 @@ class ExpressionEntity {
     include(_context, _includeChildrenRecursively, _options) {
         this.included = true;
     }
-    includeCallArguments(context, args) {
-        for (const arg of args) {
-            arg.include(context, false);
+    includeCallArguments(context, parameters) {
+        for (const argument of parameters) {
+            argument.include(context, false);
         }
     }
     shouldBeIncluded(_context) {
@@ -1934,14 +1932,14 @@ function locate(source, search, options) {
     return getLocator(source, options)(search, options && options.startIndex);
 }
 
-function spaces(i) {
+function spaces(index) {
     let result = '';
-    while (i--)
+    while (index--)
         result += ' ';
     return result;
 }
-function tabsToSpaces(str) {
-    return str.replace(/^\t+/, match => match.split('\t').join('  '));
+function tabsToSpaces(value) {
+    return value.replace(/^\t+/, match => match.split('\t').join('  '));
 }
 function getCodeFrame(source, line, column) {
     let lines = source.split('\n');
@@ -1954,16 +1952,16 @@ function getCodeFrame(source, line, column) {
     }
     const digits = String(frameEnd).length;
     return lines
-        .map((str, i) => {
-        const isErrorLine = frameStart + i + 1 === line;
-        let lineNum = String(i + frameStart + 1);
-        while (lineNum.length < digits)
-            lineNum = ` ${lineNum}`;
+        .map((sourceLine, index) => {
+        const isErrorLine = frameStart + index + 1 === line;
+        let lineNumber = String(index + frameStart + 1);
+        while (lineNumber.length < digits)
+            lineNumber = ` ${lineNumber}`;
         if (isErrorLine) {
-            const indicator = spaces(digits + 2 + tabsToSpaces(str.slice(0, column)).length) + '^';
-            return `${lineNum}: ${tabsToSpaces(str)}\n${indicator}`;
+            const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + '^';
+            return `${lineNumber}: ${tabsToSpaces(sourceLine)}\n${indicator}`;
         }
-        return `${lineNum}: ${tabsToSpaces(str)}`;
+        return `${lineNumber}: ${tabsToSpaces(sourceLine)}`;
     })
         .join('\n');
 }
@@ -1987,38 +1985,38 @@ function error(base) {
     }
     throw base;
 }
-function augmentCodeLocation(props, pos, source, id) {
+function augmentCodeLocation(properties, pos, source, id) {
     if (typeof pos === 'object') {
         const { line, column } = pos;
-        props.loc = { column, file: id, line };
+        properties.loc = { column, file: id, line };
     }
     else {
-        props.pos = pos;
+        properties.pos = pos;
         const { line, column } = locate(source, pos, { offsetLine: 1 });
-        props.loc = { column, file: id, line };
+        properties.loc = { column, file: id, line };
     }
-    if (props.frame === undefined) {
-        const { line, column } = props.loc;
-        props.frame = getCodeFrame(source, line, column);
+    if (properties.frame === undefined) {
+        const { line, column } = properties.loc;
+        properties.frame = getCodeFrame(source, line, column);
     }
 }
 // Error codes should be sorted alphabetically while errors should be sorted by
 // error code below
 const ADDON_ERROR = 'ADDON_ERROR', ALREADY_CLOSED = 'ALREADY_CLOSED', AMBIGUOUS_EXTERNAL_NAMESPACES = 'AMBIGUOUS_EXTERNAL_NAMESPACES', ANONYMOUS_PLUGIN_CACHE = 'ANONYMOUS_PLUGIN_CACHE', ASSET_NOT_FINALISED = 'ASSET_NOT_FINALISED', ASSET_NOT_FOUND = 'ASSET_NOT_FOUND', ASSET_SOURCE_ALREADY_SET = 'ASSET_SOURCE_ALREADY_SET', ASSET_SOURCE_MISSING = 'ASSET_SOURCE_MISSING', BAD_LOADER = 'BAD_LOADER', CANNOT_CALL_NAMESPACE = 'CANNOT_CALL_NAMESPACE', CANNOT_EMIT_FROM_OPTIONS_HOOK = 'CANNOT_EMIT_FROM_OPTIONS_HOOK', CHUNK_NOT_GENERATED = 'CHUNK_NOT_GENERATED', CHUNK_INVALID = 'CHUNK_INVALID', CIRCULAR_DEPENDENCY = 'CIRCULAR_DEPENDENCY', CIRCULAR_REEXPORT = 'CIRCULAR_REEXPORT', CYCLIC_CROSS_CHUNK_REEXPORT = 'CYCLIC_CROSS_CHUNK_REEXPORT', DEPRECATED_FEATURE = 'DEPRECATED_FEATURE', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INCONSISTENT_IMPORT_ASSERTIONS = 'INCONSISTENT_IMPORT_ASSERTIONS', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', SHIMMED_EXPORT = 'SHIMMED_EXPORT', SOURCEMAP_BROKEN = 'SOURCEMAP_BROKEN', SOURCEMAP_ERROR = 'SOURCEMAP_ERROR', SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT = 'SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT', THIS_IS_UNDEFINED = 'THIS_IS_UNDEFINED', UNEXPECTED_NAMED_IMPORT = 'UNEXPECTED_NAMED_IMPORT', UNKNOWN_OPTION = 'UNKNOWN_OPTION', UNRESOLVED_ENTRY = 'UNRESOLVED_ENTRY', UNRESOLVED_IMPORT = 'UNRESOLVED_IMPORT', UNUSED_EXTERNAL_IMPORT = 'UNUSED_EXTERNAL_IMPORT', VALIDATION_ERROR = 'VALIDATION_ERROR';
-function errAddonNotGenerated(message, hook, plugin) {
+function errorAddonNotGenerated(message, hook, plugin) {
     return {
         code: ADDON_ERROR,
         message: `Could not retrieve "${hook}". Check configuration of plugin "${plugin}".
 \tError Message: ${message}`
     };
 }
-function errAlreadyClosed() {
+function errorAlreadyClosed() {
     return {
         code: ALREADY_CLOSED,
         message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
     };
 }
-function errAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
+function errorAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
     return {
         binding,
         code: AMBIGUOUS_EXTERNAL_NAMESPACES,
@@ -2027,83 +2025,83 @@ function errAmbiguousExternalNamespaces(binding, reexportingModule, usedModule,
         reexporter: reexportingModule
     };
 }
-function errAnonymousPluginCache() {
+function errorAnonymousPluginCache() {
     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) {
+function errorAssetNotFinalisedForFileName(name) {
     return {
         code: ASSET_NOT_FINALISED,
         message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first. If you reference assets via import.meta.ROLLUP_FILE_URL_<referenceId>, you need to either have set their source after "renderStart" or need to provide an explicit "fileName" when emitting them.`
     };
 }
-function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+function errorAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
     return {
         code: ASSET_NOT_FOUND,
         message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
     };
 }
-function errAssetSourceAlreadySet(name) {
+function errorAssetSourceAlreadySet(name) {
     return {
         code: ASSET_SOURCE_ALREADY_SET,
         message: `Unable to set the source for asset "${name}", source already set.`
     };
 }
-function errNoAssetSourceSet(assetName) {
+function errorNoAssetSourceSet(assetName) {
     return {
         code: ASSET_SOURCE_MISSING,
         message: `Plugin error creating asset "${assetName}" - no asset source set.`
     };
 }
-function errBadLoader(id) {
+function errorBadLoader(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) {
+function errorCannotCallNamespace(name) {
     return {
         code: CANNOT_CALL_NAMESPACE,
         message: `Cannot call a namespace ("${name}").`
     };
 }
-function errCannotEmitFromOptionsHook() {
+function errorCannotEmitFromOptionsHook() {
     return {
         code: CANNOT_EMIT_FROM_OPTIONS_HOOK,
         message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
     };
 }
-function errChunkNotGeneratedForFileName(name) {
+function errorChunkNotGeneratedForFileName(name) {
     return {
         code: CHUNK_NOT_GENERATED,
         message: `Plugin error - Unable to get file name for emitted chunk "${name}". You can only get file names once chunks have been generated after the "renderStart" hook.`
     };
 }
-function errChunkInvalid({ fileName, code }, exception) {
-    const errorProps = {
+function errorChunkInvalid({ fileName, code }, exception) {
+    const errorProperties = {
         code: CHUNK_INVALID,
         message: `Chunk "${fileName}" is not valid JavaScript: ${exception.message}.`
     };
-    augmentCodeLocation(errorProps, exception.loc, code, fileName);
-    return errorProps;
+    augmentCodeLocation(errorProperties, exception.loc, code, fileName);
+    return errorProperties;
 }
-function errCircularDependency(cyclePath) {
+function errorCircularDependency(cyclePath) {
     return {
         code: CIRCULAR_DEPENDENCY,
         ids: cyclePath,
         message: `Circular dependency: ${cyclePath.map(relativeId).join(' -> ')}`
     };
 }
-function errCircularReexport(exportName, exporter) {
+function errorCircularReexport(exportName, exporter) {
     return {
         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) {
+function errorCyclicCrossChunkReexport(exportName, exporter, reexporter, importer) {
     return {
         code: CYCLIC_CROSS_CHUNK_REEXPORT,
         exporter,
@@ -2112,26 +2110,26 @@ function errCyclicCrossChunkReexport(exportName, exporter, reexporter, importer)
         reexporter
     };
 }
-function errDeprecation(deprecation) {
+function errorDeprecation(deprecation) {
     return {
         code: DEPRECATED_FEATURE,
         ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
     };
 }
-function errDuplicatePluginName(plugin) {
+function errorDuplicatePluginName(plugin) {
     return {
         code: DUPLICATE_PLUGIN_NAME,
         message: `The plugin name ${plugin} is being used twice in the same build. Plugin names must be distinct or provide a cacheKey (please post an issue to the plugin if you are a plugin user).`
     };
 }
-function errEmptyChunk(chunkName) {
+function errorEmptyChunk(chunkName) {
     return {
         code: EMPTY_BUNDLE,
         message: `Generated an empty chunk: "${chunkName}".`,
         names: [chunkName]
     };
 }
-function errEval(id) {
+function errorEval(id) {
     return {
         code: EVAL,
         id,
@@ -2139,39 +2137,39 @@ function errEval(id) {
         url: 'https://rollupjs.org/guide/en/#avoiding-eval'
     };
 }
-function errExternalSyntheticExports(id, importer) {
+function errorExternalSyntheticExports(id, importer) {
     return {
         code: EXTERNAL_SYNTHETIC_EXPORTS,
         exporter: id,
         message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
     };
 }
-function errFileNameConflict(fileName) {
+function errorFileNameConflict(fileName) {
     return {
         code: FILE_NAME_CONFLICT,
         message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
     };
 }
-function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
+function errorFileReferenceIdNotFoundForFilename(assetReferenceId) {
     return {
         code: FILE_NOT_FOUND,
         message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
     };
 }
-function errIllegalIdentifierAsName(name) {
+function errorIllegalIdentifierAsName(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) {
+function errorIllegalImportReassignment(name, importingId) {
     return {
         code: ILLEGAL_REASSIGNMENT,
         message: `Illegal reassignment of import "${name}" in "${relativeId(importingId)}".`
     };
 }
-function errInconsistentImportAssertions(existingAssertions, newAssertions, source, importer) {
+function errorInconsistentImportAssertions(existingAssertions, newAssertions, source, importer) {
     return {
         code: INCONSISTENT_IMPORT_ASSERTIONS,
         message: `Module "${relativeId(importer)}" tried to import "${relativeId(source)}" with ${formatAssertions(newAssertions)} assertions, but it was already imported elsewhere with ${formatAssertions(existingAssertions)} assertions. Please ensure that import assertions for the same module are always consistent.`
@@ -2183,46 +2181,46 @@ const formatAssertions = (assertions) => {
         return 'no';
     return entries.map(([key, value]) => `"${key}": "${value}"`).join(', ');
 };
-function errInputHookInOutputPlugin(pluginName, hookName) {
+function errorInputHookInOutputPlugin(pluginName, hookName) {
     return {
         code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
         message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
     };
 }
-function errCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
+function errorCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
     return {
         code: INVALID_CHUNK,
         message: `Cannot assign "${relativeId(moduleId)}" to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
     };
 }
-function errInvalidExportOptionValue(optionValue) {
+function errorInvalidExportOptionValue(optionValue) {
     return {
         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) {
+function errorIncompatibleExportOptionValue(optionValue, keys, entryModule) {
     return {
         code: INVALID_EXPORT_OPTION,
         message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${printQuotedStringList(keys)}`,
         url: 'https://rollupjs.org/guide/en/#outputexports'
     };
 }
-function errInternalIdCannotBeExternal(source, importer) {
+function errorInternalIdCannotBeExternal(source, importer) {
     return {
         code: INVALID_EXTERNAL_ID,
         message: `"${source}" is imported as an external by "${relativeId(importer)}", but is already an existing non-external module id.`
     };
 }
-function errInvalidOption(option, urlHash, explanation, value) {
+function errorInvalidOption(option, urlHash, explanation, value) {
     return {
         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) {
+function errorInvalidAddonPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
@@ -2230,7 +2228,7 @@ function errInvalidAddonPluginHook(hook, plugin) {
         plugin
     };
 }
-function errInvalidFunctionPluginHook(hook, plugin) {
+function errorInvalidFunctionPluginHook(hook, plugin) {
     return {
         code: INVALID_PLUGIN_HOOK,
         hook,
@@ -2238,32 +2236,32 @@ function errInvalidFunctionPluginHook(hook, plugin) {
         plugin
     };
 }
-function errInvalidRollupPhaseForAddWatchFile() {
+function errorInvalidRollupPhaseForAddWatchFile() {
     return {
         code: INVALID_ROLLUP_PHASE,
         message: `Cannot call "addWatchFile" after the build has finished.`
     };
 }
-function errInvalidRollupPhaseForChunkEmission() {
+function errorInvalidRollupPhaseForChunkEmission() {
     return {
         code: INVALID_ROLLUP_PHASE,
         message: `Cannot emit chunks after module loading has finished.`
     };
 }
-function errInvalidSetAssetSourceCall() {
+function errorInvalidSetAssetSourceCall() {
     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) {
+function errorInvalidFormatForTopLevelAwait(id, format) {
     return {
         code: INVALID_TLA_FORMAT,
         id,
         message: `Module format "${format}" does not support top-level await. Use the "es" or "system" output formats rather.`
     };
 }
-function errMissingExport(binding, importingModule, exporter) {
+function errorMissingExport(binding, importingModule, exporter) {
     return {
         binding,
         code: MISSING_EXPORT,
@@ -2273,7 +2271,7 @@ function errMissingExport(binding, importingModule, exporter) {
         url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
     };
 }
-function errMissingGlobalName(externalId, guess) {
+function errorMissingGlobalName(externalId, guess) {
     return {
         code: MISSING_GLOBAL_NAME,
         id: externalId,
@@ -2282,54 +2280,57 @@ function errMissingGlobalName(externalId, guess) {
         url: 'https://rollupjs.org/guide/en/#outputglobals'
     };
 }
-function errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
+function errorImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
     return {
         code: MISSING_IMPLICIT_DEPENDANT,
         message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
     };
 }
-function errUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
+function errorUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
     return {
         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();
+function errorImplicitDependantIsNotIncluded(module) {
+    const implicitDependencies = [...module.implicitlyLoadedBefore]
+        .map(dependency => relativeId(dependency.id))
+        .sort();
     return {
         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() {
+function errorMissingNameOptionForIifeExport() {
     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() {
+function errorMissingNameOptionForUmdExport() {
     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) {
+function errorMissingNodeBuiltins(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() {
+// eslint-disable-next-line unicorn/prevent-abbreviations
+function errorMissingFileOrDirOption() {
     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) {
+function errorMixedExport(facadeModuleId, name) {
     return {
         code: MIXED_EXPORTS,
         id: facadeModuleId,
@@ -2337,14 +2338,14 @@ function errMixedExport(facadeModuleId, name) {
         url: `https://rollupjs.org/guide/en/#outputexports`
     };
 }
-function errModuleLevelDirective(directive, id) {
+function errorModuleLevelDirective(directive, id) {
     return {
         code: MODULE_LEVEL_DIRECTIVE,
         id,
         message: `Module level directives cause errors when bundled, "${directive}" in "${relativeId(id)}" was ignored.`
     };
 }
-function errNamespaceConflict(binding, reexportingModuleId, sources) {
+function errorNamespaceConflict(binding, reexportingModuleId, sources) {
     return {
         binding,
         code: NAMESPACE_CONFLICT,
@@ -2353,14 +2354,14 @@ function errNamespaceConflict(binding, reexportingModuleId, sources) {
         reexporter: reexportingModuleId
     };
 }
-function errNoTransformMapOrAstWithoutCode(pluginName) {
+function errorNoTransformMapOrAstWithoutCode(pluginName) {
     return {
         code: NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
         message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
             'a "code". This will be ignored.'
     };
 }
-function errParseError(error, moduleId) {
+function errorParseError(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)';
@@ -2375,7 +2376,7 @@ function errParseError(error, moduleId) {
         message
     };
 }
-function errPluginError(error, plugin, { hook, id } = {}) {
+function errorPluginError(error, plugin, { hook, id } = {}) {
     if (typeof error === 'string')
         error = { message: error };
     if (error.code && error.code !== PLUGIN_ERROR) {
@@ -2391,7 +2392,7 @@ function errPluginError(error, plugin, { hook, id } = {}) {
     }
     return error;
 }
-function errShimmedExport(id, binding) {
+function errorShimmedExport(id, binding) {
     return {
         binding,
         code: SHIMMED_EXPORT,
@@ -2399,7 +2400,7 @@ function errShimmedExport(id, binding) {
         message: `Missing export "${binding}" has been shimmed in module "${relativeId(id)}".`
     };
 }
-function errSourcemapBroken(plugin) {
+function errorSourcemapBroken(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`,
@@ -2407,7 +2408,7 @@ function errSourcemapBroken(plugin) {
         url: `https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect`
     };
 }
-function errInvalidSourcemapForError(error, id, column, line, pos) {
+function errorInvalidSourcemapForError(error, id, column, line, pos) {
     return {
         cause: error,
         code: SOURCEMAP_ERROR,
@@ -2421,7 +2422,7 @@ function errInvalidSourcemapForError(error, id, column, line, pos) {
         pos
     };
 }
-function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+function errorSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
     return {
         code: SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
         exporter: id,
@@ -2430,14 +2431,14 @@ function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOp
             : 'a default export'} that does not reexport an unresolved named export of the same module.`
     };
 }
-function errThisIsUndefined() {
+function errorThisIsUndefined() {
     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) {
+function errorUnexpectedNamedImport(id, imported, isReexport) {
     const importType = isReexport ? 'reexport' : 'import';
     return {
         code: UNEXPECTED_NAMED_IMPORT,
@@ -2446,7 +2447,7 @@ function errUnexpectedNamedImport(id, imported, isReexport) {
         url: 'https://rollupjs.org/guide/en/#outputinterop'
     };
 }
-function errUnexpectedNamespaceReexport(id) {
+function errorUnexpectedNamespaceReexport(id) {
     return {
         code: UNEXPECTED_NAMED_IMPORT,
         exporter: id,
@@ -2454,25 +2455,25 @@ function errUnexpectedNamespaceReexport(id) {
         url: 'https://rollupjs.org/guide/en/#outputinterop'
     };
 }
-function errUnknownOption(optionType, unknownOptions, validOptions) {
+function errorUnknownOption(optionType, unknownOptions, validOptions) {
     return {
         code: UNKNOWN_OPTION,
         message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.join(', ')}`
     };
 }
-function errEntryCannotBeExternal(unresolvedId) {
+function errorEntryCannotBeExternal(unresolvedId) {
     return {
         code: UNRESOLVED_ENTRY,
         message: `Entry module "${relativeId(unresolvedId)}" cannot be external.`
     };
 }
-function errUnresolvedEntry(unresolvedId) {
+function errorUnresolvedEntry(unresolvedId) {
     return {
         code: UNRESOLVED_ENTRY,
         message: `Could not resolve entry module "${relativeId(unresolvedId)}".`
     };
 }
-function errUnresolvedImport(source, importer) {
+function errorUnresolvedImport(source, importer) {
     return {
         code: UNRESOLVED_IMPORT,
         exporter: source,
@@ -2480,7 +2481,7 @@ function errUnresolvedImport(source, importer) {
         message: `Could not resolve "${source}" from "${relativeId(importer)}"`
     };
 }
-function errUnresolvedImportTreatedAsExternal(source, importer) {
+function errorUnresolvedImportTreatedAsExternal(source, importer) {
     return {
         code: UNRESOLVED_IMPORT,
         exporter: source,
@@ -2489,7 +2490,7 @@ function errUnresolvedImportTreatedAsExternal(source, importer) {
         url: 'https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency'
     };
 }
-function errUnusedExternalImports(externalId, names, importers) {
+function errorUnusedExternalImports(externalId, names, importers) {
     return {
         code: UNUSED_EXTERNAL_IMPORT,
         exporter: externalId,
@@ -2501,7 +2502,7 @@ function errUnusedExternalImports(externalId, names, importers) {
         names
     };
 }
-function errFailedValidation(message) {
+function errorFailedValidation(message) {
     return {
         code: VALIDATION_ERROR,
         message
@@ -2512,7 +2513,7 @@ function warnDeprecation(deprecation, activeDeprecation, options) {
 }
 function warnDeprecationWithOptions(deprecation, activeDeprecation, warn, strictDeprecations) {
     if (activeDeprecation || strictDeprecations) {
-        const warning = errDeprecation(deprecation);
+        const warning = errorDeprecation(deprecation);
         if (strictDeprecations) {
             return error(warning);
         }
@@ -2573,20 +2574,22 @@ const RESERVED_NAMES = new Set([
 ]);
 const RESERVED_NAMES$1 = RESERVED_NAMES;
 
-const illegalCharacters = /[^$_a-zA-Z0-9]/g;
-const startsWithDigit = (str) => /\d/.test(str[0]);
-const needsEscape = (str) => startsWithDigit(str) || RESERVED_NAMES$1.has(str) || str === 'arguments';
-function isLegal(str) {
-    if (needsEscape(str)) {
+const illegalCharacters = /[^\w$]/g;
+const startsWithDigit = (value) => /\d/.test(value[0]);
+const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES$1.has(value) || value === 'arguments';
+function isLegal(value) {
+    if (needsEscape(value)) {
         return false;
     }
-    return !illegalCharacters.test(str);
+    return !illegalCharacters.test(value);
 }
-function makeLegal(str) {
-    str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
-    if (needsEscape(str))
-        str = `_${str}`;
-    return str || '_';
+function makeLegal(value) {
+    value = value
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(illegalCharacters, '_');
+    if (needsEscape(value))
+        value = `_${value}`;
+    return value || '_';
 }
 
 class ExternalModule {
@@ -2603,7 +2606,7 @@ class ExternalModule {
         this.declarations = new Map();
         this.mostCommonSuggestion = 0;
         this.nameSuggestions = new Map();
-        this.suggestedVariableName = makeLegal(id.split(/[\\/]/).pop());
+        this.suggestedVariableName = makeLegal(id.split(/[/\\]/).pop());
         const { importers, dynamicImporters } = this;
         const info = (this.info = {
             assertions,
@@ -2657,7 +2660,7 @@ class ExternalModule {
         }
     }
     warnUnusedImports() {
-        const unused = Array.from(this.declarations)
+        const unused = [...this.declarations]
             .filter(([name, declaration]) => name !== '*' && !declaration.included && !this.reexported && !declaration.referenced)
             .map(([name]) => name);
         if (unused.length === 0)
@@ -2669,7 +2672,7 @@ class ExternalModule {
             }
         }
         const importersArray = [...importersSet];
-        this.options.onwarn(errUnusedExternalImports(this.id, unused, importersArray));
+        this.options.onwarn(errorUnusedExternalImports(this.id, unused, importersArray));
     }
 }
 
@@ -4986,12 +4989,12 @@ const returnsString = {
 const stringReplace = {
     value: {
         hasEffectsWhenCalled({ args }, context) {
-            const arg1 = args[1];
+            const argument1 = args[1];
             return (args.length < 2 ||
-                (typeof arg1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                (typeof argument1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
                     deoptimizeCache() { }
                 }) === 'symbol' &&
-                    arg1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
+                    argument1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
         },
         returns: UNKNOWN_LITERAL_STRING
     }
@@ -5066,12 +5069,15 @@ const literalStringMembers = assembleMemberDescriptions({
 }, objectMembers);
 function getLiteralMembersForValue(value) {
     switch (typeof value) {
-        case 'boolean':
+        case 'boolean': {
             return literalBooleanMembers;
-        case 'number':
+        }
+        case 'number': {
             return literalNumberMembers;
-        case 'string':
+        }
+        case 'string': {
             return literalStringMembers;
+        }
     }
     return Object.create(null);
 }
@@ -5379,14 +5385,16 @@ const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${SOURCEMAPPIN
 const ANNOTATION_KEY = '_rollupAnnotations';
 const INVALID_COMMENT_KEY = '_rollupRemoved';
 function handlePureAnnotationsOfNode(node, state, type = node.type) {
-    const { annotations } = state;
+    const { annotations, code } = state;
+    // eslint-disable-next-line unicorn/consistent-destructuring
     let comment = annotations[state.annotationIndex];
     while (comment && node.start >= comment.end) {
-        markPureNode(node, comment, state.code);
+        markPureNode(node, comment, code);
         comment = annotations[++state.annotationIndex];
     }
     if (comment && comment.end <= node.end) {
         base$1[type](node, state, handlePureAnnotationsOfNode);
+        // eslint-disable-next-line unicorn/consistent-destructuring
         while ((comment = annotations[state.annotationIndex]) && comment.end <= node.end) {
             ++state.annotationIndex;
             annotateNode(node, comment, false);
@@ -5405,10 +5413,11 @@ function markPureNode(node, comment, code) {
             annotatedNodes.push(node);
             switch (node.type) {
                 case ExpressionStatement$1:
-                case ChainExpression$1:
+                case ChainExpression$1: {
                     node = node.expression;
                     continue;
-                case SequenceExpression$1:
+                }
+                case SequenceExpression$1: {
                     // if there are parentheses, the annotation would apply to the entire expression
                     if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
                         node = node.expressions[0];
@@ -5416,7 +5425,8 @@ function markPureNode(node, comment, code) {
                     }
                     invalidAnnotation = true;
                     break;
-                case ConditionalExpression$1:
+                }
+                case ConditionalExpression$1: {
                     // if there are parentheses, the annotation would apply to the entire expression
                     if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
                         node = node.test;
@@ -5424,8 +5434,9 @@ function markPureNode(node, comment, code) {
                     }
                     invalidAnnotation = true;
                     break;
+                }
                 case LogicalExpression$1:
-                case BinaryExpression$1:
+                case BinaryExpression$1: {
                     // if there are parentheses, the annotation would apply to the entire expression
                     if (doesNotMatchOutsideComment(code.slice(parentStart, node.start), noWhitespace)) {
                         node = node.left;
@@ -5433,11 +5444,14 @@ function markPureNode(node, comment, code) {
                     }
                     invalidAnnotation = true;
                     break;
+                }
                 case CallExpression$1:
-                case NewExpression$1:
+                case NewExpression$1: {
                     break;
-                default:
+                }
+                default: {
                     invalidAnnotation = true;
+                }
             }
             break;
         }
@@ -5473,7 +5487,7 @@ function doesNotMatchOutsideComment(code, forbiddenChars) {
     }
     return true;
 }
-const pureCommentRegex = /[@#]__PURE__/;
+const pureCommentRegex = /[#@]__PURE__/;
 function addAnnotations(comments, esTreeAst, code) {
     const annotations = [];
     const sourceMappingComments = [];
@@ -5739,13 +5753,14 @@ class Method extends ExpressionEntity {
             return true;
         }
         if (type === INTERACTION_CALLED) {
+            const { args, thisArg } = interaction;
             if (this.description.mutatesSelfAsArray === true &&
-                interaction.thisArg?.hasEffectsOnInteractionAtPath(UNKNOWN_INTEGER_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)) {
+                thisArg?.hasEffectsOnInteractionAtPath(UNKNOWN_INTEGER_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)) {
                 return true;
             }
             if (this.description.callsArgs) {
-                for (const argIndex of this.description.callsArgs) {
-                    if (interaction.args[argIndex]?.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)) {
+                for (const argumentIndex of this.description.callsArgs) {
+                    if (args[argumentIndex]?.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)) {
                         return true;
                     }
                 }
@@ -5831,7 +5846,10 @@ class ObjectEntity extends ExpressionEntity {
         if (isDeoptimized) {
             return;
         }
-        for (const properties of Object.values(this.propertiesAndGettersByKey).concat(Object.values(this.settersByKey))) {
+        for (const properties of [
+            ...Object.values(this.propertiesAndGettersByKey),
+            ...Object.values(this.settersByKey)
+        ]) {
             for (const property of properties) {
                 property.deoptimizePath(UNKNOWN_PATH);
             }
@@ -5883,7 +5901,10 @@ class ObjectEntity extends ExpressionEntity {
         }
         const subPath = path.length === 1 ? UNKNOWN_PATH : path.slice(1);
         for (const property of typeof key === 'string'
-            ? (this.propertiesAndGettersByKey[key] || this.unmatchablePropertiesAndGetters).concat(this.settersByKey[key] || this.unmatchableSetters)
+            ? [
+                ...(this.propertiesAndGettersByKey[key] || this.unmatchablePropertiesAndGetters),
+                ...(this.settersByKey[key] || this.unmatchableSetters)
+            ]
             : this.allProperties) {
             property.deoptimizePath(subPath);
         }
@@ -5931,9 +5952,10 @@ class ObjectEntity extends ExpressionEntity {
             }
         }
         else {
-            for (const properties of Object.values(relevantPropertiesByKey).concat([
+            for (const properties of [
+                ...Object.values(relevantPropertiesByKey),
                 relevantUnmatchableProperties
-            ])) {
+            ]) {
                 for (const property of properties) {
                     property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
                 }
@@ -5980,7 +6002,7 @@ class ObjectEntity extends ExpressionEntity {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const [key, ...subPath] = path;
-        if (subPath.length || interaction.type === INTERACTION_CALLED) {
+        if (subPath.length > 0 || interaction.type === INTERACTION_CALLED) {
             const expressionAtPath = this.getMemberExpression(key);
             if (expressionAtPath) {
                 return expressionAtPath.hasEffectsOnInteractionAtPath(subPath, interaction, context);
@@ -6015,7 +6037,7 @@ class ObjectEntity extends ExpressionEntity {
             }
         }
         else {
-            for (const accessors of Object.values(accessorsByKey).concat([unmatchableAccessors])) {
+            for (const accessors of [...Object.values(accessorsByKey), unmatchableAccessors]) {
                 for (const accessor of accessors) {
                     if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
                         return true;
@@ -6107,7 +6129,7 @@ class ObjectEntity extends ExpressionEntity {
         }
         if (properties ||
             this.unmatchablePropertiesAndGetters.length > 0 ||
-            (this.unknownIntegerProps.length && INTEGER_REG_EXP.test(key))) {
+            (this.unknownIntegerProps.length > 0 && INTEGER_REG_EXP.test(key))) {
             return UNKNOWN_EXPRESSION;
         }
         return null;
@@ -6126,7 +6148,7 @@ class ObjectEntity extends ExpressionEntity {
     }
 }
 
-const isInteger = (prop) => typeof prop === 'string' && /^\d+$/.test(prop);
+const isInteger = (property) => typeof property === 'string' && /^\d+$/.test(property);
 // This makes sure unknown properties are not handled as "undefined" but as
 // "unknown" but without access side effects. An exception is done for numeric
 // properties as we do not expect new builtin properties to be numbers, this
@@ -6315,11 +6337,9 @@ class ArrayExpression extends NodeBase {
         let hasSpread = false;
         for (let index = 0; index < this.elements.length; index++) {
             const element = this.elements[index];
-            if (element) {
-                if (hasSpread || element instanceof SpreadElement) {
-                    hasSpread = true;
-                    element.deoptimizePath(UNKNOWN_PATH);
-                }
+            if (element && (hasSpread || element instanceof SpreadElement)) {
+                hasSpread = true;
+                element.deoptimizePath(UNKNOWN_PATH);
             }
         }
         this.context.requestTreeshakingPass();
@@ -6459,13 +6479,14 @@ class LocalVariable extends Variable {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
-            case INTERACTION_ACCESSED:
+            case INTERACTION_ACCESSED: {
                 if (this.isReassigned)
                     return true;
                 return (this.init &&
                     !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
-            case INTERACTION_ASSIGNED:
+            }
+            case INTERACTION_ASSIGNED: {
                 if (this.included)
                     return true;
                 if (path.length === 0)
@@ -6475,12 +6496,14 @@ class LocalVariable extends Variable {
                 return (this.init &&
                     !context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
-            case INTERACTION_CALLED:
+            }
+            case INTERACTION_CALLED: {
                 if (this.isReassigned)
                     return true;
                 return (this.init &&
                     !(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
                     this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
         }
     }
     include() {
@@ -6502,15 +6525,15 @@ class LocalVariable extends Variable {
             }
         }
     }
-    includeCallArguments(context, args) {
+    includeCallArguments(context, parameters) {
         if (this.isReassigned || (this.init && context.includedCallArguments.has(this.init))) {
-            for (const arg of args) {
-                arg.include(context, false);
+            for (const argument of parameters) {
+                argument.include(context, false);
             }
         }
         else if (this.init) {
             context.includedCallArguments.add(this.init);
-            this.init.includeCallArguments(context, args);
+            this.init.includeCallArguments(context, parameters);
             context.includedCallArguments.delete(this.init);
         }
     }
@@ -6529,14 +6552,14 @@ class LocalVariable extends Variable {
 
 const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
 const base = 64;
-function toBase64(num) {
-    let outStr = '';
+function toBase64(value) {
+    let outString = '';
     do {
-        const curDigit = num % base;
-        num = (num / base) | 0;
-        outStr = chars[curDigit] + outStr;
-    } while (num !== 0);
-    return outStr;
+        const currentDigit = value % base;
+        value = (value / base) | 0;
+        outString = chars[currentDigit] + outString;
+    } while (value !== 0);
+    return outString;
 }
 
 function getSafeName(baseName, usedNames) {
@@ -6689,31 +6712,31 @@ class ParameterScope extends ChildScope {
         }
         this.hasRest = hasRest;
     }
-    includeCallArguments(context, args) {
+    includeCallArguments(context, parameters) {
         let calledFromTryStatement = false;
-        let argIncluded = false;
-        const restParam = this.hasRest && this.parameters[this.parameters.length - 1];
-        for (const checkedArg of args) {
-            if (checkedArg instanceof SpreadElement) {
-                for (const arg of args) {
-                    arg.include(context, false);
+        let argumentIncluded = false;
+        const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
+        for (const checkedArgument of parameters) {
+            if (checkedArgument instanceof SpreadElement) {
+                for (const argument of parameters) {
+                    argument.include(context, false);
                 }
                 break;
             }
         }
-        for (let index = args.length - 1; index >= 0; index--) {
-            const paramVars = this.parameters[index] || restParam;
-            const arg = args[index];
-            if (paramVars) {
+        for (let index = parameters.length - 1; index >= 0; index--) {
+            const parameterVariables = this.parameters[index] || restParameter;
+            const argument = parameters[index];
+            if (parameterVariables) {
                 calledFromTryStatement = false;
-                if (paramVars.length === 0) {
+                if (parameterVariables.length === 0) {
                     // handle empty destructuring
-                    argIncluded = true;
+                    argumentIncluded = true;
                 }
                 else {
-                    for (const variable of paramVars) {
+                    for (const variable of parameterVariables) {
                         if (variable.included) {
-                            argIncluded = true;
+                            argumentIncluded = true;
                         }
                         if (variable.calledFromTryStatement) {
                             calledFromTryStatement = true;
@@ -6721,11 +6744,11 @@ class ParameterScope extends ChildScope {
                     }
                 }
             }
-            if (!argIncluded && arg.shouldBeIncluded(context)) {
-                argIncluded = true;
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
+                argumentIncluded = true;
             }
-            if (argIncluded) {
-                arg.include(context, calledFromTryStatement);
+            if (argumentIncluded) {
+                argument.include(context, calledFromTryStatement);
             }
         }
     }
@@ -6839,7 +6862,7 @@ const MUTATES_ARG_WITHOUT_ACCESSOR = {
     [ValueProperties]: {
         getLiteralValue: getTruthyLiteralValue,
         hasEffectsWhenCalled({ args }, context) {
-            return (!args.length ||
+            return (args.length === 0 ||
                 args[0].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
         }
     }
@@ -7693,14 +7716,16 @@ class GlobalVariable extends Variable {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
-            case INTERACTION_ACCESSED:
+            case INTERACTION_ACCESSED: {
                 if (path.length === 0) {
                     // Technically, "undefined" is a global variable of sorts
                     return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
                 }
                 return !getGlobalAtPath([this.name, ...path].slice(0, -1));
-            case INTERACTION_ASSIGNED:
+            }
+            case INTERACTION_ASSIGNED: {
                 return true;
+            }
             case INTERACTION_CALLED: {
                 const globalAtPath = getGlobalAtPath([this.name, ...path]);
                 return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
@@ -7737,29 +7762,34 @@ class Identifier extends NodeBase {
         let variable;
         const { treeshake } = this.context.options;
         switch (kind) {
-            case 'var':
+            case 'var': {
                 variable = this.scope.addDeclaration(this, this.context, init, true);
                 if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
                     // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
                     variable.markInitializersForDeoptimization();
                 }
                 break;
-            case 'function':
+            }
+            case 'function': {
                 // in strict mode, functions are only hoisted within a scope but not across block scopes
                 variable = this.scope.addDeclaration(this, this.context, init, false);
                 break;
+            }
             case 'let':
             case 'const':
-            case 'class':
+            case 'class': {
                 variable = this.scope.addDeclaration(this, this.context, init, false);
                 break;
-            case 'parameter':
+            }
+            case 'parameter': {
                 variable = this.scope.addParameterDeclaration(this);
                 break;
+            }
             /* istanbul ignore next */
-            default:
+            default: {
                 /* istanbul ignore next */
                 throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+            }
         }
         variable.kind = kind;
         return [(this.variable = variable)];
@@ -7793,13 +7823,16 @@ class Identifier extends NodeBase {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
-            case INTERACTION_ACCESSED:
+            case INTERACTION_ACCESSED: {
                 return (this.variable !== null &&
                     this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
-            case INTERACTION_ASSIGNED:
+            }
+            case INTERACTION_ASSIGNED: {
                 return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
-            case INTERACTION_CALLED:
+            }
+            case INTERACTION_CALLED: {
                 return this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
         }
     }
     include() {
@@ -7812,8 +7845,8 @@ class Identifier extends NodeBase {
             }
         }
     }
-    includeCallArguments(context, args) {
-        this.variable.includeCallArguments(context, args);
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
     }
     isPossibleTDZ() {
         // return cached value to avoid issues with the next tree-shaking pass
@@ -7872,7 +7905,7 @@ class Identifier extends NodeBase {
         }
     }
     disallowImportReassignment() {
-        return this.context.error(errIllegalImportReassignment(this.name, this.context.module.id), this.start);
+        return this.context.error(errorIllegalImportReassignment(this.name, this.context.module.id), this.start);
     }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
@@ -7998,10 +8031,9 @@ function renderStatementList(statements, code, start, end, options) {
 // This assumes that the first character is not part of the first node
 function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
     const splitUpNodes = [];
-    let node, nextNode, nextNodeStart, contentEnd, char;
+    let node, nextNodeStart, contentEnd, char;
     let separator = start - 1;
-    for (let nextIndex = 0; nextIndex < nodes.length; nextIndex++) {
-        nextNode = nodes[nextIndex];
+    for (const nextNode of nodes) {
         if (node !== undefined) {
             separator =
                 node.end +
@@ -8068,7 +8100,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.
-            errModuleLevelDirective(this.directive, this.context.module.id), this.start);
+            errorModuleLevelDirective(this.directive, this.context.module.id), this.start);
         }
     }
     render(code, options) {
@@ -8130,7 +8162,7 @@ class BlockStatement extends NodeBase {
                 firstBodyStatement.directive === 'use asm';
     }
     render(code, options) {
-        if (this.body.length) {
+        if (this.body.length > 0) {
             renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
         }
         else {
@@ -8221,8 +8253,8 @@ class FunctionBase extends NodeBase {
                 return true;
             }
         }
-        for (const param of this.params) {
-            if (param.hasEffects(context))
+        for (const parameter of this.params) {
+            if (parameter.hasEffects(context))
                 return true;
         }
         return false;
@@ -8236,11 +8268,11 @@ class FunctionBase extends NodeBase {
         this.body.include(context, includeChildrenRecursively);
         context.brokenFlow = brokenFlow;
     }
-    includeCallArguments(context, args) {
-        this.scope.includeCallArguments(context, args);
+    includeCallArguments(context, parameters) {
+        this.scope.includeCallArguments(context, parameters);
     }
     initialise() {
-        this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
+        this.scope.addParameterVariables(this.params.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
         if (this.body instanceof BlockStatement) {
             this.body.addImplicitReturnExpressionToScope();
         }
@@ -8291,9 +8323,9 @@ class ArrowFunctionExpression extends FunctionBase {
     }
     include(context, includeChildrenRecursively) {
         super.include(context, includeChildrenRecursively);
-        for (const param of this.params) {
-            if (!(param instanceof Identifier)) {
-                param.include(context, includeChildrenRecursively);
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier)) {
+                parameter.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -8391,12 +8423,12 @@ class ObjectPattern extends NodeBase {
 
 class AssignmentExpression extends NodeBase {
     hasEffects(context) {
-        const { deoptimized, left, right } = this;
+        const { deoptimized, left, operator, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
         // MemberExpressions do not access the property before assignments if the
         // operator is '='.
-        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, this.operator !== '='));
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
@@ -8567,12 +8599,12 @@ class FunctionScope extends ReturnValueScope {
     findLexicalBoundary() {
         return this;
     }
-    includeCallArguments(context, args) {
-        super.includeCallArguments(context, args);
+    includeCallArguments(context, parameters) {
+        super.includeCallArguments(context, parameters);
         if (this.argumentsVariable.included) {
-            for (const arg of args) {
-                if (!arg.included) {
-                    arg.include(context, false);
+            for (const argument of parameters) {
+                if (!argument.included) {
+                    argument.include(context, false);
                 }
             }
         }
@@ -8606,7 +8638,7 @@ class FunctionNode extends FunctionBase {
             context.replacedVariableInits.set(this.scope.thisVariable, interaction.withNew
                 ? new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE)
                 : UNKNOWN_EXPRESSION);
-            const { brokenFlow, ignore } = context;
+            const { brokenFlow, ignore, replacedVariableInits } = context;
             context.ignore = {
                 breaks: false,
                 continues: false,
@@ -8617,10 +8649,10 @@ class FunctionNode extends FunctionBase {
                 return true;
             context.brokenFlow = brokenFlow;
             if (thisInit) {
-                context.replacedVariableInits.set(this.scope.thisVariable, thisInit);
+                replacedVariableInits.set(this.scope.thisVariable, thisInit);
             }
             else {
-                context.replacedVariableInits.delete(this.scope.thisVariable);
+                replacedVariableInits.delete(this.scope.thisVariable);
             }
             context.ignore = ignore;
         }
@@ -8630,9 +8662,9 @@ class FunctionNode extends FunctionBase {
         super.include(context, includeChildrenRecursively);
         this.id?.include();
         const hasArguments = this.scope.argumentsVariable.included;
-        for (const param of this.params) {
-            if (!(param instanceof Identifier) || hasArguments) {
-                param.include(context, includeChildrenRecursively);
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier) || hasArguments) {
+                parameter.include(context, includeChildrenRecursively);
             }
         }
     }
@@ -8715,10 +8747,10 @@ class BinaryExpression extends NodeBase {
         const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
         if (typeof rightValue === 'symbol')
             return UnknownValue;
-        const operatorFn = binaryOperators[this.operator];
-        if (!operatorFn)
+        const operatorFunction = binaryOperators[this.operator];
+        if (!operatorFunction)
             return UnknownValue;
-        return operatorFn(leftValue, rightValue);
+        return operatorFunction(leftValue, rightValue);
     }
     hasEffects(context) {
         // support some implicit type coercion runtime errors
@@ -8766,8 +8798,8 @@ class BreakStatement extends NodeBase {
 function renderCallArguments(code, options, node) {
     if (node.arguments.length > 0) {
         if (node.arguments[node.arguments.length - 1].included) {
-            for (const arg of node.arguments) {
-                arg.render(code, options);
+            for (const argument of node.arguments) {
+                argument.render(code, options);
             }
         }
         else {
@@ -8808,13 +8840,16 @@ class Literal extends NodeBase {
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         switch (interaction.type) {
-            case INTERACTION_ACCESSED:
+            case INTERACTION_ACCESSED: {
                 return path.length > (this.value === null ? 0 : 1);
-            case INTERACTION_ASSIGNED:
+            }
+            case INTERACTION_ASSIGNED: {
                 return true;
-            case INTERACTION_CALLED:
+            }
+            case INTERACTION_CALLED: {
                 return (path.length !== 1 ||
                     hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
+            }
         }
     }
     initialise() {
@@ -8914,14 +8949,12 @@ class MemberExpression extends NodeBase {
         if (this.variable) {
             this.variable.deoptimizePath(path);
         }
-        else if (!this.isUndefined) {
-            if (path.length < MAX_PATH_DEPTH) {
-                const propertyKey = this.getPropertyKey();
-                this.object.deoptimizePath([
-                    propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
-                    ...path
-                ]);
-            }
+        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizePath([
+                propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                ...path
+            ]);
         }
     }
     deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
@@ -9007,12 +9040,12 @@ class MemberExpression extends NodeBase {
             this.includeProperties(context, includeChildrenRecursively);
         }
     }
-    includeCallArguments(context, args) {
+    includeCallArguments(context, parameters) {
         if (this.variable) {
-            this.variable.includeCallArguments(context, args);
+            this.variable.includeCallArguments(context, parameters);
         }
         else {
-            super.includeCallArguments(context, args);
+            super.includeCallArguments(context, parameters);
         }
     }
     initialise() {
@@ -9079,7 +9112,7 @@ class MemberExpression extends NodeBase {
                 if (this.variable) {
                     this.context.includeVariableInModule(this.variable);
                 }
-                this.context.warn(errIllegalImportReassignment(this.object.name, this.context.module.id), this.start);
+                this.context.warn(errorIllegalImportReassignment(this.object.name, this.context.module.id), this.start);
             }
         }
     }
@@ -9124,7 +9157,7 @@ function resolveNamespaceVariables(baseVariable, path, astContext) {
     const variable = baseVariable.context.traceExport(exportName);
     if (!variable) {
         const fileName = baseVariable.context.fileName;
-        astContext.warn(errMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
+        astContext.warn(errorMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
         return 'undefined';
     }
     return resolveNamespaceVariables(variable, path.slice(1), astContext);
@@ -9167,7 +9200,7 @@ class CallExpressionBase extends NodeBase {
             recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
                 this.expressionsToBeDeoptimized.add(interaction.thisArg);
                 returnExpression.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
-            }, undefined);
+            }, null);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
@@ -9193,9 +9226,8 @@ class CallExpressionBase extends NodeBase {
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const { type } = interaction;
         if (type === INTERACTION_CALLED) {
-            if ((interaction.withNew
-                ? context.instantiated
-                : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this)) {
+            const { args, withNew } = interaction;
+            if ((withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, args, this)) {
                 return false;
             }
         }
@@ -9214,10 +9246,10 @@ class CallExpression extends CallExpressionBase {
         if (this.callee instanceof Identifier) {
             const variable = this.scope.findVariable(this.callee.name);
             if (variable.isNamespace) {
-                this.context.warn(errCannotCallNamespace(this.callee.name), this.start);
+                this.context.warn(errorCannotCallNamespace(this.callee.name), this.start);
             }
             if (this.callee.name === 'eval') {
-                this.context.warn(errEval(this.context.module.id), this.start);
+                this.context.warn(errorEval(this.context.module.id), this.start);
             }
         }
         this.interaction = {
@@ -9490,16 +9522,13 @@ class ClassNode extends NodeBase {
         return initEffect || super.hasEffects(context);
     }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
-        if (interaction.type === INTERACTION_CALLED && path.length === 0) {
-            return (!interaction.withNew ||
+        return interaction.type === INTERACTION_CALLED && path.length === 0
+            ? !interaction.withNew ||
                 (this.classConstructor !== null
                     ? this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)
                     : this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
-                false);
-        }
-        else {
-            return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
-        }
+                false
+            : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
@@ -9706,14 +9735,14 @@ class ConditionalExpression extends NodeBase {
             usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    includeCallArguments(context, args) {
+    includeCallArguments(context, parameters) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch) {
-            this.consequent.includeCallArguments(context, args);
-            this.alternate.includeCallArguments(context, args);
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
         }
         else {
-            usedBranch.includeCallArguments(context, args);
+            usedBranch.includeCallArguments(context, parameters);
         }
     }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
@@ -9785,13 +9814,14 @@ class DoWhileStatement extends NodeBase {
     hasEffects(context) {
         if (this.test.hasEffects(context))
             return true;
-        const { brokenFlow, ignore: { breaks, continues } } = context;
-        context.ignore.breaks = true;
-        context.ignore.continues = true;
+        const { brokenFlow, ignore } = context;
+        const { breaks, continues } = ignore;
+        ignore.breaks = true;
+        ignore.continues = true;
         if (this.body.hasEffects(context))
             return true;
-        context.ignore.breaks = breaks;
-        context.ignore.continues = continues;
+        ignore.breaks = breaks;
+        ignore.continues = continues;
         context.brokenFlow = brokenFlow;
         return false;
     }
@@ -9961,18 +9991,19 @@ class ForInStatement extends NodeBase {
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
-        const { deoptimized, left, right } = this;
+        const { body, deoptimized, left, right } = this;
         if (!deoptimized)
             this.applyDeoptimizations();
         if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
             return true;
-        const { brokenFlow, ignore: { breaks, continues } } = context;
-        context.ignore.breaks = true;
-        context.ignore.continues = true;
-        if (this.body.hasEffects(context))
+        const { brokenFlow, ignore } = context;
+        const { breaks, continues } = ignore;
+        ignore.breaks = true;
+        ignore.continues = true;
+        if (body.hasEffects(context))
             return true;
-        context.ignore.breaks = breaks;
-        context.ignore.continues = continues;
+        ignore.breaks = breaks;
+        ignore.continues = continues;
         context.brokenFlow = brokenFlow;
         return false;
     }
@@ -10055,13 +10086,14 @@ class ForStatement extends NodeBase {
             this.test?.hasEffects(context) ||
             this.update?.hasEffects(context))
             return true;
-        const { brokenFlow, ignore: { breaks, continues } } = context;
-        context.ignore.breaks = true;
-        context.ignore.continues = true;
+        const { brokenFlow, ignore } = context;
+        const { breaks, continues } = ignore;
+        ignore.breaks = true;
+        ignore.continues = true;
         if (this.body.hasEffects(context))
             return true;
-        context.ignore.breaks = breaks;
-        context.ignore.continues = continues;
+        ignore.breaks = breaks;
+        ignore.continues = continues;
         context.brokenFlow = brokenFlow;
         return false;
     }
@@ -10121,6 +10153,7 @@ class IfStatement extends NodeBase {
             const { brokenFlow } = context;
             if (this.consequent.hasEffects(context))
                 return true;
+            // eslint-disable-next-line unicorn/consistent-destructuring
             const consequentBrokenFlow = context.brokenFlow;
             context.brokenFlow = brokenFlow;
             if (this.alternate === null)
@@ -10128,6 +10161,7 @@ class IfStatement extends NodeBase {
             if (this.alternate.hasEffects(context))
                 return true;
             context.brokenFlow =
+                // eslint-disable-next-line unicorn/consistent-destructuring
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
             return false;
         }
@@ -10230,17 +10264,19 @@ class IfStatement extends NodeBase {
         let consequentBrokenFlow = BROKEN_FLOW_NONE;
         if (this.consequent.shouldBeIncluded(context)) {
             this.consequent.include(context, false, { asSingleStatement: true });
+            // eslint-disable-next-line unicorn/consistent-destructuring
             consequentBrokenFlow = context.brokenFlow;
             context.brokenFlow = brokenFlow;
         }
         if (this.alternate?.shouldBeIncluded(context)) {
             this.alternate.include(context, false, { asSingleStatement: true });
             context.brokenFlow =
+                // eslint-disable-next-line unicorn/consistent-destructuring
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
         }
     }
     renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess) {
-        const hoistedVars = [
+        const hoistedVariables = [
             ...new Set(hoistedDeclarations.map(identifier => {
                 const variable = identifier.variable;
                 return variable.included ? variable.getName(getPropertyAccess) : '';
@@ -10248,10 +10284,10 @@ class IfStatement extends NodeBase {
         ]
             .filter(Boolean)
             .join(', ');
-        if (hoistedVars) {
+        if (hoistedVariables) {
             const parentType = this.parent.type;
             const needsBraces = parentType !== Program$1 && parentType !== BlockStatement$1;
-            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVars}; `);
+            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
             if (needsBraces) {
                 code.appendLeft(this.end, ` }`);
             }
@@ -10419,21 +10455,21 @@ const HELPER_GENERATORS = {
 const getDefaultLiveBinding = ({ _, getObject }) => `e${_}:${_}${getObject([['default', 'e']], { lineBreakIndent: null })}`;
 const getDefaultStatic = ({ _, getPropertyAccess }) => `e${getPropertyAccess('default')}${_}:${_}e`;
 const getIsCompatNamespace = ({ _ }) => `e${_}&&${_}typeof e${_}===${_}'object'${_}&&${_}'default'${_}in e`;
-const createNamespaceObject = (t, i, snippets, liveBindings, freeze, namespaceToStringTag) => {
+const createNamespaceObject = (t, index, snippets, liveBindings, freeze, namespaceToStringTag) => {
     const { _, cnst, getObject, getPropertyAccess, n, s } = snippets;
     const copyProperty = `{${n}` +
-        (liveBindings ? copyNonDefaultOwnPropertyLiveBinding : copyPropertyStatic)(t, i + t + t, snippets) +
-        `${i}${t}}`;
-    return (`${i}${cnst} n${_}=${_}Object.create(null${namespaceToStringTag
+        (liveBindings ? copyNonDefaultOwnPropertyLiveBinding : copyPropertyStatic)(t, index + t + t, snippets) +
+        `${index}${t}}`;
+    return (`${index}${cnst} n${_}=${_}Object.create(null${namespaceToStringTag
         ? `,${_}{${_}[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}${_}}`
         : ''});${n}` +
-        `${i}if${_}(e)${_}{${n}` +
-        `${i}${t}${loopOverKeys(copyProperty, !liveBindings, snippets)}${n}` +
-        `${i}}${n}` +
-        `${i}n${getPropertyAccess('default')}${_}=${_}e;${n}` +
-        `${i}return ${getFrozen(freeze, 'n')}${s}${n}`);
+        `${index}if${_}(e)${_}{${n}` +
+        `${index}${t}${loopOverKeys(copyProperty, !liveBindings, snippets)}${n}` +
+        `${index}}${n}` +
+        `${index}n${getPropertyAccess('default')}${_}=${_}e;${n}` +
+        `${index}return ${getFrozen(freeze, 'n')}${s}${n}`);
 };
-const loopOverKeys = (body, allowVarLoopVariable, { _, cnst, getFunctionIntro, s }) => cnst !== 'var' || allowVarLoopVariable
+const loopOverKeys = (body, allowVariableLoopVariable, { _, cnst, getFunctionIntro, s }) => cnst !== 'var' || allowVariableLoopVariable
     ? `for${_}(${cnst} k in e)${_}${body}`
     : `Object.keys(e).forEach(${getFunctionIntro(['k'], {
         isAsync: false,
@@ -10456,39 +10492,39 @@ const loopOverNamespaces = (body, useForEach, t, { _, cnst, getDirectReturnFunct
         `${t}${t}${cnst} e${_}=${_}m[i];${n}` +
         `${t}${t}if${_}(typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e))${_}{${_}for${_}(${cnst} k in e)${_}${body}${_}}${n}${t}}`);
 };
-const copyNonDefaultOwnPropertyLiveBinding = (t, i, snippets) => {
+const copyNonDefaultOwnPropertyLiveBinding = (t, index, snippets) => {
     const { _, n } = snippets;
-    return (`${i}if${_}(k${_}!==${_}'default')${_}{${n}` +
-        copyOwnPropertyLiveBinding(t, i + t, snippets) +
-        `${i}}${n}`);
+    return (`${index}if${_}(k${_}!==${_}'default')${_}{${n}` +
+        copyOwnPropertyLiveBinding(t, index + t, snippets) +
+        `${index}}${n}`);
 };
-const copyOwnPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n }) => {
+const copyOwnPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
     const [left, right] = getDirectReturnFunction([], {
         functionReturn: true,
         lineBreakIndent: null,
         name: null
     });
-    return (`${i}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
-        `${i}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
-        `${i}${t}enumerable:${_}true,${n}` +
-        `${i}${t}get:${_}${left}e[k]${right}${n}` +
-        `${i}});${n}`);
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}enumerable:${_}true,${n}` +
+        `${index}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}});${n}`);
 };
-const copyPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n }) => {
+const copyPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
     const [left, right] = getDirectReturnFunction([], {
         functionReturn: true,
         lineBreakIndent: null,
         name: null
     });
-    return (`${i}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
-        `${i}if${_}(d)${_}{${n}` +
-        `${i}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
-        `${i}${t}${t}enumerable:${_}true,${n}` +
-        `${i}${t}${t}get:${_}${left}e[k]${right}${n}` +
-        `${i}${t}});${n}` +
-        `${i}}${n}`);
-};
-const copyPropertyStatic = (_t, i, { _, n }) => `${i}n[k]${_}=${_}e[k];${n}`;
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}if${_}(d)${_}{${n}` +
+        `${index}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}${t}enumerable:${_}true,${n}` +
+        `${index}${t}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}${t}});${n}` +
+        `${index}}${n}`);
+};
+const copyPropertyStatic = (_t, index, { _, n }) => `${index}n[k]${_}=${_}e[k];${n}`;
 const getFrozen = (freeze, fragment) => freeze ? `Object.freeze(${fragment})` : fragment;
 const getWithToStringTag = (namespaceToStringTag, fragment, { _, getObject }) => namespaceToStringTag
     ? `Object.defineProperty(${fragment},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`
@@ -10667,7 +10703,7 @@ class ImportExpression extends NodeBase {
                     mechanism: { left, right }
                 };
             }
-            case 'system':
+            case 'system': {
                 return {
                     helper: null,
                     mechanism: {
@@ -10675,7 +10711,8 @@ class ImportExpression extends NodeBase {
                         right: ')'
                     }
                 };
-            case 'es':
+            }
+            case 'es': {
                 if (dynamicImportFunction) {
                     return {
                         helper: null,
@@ -10685,6 +10722,7 @@ class ImportExpression extends NodeBase {
                         }
                     };
                 }
+            }
         }
         return { helper: null, mechanism: null };
     }
@@ -10886,7 +10924,7 @@ class MetaProperty extends NodeBase {
     getReferencedFileName(outputPluginDriver) {
         const { metaProperty } = this;
         if (metaProperty?.startsWith(FILE_PREFIX)) {
-            return outputPluginDriver.getFileName(metaProperty.substring(FILE_PREFIX.length));
+            return outputPluginDriver.getFileName(metaProperty.slice(FILE_PREFIX.length));
         }
         return null;
     }
@@ -10907,44 +10945,33 @@ class MetaProperty extends NodeBase {
                         ? parent.propertyKey
                         : null);
                 if (metaProperty?.startsWith(FILE_PREFIX)) {
-                    this.referenceId = metaProperty.substring(FILE_PREFIX.length);
+                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
                 }
             }
         }
     }
     render(code, { format, pluginDriver, snippets }) {
-        const { metaProperty, parent, referenceId } = this;
-        const chunkId = this.preliminaryChunkId;
+        const { context: { module: { id: moduleId } }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
+        const chunkId = preliminaryChunkId;
         if (referenceId) {
             const fileName = pluginDriver.getFileName(referenceId);
             const relativePath = normalize(relative$1(dirname(chunkId), fileName));
             const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
-                {
-                    chunkId,
-                    fileName,
-                    format,
-                    moduleId: this.context.module.id,
-                    referenceId,
-                    relativePath
-                }
+                { chunkId, fileName, format, moduleId, referenceId, relativePath }
             ]) || relativeUrlMechanisms[format](relativePath);
             code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
             return;
         }
         const replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
             metaProperty,
-            {
-                chunkId,
-                format,
-                moduleId: this.context.module.id
-            }
+            { chunkId, format, moduleId }
         ]) || importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
         if (typeof replacement === 'string') {
             if (parent instanceof MemberExpression) {
                 code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
             }
             else {
-                code.overwrite(this.start, this.end, replacement, { contentOnly: true });
+                code.overwrite(start, end, replacement, { contentOnly: true });
             }
         }
     }
@@ -10974,11 +11001,11 @@ const accessedFileUrlGlobals = {
 };
 const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
 const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${relativePath}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.src || document.baseURI`);
-const getGenericImportMetaMechanism = (getUrl) => (prop, { chunkId }) => {
+const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
     const urlMechanism = getUrl(chunkId);
-    return prop === null
+    return property === null
         ? `({ url: ${urlMechanism} })`
-        : prop === 'url'
+        : property === 'url'
             ? urlMechanism
             : 'undefined';
 };
@@ -10999,7 +11026,7 @@ const importMetaMechanisms = {
     amd: getGenericImportMetaMechanism(() => getResolveUrl(`module.uri, document.baseURI`)),
     cjs: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' ? ${getResolveUrl(`'file:' + __filename`, `(require('u' + 'rl').URL)`)} : ${getUrlFromDocument(chunkId)})`),
     iife: getGenericImportMetaMechanism(chunkId => getUrlFromDocument(chunkId)),
-    system: (prop, { snippets: { getPropertyAccess } }) => prop === null ? `module.meta` : `module.meta${getPropertyAccess(prop)}`,
+    system: (property, { snippets: { getPropertyAccess } }) => property === null ? `module.meta` : `module.meta${getPropertyAccess(property)}`,
     umd: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getResolveUrl(`'file:' + __filename`, `(require('u' + 'rl').URL)`)} : ${getUrlFromDocument(chunkId, true)})`)
 };
 
@@ -11160,7 +11187,7 @@ class Program extends NodeBase {
         }
     }
     render(code, options) {
-        if (this.body.length) {
+        if (this.body.length > 0) {
             renderStatementList(this.body, code, this.start, this.end, options);
         }
         else {
@@ -11338,7 +11365,7 @@ class StaticBlock extends NodeBase {
         }
     }
     render(code, options) {
-        if (this.body.length) {
+        if (this.body.length > 0) {
             renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
         }
         else {
@@ -11386,7 +11413,7 @@ class SwitchCase extends NodeBase {
         }
     }
     render(code, options, nodeRenderOptions) {
-        if (this.consequent.length) {
+        if (this.consequent.length > 0) {
             this.test && this.test.render(code, options);
             const testEnd = this.test
                 ? this.test.end
@@ -11408,19 +11435,21 @@ class SwitchStatement extends NodeBase {
     hasEffects(context) {
         if (this.discriminant.hasEffects(context))
             return true;
-        const { brokenFlow, ignore: { breaks } } = context;
+        const { brokenFlow, ignore } = context;
+        const { breaks } = ignore;
         let minBrokenFlow = Infinity;
-        context.ignore.breaks = true;
+        ignore.breaks = true;
         for (const switchCase of this.cases) {
             if (switchCase.hasEffects(context))
                 return true;
+            // eslint-disable-next-line unicorn/consistent-destructuring
             minBrokenFlow = context.brokenFlow < minBrokenFlow ? context.brokenFlow : minBrokenFlow;
             context.brokenFlow = brokenFlow;
         }
         if (this.defaultCase !== null && !(minBrokenFlow === BROKEN_FLOW_BREAK_CONTINUE)) {
             context.brokenFlow = minBrokenFlow;
         }
-        context.ignore.breaks = breaks;
+        ignore.breaks = breaks;
         return false;
     }
     include(context, includeChildrenRecursively) {
@@ -11442,6 +11471,7 @@ class SwitchStatement extends NodeBase {
             }
             if (isCaseIncluded) {
                 switchCase.include(context, includeChildrenRecursively);
+                // eslint-disable-next-line unicorn/consistent-destructuring
                 minBrokenFlow = minBrokenFlow < context.brokenFlow ? minBrokenFlow : context.brokenFlow;
                 context.brokenFlow = brokenFlow;
             }
@@ -11479,7 +11509,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
             const name = this.tag.name;
             const variable = this.scope.findVariable(name);
             if (variable.isNamespace) {
-                this.context.warn(errCannotCallNamespace(name), this.start);
+                this.context.warn(errorCannotCallNamespace(name), this.start);
             }
         }
     }
@@ -11626,12 +11656,7 @@ class ExportDefaultVariable extends LocalVariable {
     }
     getBaseVariableName() {
         const original = this.getOriginalVariable();
-        if (original === this) {
-            return super.getBaseVariableName();
-        }
-        else {
-            return original.getBaseVariableName();
-        }
+        return original === this ? super.getBaseVariableName() : original.getBaseVariableName();
     }
     getDirectOriginalVariable() {
         return this.originalId &&
@@ -11646,12 +11671,9 @@ class ExportDefaultVariable extends LocalVariable {
     }
     getName(getPropertyAccess) {
         const original = this.getOriginalVariable();
-        if (original === this) {
-            return super.getName(getPropertyAccess);
-        }
-        else {
-            return original.getName(getPropertyAccess);
-        }
+        return original === this
+            ? super.getName(getPropertyAccess)
+            : original.getName(getPropertyAccess);
     }
     getOriginalVariable() {
         if (this.originalVariable)
@@ -11729,7 +11751,7 @@ class ThisExpression extends NodeBase {
         this.alias =
             this.scope.findLexicalBoundary() instanceof ModuleScope ? this.context.moduleContext : null;
         if (this.alias === 'undefined') {
-            this.context.warn(errThisIsUndefined(), this.start);
+            this.context.warn(errorThisIsUndefined(), this.start);
         }
     }
     render(code) {
@@ -11773,19 +11795,19 @@ class TryStatement extends NodeBase {
     include(context, includeChildrenRecursively) {
         const tryCatchDeoptimization = this.context.options.treeshake
             ?.tryCatchDeoptimization;
-        const { brokenFlow } = context;
+        const { brokenFlow, includedLabels } = context;
         if (!this.directlyIncluded || !tryCatchDeoptimization) {
             this.included = true;
             this.directlyIncluded = true;
             this.block.include(context, tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively);
-            if (context.includedLabels.size > 0) {
-                this.includedLabelsAfterBlock = [...context.includedLabels];
+            if (includedLabels.size > 0) {
+                this.includedLabelsAfterBlock = [...includedLabels];
             }
             context.brokenFlow = brokenFlow;
         }
         else if (this.includedLabelsAfterBlock) {
             for (const label of this.includedLabelsAfterBlock) {
-                context.includedLabels.add(label);
+                includedLabels.add(label);
             }
         }
         if (this.handler !== null) {
@@ -12120,13 +12142,14 @@ class WhileStatement extends NodeBase {
     hasEffects(context) {
         if (this.test.hasEffects(context))
             return true;
-        const { brokenFlow, ignore: { breaks, continues } } = context;
-        context.ignore.breaks = true;
-        context.ignore.continues = true;
+        const { brokenFlow, ignore } = context;
+        const { breaks, continues } = ignore;
+        ignore.breaks = true;
+        ignore.continues = true;
         if (this.body.hasEffects(context))
             return true;
-        context.ignore.breaks = breaks;
-        context.ignore.continues = continues;
+        ignore.breaks = breaks;
+        ignore.continues = continues;
         context.brokenFlow = brokenFlow;
         return false;
     }
@@ -12265,7 +12288,7 @@ class NamespaceVariable extends Variable {
             return this.memberVariables;
         }
         const memberVariables = Object.create(null);
-        for (const name of this.context.getExports().concat(this.context.getReexports())) {
+        for (const name of [...this.context.getExports(), ...this.context.getReexports()]) {
             if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
                 const exportedVariable = this.context.traceExport(name);
                 if (exportedVariable) {
@@ -12302,8 +12325,8 @@ class NamespaceVariable extends Variable {
         members.unshift([null, `__proto__:${_}null`]);
         let output = getObject(members, { lineBreakIndent: { base: '', t } });
         if (this.mergedNamespaces.length > 0) {
-            const assignmentArgs = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
-            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArgs.join(`,${_}`)}])`;
+            const assignmentArguments = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
+            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArguments.join(`,${_}`)}])`;
         }
         else {
             // The helper to merge namespaces will also take care of freezing and toStringTag
@@ -12451,14 +12474,18 @@ const NOOP = () => { };
 let timers = new Map();
 function getPersistedLabel(label, level) {
     switch (level) {
-        case 1:
+        case 1: {
             return `# ${label}`;
-        case 2:
+        }
+        case 2: {
             return `## ${label}`;
-        case 3:
+        }
+        case 3: {
             return label;
-        default:
+        }
+        default: {
             return `${'  '.repeat(level - 4)}- ${label}`;
+        }
     }
 }
 function timeStartImpl(label, level = 3) {
@@ -12527,10 +12554,10 @@ function getPluginWithTimers(plugin, index) {
                 timerLabel += ` (${plugin.name})`;
             }
             timerLabel += ` - ${hook}`;
-            const func = plugin[hook];
-            plugin[hook] = function (...args) {
+            const hookFunction = plugin[hook];
+            plugin[hook] = function (...parameters) {
                 timeStart(timerLabel, 4);
-                const result = func.apply(this, args);
+                const result = hookFunction.apply(this, parameters);
                 timeEnd(timerLabel, 4);
                 return result;
             };
@@ -12577,7 +12604,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
-            return isExportAllSearch ? [null] : error(errCircularReexport(name, target.id));
+            return isExportAllSearch ? [null] : error(errorCircularReexport(name, target.id));
         }
         searchedModules.add(target);
     }
@@ -12693,17 +12720,21 @@ class Module {
             },
             id,
             get implicitlyLoadedAfterOneOf() {
+                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(implicitlyLoadedAfter, getId).sort();
             },
             get implicitlyLoadedBefore() {
+                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(implicitlyLoadedBefore, getId).sort();
             },
             get importedIdResolutions() {
+                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(sourcesWithAssertions.keys(), source => module.resolvedIds[source]).filter(Boolean);
             },
             get importedIds() {
                 // We cannot use this.dependencies because this is needed before
                 // dependencies are populated
+                // eslint-disable-next-line unicorn/prefer-spread
                 return Array.from(sourcesWithAssertions.keys(), source => module.resolvedIds[source]?.id).filter(Boolean);
             },
             get importers() {
@@ -12722,21 +12753,22 @@ class Module {
             syntheticNamedExports
         };
         // Hide the deprecated key so that it only warns when accessed explicitly
+        // eslint-disable-next-line unicorn/consistent-destructuring
         Object.defineProperty(this.info, 'hasModuleSideEffects', {
             enumerable: false
         });
     }
     basename() {
         const base = basename(this.id);
-        const ext = extname(this.id);
-        return makeLegal(ext ? base.slice(0, -ext.length) : base);
+        const extension = extname(this.id);
+        return makeLegal(extension ? base.slice(0, -extension.length) : base);
     }
     bindReferences() {
         this.ast.bind();
     }
-    error(props, pos) {
-        this.addLocationToLogProps(props, pos);
-        return error(props);
+    error(properties, pos) {
+        this.addLocationToLogProps(properties, pos);
+        return error(properties);
     }
     getAllExportNames() {
         if (this.allExportNames) {
@@ -12831,7 +12863,7 @@ class Module {
         return (this.exportNamesByVariable = exportNamesByVariable);
     }
     getExports() {
-        return Array.from(this.exports.keys());
+        return [...this.exports.keys()];
     }
     getReexports() {
         if (this.transitiveReexports) {
@@ -12871,7 +12903,7 @@ class Module {
                 : 'default', { onlyExplicit: true });
         }
         if (!this.syntheticNamespace) {
-            return error(errSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
+            return error(errorSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
         }
         return this.syntheticNamespace;
     }
@@ -12890,7 +12922,7 @@ class Module {
         if (reexportDeclaration) {
             const [variable] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
             if (!variable) {
-                return this.error(errMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
+                return this.error(errorMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
             }
             if (importerForSideEffects) {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
@@ -12931,11 +12963,9 @@ class Module {
         }
         // we don't want to create shims when we are just
         // probing export * modules for exports
-        if (!isExportAllSearch) {
-            if (this.options.shimMissingExports) {
-                this.shimMissingExport(name);
-                return [this.exportShimVariable];
-            }
+        if (!isExportAllSearch && this.options.shimMissingExports) {
+            this.shimMissingExport(name);
+            return [this.exportShimVariable];
         }
         return [null];
     }
@@ -13005,7 +13035,7 @@ class Module {
         source.trim();
         const { usesTopLevelAwait } = this.astContext;
         if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
-            return error(errInvalidFormatForTopLevelAwait(this.id, options.format));
+            return error(errorInvalidFormatForTopLevelAwait(this.id, options.format));
         }
         return { source, usesTopLevelAwait };
     }
@@ -13074,6 +13104,7 @@ class Module {
             ast: this.ast.esTreeNode,
             code: this.info.code,
             customTransformCache: this.customTransformCache,
+            // eslint-disable-next-line unicorn/prefer-spread
             dependencies: Array.from(this.dependencies, getId),
             id: this.id,
             meta: this.info.meta,
@@ -13100,7 +13131,7 @@ class Module {
             }
             const [declaration] = getVariableForExportNameRecursive(otherModule, importDeclaration.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules);
             if (!declaration) {
-                return this.error(errMissingExport(importDeclaration.name, this.id, otherModule.id), importDeclaration.start);
+                return this.error(errorMissingExport(importDeclaration.name, this.id, otherModule.id), importDeclaration.start);
             }
             return declaration;
         }
@@ -13110,8 +13141,8 @@ class Module {
         try {
             return this.graph.contextParse(this.info.code);
         }
-        catch (err) {
-            return this.error(errParseError(err, this.id), err.pos);
+        catch (error_) {
+            return this.error(errorParseError(error_, this.id), error_.pos);
         }
     }
     updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
@@ -13125,9 +13156,9 @@ class Module {
             Object.assign(this.info.meta, meta);
         }
     }
-    warn(props, pos) {
-        this.addLocationToLogProps(props, pos);
-        this.options.onwarn(props);
+    warn(properties, pos) {
+        this.addLocationToLogProps(properties, pos);
+        this.options.onwarn(properties);
     }
     addDynamicImport(node) {
         let argument = node.source;
@@ -13225,9 +13256,9 @@ class Module {
     addImportMeta(node) {
         this.importMetas.push(node);
     }
-    addLocationToLogProps(props, pos) {
-        props.id = this.id;
-        props.pos = pos;
+    addLocationToLogProps(properties, pos) {
+        properties.id = this.id;
+        properties.pos = pos;
         let code = this.info.code;
         const location = locate(code, pos, { offsetLine: 1 });
         if (location) {
@@ -13236,10 +13267,10 @@ class Module {
                 ({ column, line } = getOriginalLocation(this.sourcemapChain, { column, line }));
                 code = this.originalCode;
             }
-            catch (err) {
-                this.options.onwarn(errInvalidSourcemapForError(err, this.id, column, line, pos));
+            catch (error_) {
+                this.options.onwarn(errorInvalidSourcemapForError(error_, this.id, column, line, pos));
             }
-            augmentCodeLocation(props, { column, line }, code, this.id);
+            augmentCodeLocation(properties, { column, line }, code, this.id);
         }
     }
     addModulesToImportDescriptions(importDescription) {
@@ -13278,7 +13309,7 @@ class Module {
         const existingAssertions = this.sourcesWithAssertions.get(source);
         if (existingAssertions) {
             if (doAssertionsDiffer(existingAssertions, parsedAssertions)) {
-                this.warn(errInconsistentImportAssertions(existingAssertions, parsedAssertions, source, this.id), declaration.start);
+                this.warn(errorInconsistentImportAssertions(existingAssertions, parsedAssertions, source, this.id), declaration.start);
             }
         }
         else {
@@ -13316,7 +13347,7 @@ class Module {
             if (foundDeclarationList.length === 1) {
                 return [usedDeclaration];
             }
-            this.options.onwarn(errNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
+            this.options.onwarn(errorNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
             // TODO we are pretending it was not found while it should behave like "undefined"
             return [null];
         }
@@ -13324,7 +13355,7 @@ class Module {
             const foundDeclarationList = [...foundExternalDeclarations];
             const usedDeclaration = foundDeclarationList[0];
             if (foundDeclarationList.length > 1) {
-                this.options.onwarn(errAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
+                this.options.onwarn(errorAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
             }
             return [usedDeclaration, true];
         }
@@ -13387,7 +13418,7 @@ class Module {
         }
     }
     shimMissingExport(name) {
-        this.options.onwarn(errShimmedExport(this.id, name));
+        this.options.onwarn(errorShimmedExport(this.id, name));
         this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
 }
@@ -13409,6 +13440,7 @@ function setAlternativeExporterIfCyclic(variable, importer, reexporter) {
     }
 }
 const copyNameToModulesMap = (searchedNamesAndModules) => searchedNamesAndModules &&
+    // eslint-disable-next-line unicorn/prefer-spread
     new Map(Array.from(searchedNamesAndModules, ([name, modules]) => [name, new Set(modules)]));
 
 function removeJsExtension(name) {
@@ -13598,12 +13630,10 @@ function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, na
                         }
                     }
                 }
-                else if (imported === '*' && reexported !== '*') {
-                    if (!hasNamespace) {
-                        hasNamespace = true;
-                        helper = namespaceInteropHelpersByInteropType[moduleInterop];
-                        variableName = namespaceVariableName;
-                    }
+                else if (imported === '*' && reexported !== '*' && !hasNamespace) {
+                    hasNamespace = true;
+                    helper = namespaceInteropHelpersByInteropType[moduleInterop];
+                    variableName = namespaceVariableName;
                 }
                 if (helper) {
                     addInteropStatement(variableName, helper, name);
@@ -13655,31 +13685,31 @@ function warnOnBuiltins(warn, dependencies) {
     const externalBuiltins = dependencies
         .map(({ importPath }) => importPath)
         .filter(importPath => importPath in builtins || importPath.startsWith('node:'));
-    if (!externalBuiltins.length)
+    if (externalBuiltins.length === 0)
         return;
-    warn(errMissingNodeBuiltins(externalBuiltins));
+    warn(errorMissingNodeBuiltins(externalBuiltins));
 }
 
 function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets, onwarn }, { amd, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
     warnOnBuiltins(onwarn, dependencies);
     const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
-    const args = dependencies.map(m => m.name);
+    const parameters = dependencies.map(m => m.name);
     const { n, getNonArrowFunctionIntro, _ } = snippets;
     if (namedExportsMode && hasExports) {
-        args.unshift(`exports`);
+        parameters.unshift(`exports`);
         deps.unshift(`'exports'`);
     }
     if (accessedGlobals.has('require')) {
-        args.unshift('require');
+        parameters.unshift('require');
         deps.unshift(`'require'`);
     }
     if (accessedGlobals.has('module')) {
-        args.unshift('module');
+        parameters.unshift('module');
         deps.unshift(`'module'`);
     }
     const completeAmdId = getCompleteAmdId(amd, id);
-    const params = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (deps.length ? `[${deps.join(`,${_}`)}],${_}` : ``);
+    const defineParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (deps.length > 0 ? `[${deps.join(`,${_}`)}],${_}` : ``);
     const useStrict = strict ? `${_}'use strict';` : '';
     magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, t, snippets)}`);
     const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings);
@@ -13692,7 +13722,7 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
         .indent(t)
         // factory function should be wrapped by parentheses to avoid lazy parsing,
         // cf. https://v8.dev/blog/preparser#pife
-        .prepend(`${amd.define}(${params}(${getNonArrowFunctionIntro(args, {
+        .prepend(`${amd.define}(${defineParameters}(${getNonArrowFunctionIntro(parameters, {
         isAsync: false,
         name: null
     })}{${useStrict}${n}${n}`)
@@ -13744,7 +13774,7 @@ function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencie
     if (intro)
         magicString.prepend(intro);
     const exportBlock = getExportBlock(exports, snippets);
-    if (exportBlock.length)
+    if (exportBlock.length > 0)
         magicString.append(n + n + exportBlock.join(n).trim());
     if (outro)
         magicString.append(outro);
@@ -13783,12 +13813,9 @@ function getImportBlock(dependencies, { _ }) {
             else if (importedNames.length > 0) {
                 importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
                     .map(specifier => {
-                    if (specifier.imported === specifier.local) {
-                        return specifier.imported;
-                    }
-                    else {
-                        return `${specifier.imported} as ${specifier.local}`;
-                    }
+                    return specifier.imported === specifier.local
+                        ? specifier.imported
+                        : `${specifier.imported} as ${specifier.local}`;
                 })
                     .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
             }
@@ -13823,12 +13850,9 @@ function getImportBlock(dependencies, { _ }) {
             if (namedReexports.length > 0) {
                 importBlock.push(`export${_}{${_}${namedReexports
                     .map(specifier => {
-                    if (specifier.imported === specifier.reexported) {
-                        return specifier.imported;
-                    }
-                    else {
-                        return `${specifier.imported} as ${specifier.reexported}`;
-                    }
+                    return specifier.imported === specifier.reexported
+                        ? specifier.imported
+                        : `${specifier.imported} as ${specifier.reexported}`;
                 })
                     .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
             }
@@ -13847,7 +13871,7 @@ function getExportBlock(exports, { _, cnst }) {
             ? specifier.local
             : `${specifier.local} as ${specifier.exported}`);
     }
-    if (exportDeclaration.length) {
+    if (exportDeclaration.length > 0) {
         exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
     }
     return exportBlock;
@@ -13865,20 +13889,20 @@ function setupNamespace(name, root, globals, { _, getPropertyAccess, s }, compac
         propertyPath += getPropertyAccess(part);
         return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}${s}`;
     })
-        .join(compact ? ',' : '\n') + (compact && parts.length ? ';' : '\n'));
+        .join(compact ? ',' : '\n') + (compact && parts.length > 0 ? ';' : '\n'));
 }
 function assignToDeepVariable(deepName, root, globals, assignment, { _, getPropertyAccess }) {
     const parts = deepName.split('.');
     parts[0] = (typeof globals === 'function' ? globals(parts[0]) : globals[parts[0]]) || parts[0];
     const last = parts.pop();
     let propertyPath = root;
-    let deepAssignment = parts
-        .map(part => {
-        propertyPath += getPropertyAccess(part);
-        return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
-    })
-        .concat(`${propertyPath}${getPropertyAccess(last)}`)
-        .join(`,${_}`) + `${_}=${_}${assignment}`;
+    let deepAssignment = [
+        ...parts.map(part => {
+            propertyPath += getPropertyAccess(part);
+            return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
+        }),
+        `${propertyPath}${getPropertyAccess(last)}`
+    ].join(`,${_}`) + `${_}=${_}${assignment}`;
     if (parts.length > 0) {
         deepAssignment = `(${deepAssignment})`;
     }
@@ -13886,11 +13910,11 @@ function assignToDeepVariable(deepName, root, globals, assignment, { _, getPrope
 }
 
 function trimEmptyImports(dependencies) {
-    let i = dependencies.length;
-    while (i--) {
-        const { imports, reexports } = dependencies[i];
+    let index = dependencies.length;
+    while (index--) {
+        const { imports, reexports } = dependencies[index];
         if (imports || reexports) {
-            return dependencies.slice(0, i + 1);
+            return dependencies.slice(0, index + 1);
         }
     }
     return [];
@@ -13901,29 +13925,29 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultE
     const isNamespaced = name && name.includes('.');
     const useVariableAssignment = !extend && !isNamespaced;
     if (name && useVariableAssignment && !isLegal(name)) {
-        return error(errIllegalIdentifierAsName(name));
+        return error(errorIllegalIdentifierAsName(name));
     }
     warnOnBuiltins(onwarn, dependencies);
     const external = trimEmptyImports(dependencies);
     const deps = external.map(dep => dep.globalName || 'null');
-    const args = external.map(m => m.name);
+    const parameters = external.map(m => m.name);
     if (hasExports && !name) {
-        onwarn(errMissingNameOptionForIifeExport());
+        onwarn(errorMissingNameOptionForIifeExport());
     }
     if (namedExportsMode && hasExports) {
         if (extend) {
             deps.unshift(`this${keypath(name, getPropertyAccess)}${_}=${_}this${keypath(name, getPropertyAccess)}${_}||${_}{}`);
-            args.unshift('exports');
+            parameters.unshift('exports');
         }
         else {
             deps.unshift('{}');
-            args.unshift('exports');
+            parameters.unshift('exports');
         }
     }
     const useStrict = strict ? `${t}'use strict';${n}` : '';
     const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, t, snippets);
     magicString.prepend(`${intro}${interopBlock}`);
-    let wrapperIntro = `(${getNonArrowFunctionIntro(args, {
+    let wrapperIntro = `(${getNonArrowFunctionIntro(parameters, {
         isAsync: false,
         name: null
     })}{${n}${useStrict}${n}`;
@@ -13957,7 +13981,7 @@ function system(magicString, { accessedGlobals, dependencies, exports, hasExport
     const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
     const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports, t, snippets);
     const registeredName = name ? `'${name}',${_}` : '';
-    const wrapperParams = accessedGlobals.has('module')
+    const wrapperParameters = accessedGlobals.has('module')
         ? ['exports', 'module']
         : hasExports
             ? ['exports']
@@ -13966,10 +13990,13 @@ function system(magicString, { accessedGlobals, dependencies, exports, hasExport
     // cf. https://v8.dev/blog/preparser#pife
     let wrapperStart = `System.register(${registeredName}[` +
         dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
-        `],${_}(${getNonArrowFunctionIntro(wrapperParams, { isAsync: false, name: null })}{${n}${t}${strict ? "'use strict';" : ''}` +
+        `],${_}(${getNonArrowFunctionIntro(wrapperParameters, {
+            isAsync: false,
+            name: null
+        })}{${n}${t}${strict ? "'use strict';" : ''}` +
         getStarExcludesBlock(starExcludes, t, snippets) +
         getImportBindingsBlock(importBindings, t, snippets) +
-        `${n}${t}return${_}{${setters.length
+        `${n}${t}return${_}{${setters.length > 0
             ? `${n}${t}${t}setters:${_}[${setters
                 .map(setter => setter
                 ? `${getFunctionIntro(['module'], {
@@ -14063,9 +14090,9 @@ const getStarExcludes = ({ dependencies, exports }) => {
     return starExcludes;
 };
 const getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n }) => starExcludes
-    ? `${n}${t}${cnst} _starExcludes${_}=${_}${getObject([...starExcludes].map(prop => [prop, '1']), { lineBreakIndent: { base: t, t } })};`
+    ? `${n}${t}${cnst} _starExcludes${_}=${_}${getObject([...starExcludes].map(property => [property, '1']), { lineBreakIndent: { base: t, t } })};`
     : '';
-const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
+const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length > 0 ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
 const getHoistedExportsBlock = (exports, t, snippets) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
 function getExportsBlock(exports, t, { _, n }) {
     if (exports.length === 0) {
@@ -14085,13 +14112,13 @@ const getMissingExportsBlock = (exports, t, snippets) => getExportsBlock(exports
     .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
     .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
 
-function globalProp(name, globalVar, getPropertyAccess) {
+function globalProperty(name, globalVariable, getPropertyAccess) {
     if (!name)
         return 'null';
-    return `${globalVar}${keypath(name, getPropertyAccess)}`;
+    return `${globalVariable}${keypath(name, getPropertyAccess)}`;
 }
-function safeAccess(name, globalVar, { _, getPropertyAccess }) {
-    let propertyPath = globalVar;
+function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
+    let propertyPath = globalVariable;
     return name
         .split('.')
         .map(part => (propertyPath += getPropertyAccess(part)))
@@ -14099,80 +14126,80 @@ function safeAccess(name, globalVar, { _, getPropertyAccess }) {
 }
 function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, outro, snippets, onwarn }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, namespaceToStringTag, globals, noConflict, strict }) {
     const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
-    const factoryVar = compact ? 'f' : 'factory';
-    const globalVar = compact ? 'g' : 'global';
+    const factoryVariable = compact ? 'f' : 'factory';
+    const globalVariable = compact ? 'g' : 'global';
     if (hasExports && !name) {
-        return error(errMissingNameOptionForUmdExport());
+        return error(errorMissingNameOptionForUmdExport());
     }
     warnOnBuiltins(onwarn, dependencies);
     const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
     const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
     const trimmedImports = trimEmptyImports(dependencies);
-    const globalDeps = trimmedImports.map(module => globalProp(module.globalName, globalVar, getPropertyAccess));
-    const factoryParams = trimmedImports.map(m => m.name);
+    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
+    const factoryParameters = trimmedImports.map(m => m.name);
     if (namedExportsMode && (hasExports || noConflict)) {
         amdDeps.unshift(`'exports'`);
         cjsDeps.unshift(`exports`);
-        globalDeps.unshift(assignToDeepVariable(name, globalVar, globals, `${extend ? `${globalProp(name, globalVar, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets));
-        factoryParams.unshift('exports');
+        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets));
+        factoryParameters.unshift('exports');
     }
     const completeAmdId = getCompleteAmdId(amd, id);
-    const amdParams = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (amdDeps.length ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
+    const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
     const define = amd.define;
     const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
     const useStrict = strict ? `${_}'use strict';${n}` : ``;
     let iifeExport;
     if (noConflict) {
-        const noConflictExportsVar = compact ? 'e' : 'exports';
+        const noConflictExportsVariable = compact ? 'e' : 'exports';
         let factory;
         if (!namedExportsMode && hasExports) {
-            factory = `${cnst} ${noConflictExportsVar}${_}=${_}${assignToDeepVariable(name, globalVar, globals, `${factoryVar}(${globalDeps.join(`,${_}`)})`, snippets)};`;
+            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets)};`;
         }
         else {
             const module = globalDeps.shift();
             factory =
-                `${cnst} ${noConflictExportsVar}${_}=${_}${module};${n}` +
-                    `${t}${t}${factoryVar}(${[noConflictExportsVar].concat(globalDeps).join(`,${_}`)});`;
+                `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
+                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
         }
         iifeExport =
             `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
-                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVar, snippets)};${n}` +
+                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVariable, snippets)};${n}` +
                 `${t}${t}${factory}${n}` +
-                `${t}${t}${noConflictExportsVar}.noConflict${_}=${_}${getFunctionIntro([], {
+                `${t}${t}${noConflictExportsVariable}.noConflict${_}=${_}${getFunctionIntro([], {
                     isAsync: false,
                     name: null
                 })}{${_}` +
-                `${globalProp(name, globalVar, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVar}${s}${_}};${n}` +
+                `${globalProperty(name, globalVariable, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVariable}${s}${_}};${n}` +
                 `${t}})()`;
     }
     else {
-        iifeExport = `${factoryVar}(${globalDeps.join(`,${_}`)})`;
+        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
         if (!namedExportsMode && hasExports) {
-            iifeExport = assignToDeepVariable(name, globalVar, globals, iifeExport, snippets);
+            iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets);
         }
     }
     const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
-    const wrapperParams = [factoryVar];
+    const wrapperParameters = [factoryVariable];
     if (iifeNeedsGlobal) {
-        wrapperParams.unshift(globalVar);
+        wrapperParameters.unshift(globalVariable);
     }
-    const globalArg = iifeNeedsGlobal ? `this,${_}` : '';
+    const globalArgument = iifeNeedsGlobal ? `this,${_}` : '';
     const iifeStart = iifeNeedsGlobal
-        ? `(${globalVar}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVar}${_}||${_}self,${_}`
+        ? `(${globalVariable}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVariable}${_}||${_}self,${_}`
         : '';
     const iifeEnd = iifeNeedsGlobal ? ')' : '';
     const cjsIntro = iifeNeedsGlobal
         ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
-            `${_}${cjsExport}${factoryVar}(${cjsDeps.join(`,${_}`)})${_}:${n}`
+            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
         : '';
-    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParams, { isAsync: false, name: null })}{${n}` +
+    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
         cjsIntro +
-        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParams}${factoryVar})${_}:${n}` +
+        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParameters}${factoryVariable})${_}:${n}` +
         `${t}${iifeStart}${iifeExport}${iifeEnd};${n}` +
         // factory function should be wrapped by parentheses to avoid lazy parsing,
         // cf. https://v8.dev/blog/preparser#pife
-        `})(${globalArg}(${getNonArrowFunctionIntro(factoryParams, {
+        `})(${globalArgument}(${getNonArrowFunctionIntro(factoryParameters, {
             isAsync: false,
             name: null
         })}{${useStrict}${n}`;
@@ -14193,15 +14220,15 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
 
 const finalisers = { amd, cjs, es, iife, system, umd };
 
-const concatSep = (out, next) => (next ? `${out}\n${next}` : out);
-const concatDblSep = (out, next) => (next ? `${out}\n\n${next}` : out);
+const concatSeparator = (out, next) => (next ? `${out}\n${next}` : out);
+const concatDblSeparator = (out, next) => (next ? `${out}\n\n${next}` : out);
 async function createAddons(options, outputPluginDriver, chunk) {
     try {
         let [banner, footer, intro, outro] = await Promise.all([
-            outputPluginDriver.hookReduceValue('banner', options.banner(chunk), [chunk], concatSep),
-            outputPluginDriver.hookReduceValue('footer', options.footer(chunk), [chunk], concatSep),
-            outputPluginDriver.hookReduceValue('intro', options.intro(chunk), [chunk], concatDblSep),
-            outputPluginDriver.hookReduceValue('outro', options.outro(chunk), [chunk], concatDblSep)
+            outputPluginDriver.hookReduceValue('banner', options.banner(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('footer', options.footer(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('intro', options.intro(chunk), [chunk], concatDblSeparator),
+            outputPluginDriver.hookReduceValue('outro', options.outro(chunk), [chunk], concatDblSeparator)
         ]);
         if (intro)
             intro += '\n\n';
@@ -14213,8 +14240,8 @@ async function createAddons(options, outputPluginDriver, chunk) {
             footer = '\n' + footer;
         return { banner, footer, intro, outro };
     }
-    catch (err) {
-        return error(errAddonNotGenerated(err.message, err.hook, err.plugin));
+    catch (error_) {
+        return error(errorAddonNotGenerated(error_.message, error_.hook, error_.plugin));
     }
 }
 
@@ -14227,7 +14254,7 @@ const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
     umd: deconflictImportsOther
 };
 function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
-    const reversedModules = modules.slice().reverse();
+    const reversedModules = [...modules].reverse();
     for (const module of reversedModules) {
         module.scope.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
     }
@@ -14273,13 +14300,11 @@ function deconflictImportsOther(usedNames, imports, { deconflictedDefault, decon
         chunk.namespaceVariableName = getSafeName(`${chunk.suggestedVariableName}__namespace`, usedNames);
     }
     for (const externalModule of deconflictedDefault) {
-        if (deconflictedNamespace.has(externalModule) &&
-            canDefaultBeTakenFromNamespace(interop(externalModule.id), externalLiveBindings)) {
-            externalModule.defaultVariableName = externalModule.namespaceVariableName;
-        }
-        else {
-            externalModule.defaultVariableName = getSafeName(`${externalModule.suggestedVariableName}__default`, usedNames);
-        }
+        externalModule.defaultVariableName =
+            deconflictedNamespace.has(externalModule) &&
+                canDefaultBeTakenFromNamespace(interop(externalModule.id), externalLiveBindings)
+                ? externalModule.namespaceVariableName
+                : getSafeName(`${externalModule.suggestedVariableName}__default`, usedNames);
     }
     for (const variable of imports) {
         const module = variable.module;
@@ -14373,11 +14398,11 @@ function getExportMode(chunk, { exports: exportMode, name, format }, facadeModul
     const exportKeys = chunk.getExportNames();
     if (exportMode === 'default') {
         if (exportKeys.length !== 1 || exportKeys[0] !== 'default') {
-            return error(errIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
+            return error(errorIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
         }
     }
-    else if (exportMode === 'none' && exportKeys.length) {
-        return error(errIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
+    else if (exportMode === 'none' && exportKeys.length > 0) {
+        return error(errorIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
     }
     if (exportMode === 'auto') {
         if (exportKeys.length === 0) {
@@ -14388,7 +14413,7 @@ function getExportMode(chunk, { exports: exportMode, name, format }, facadeModul
         }
         else {
             if (format !== 'es' && format !== 'system' && exportKeys.includes('default')) {
-                warn(errMixedExport(facadeModuleId, name));
+                warn(errorMixedExport(facadeModuleId, name));
             }
             exportMode = 'named';
         }
@@ -14411,10 +14436,10 @@ function guessIndentString(code) {
     }
     // Otherwise, we need to guess the multiple
     const min = spaced.reduce((previous, current) => {
-        const numSpaces = /^ +/.exec(current)[0].length;
-        return Math.min(numSpaces, previous);
+        const numberSpaces = /^ +/.exec(current)[0].length;
+        return Math.min(numberSpaces, previous);
     }, Infinity);
-    return new Array(min + 1).join(' ');
+    return ' '.repeat(min);
 }
 function getIndentString(modules, options) {
     if (options.indent !== true)
@@ -14476,11 +14501,11 @@ const getHashPlaceholderGenerator = () => {
     let nextIndex = 0;
     return (optionName, hashSize = defaultHashSize) => {
         if (hashSize > maxHashSize) {
-            return error(errFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
+            return error(errorFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
         }
         const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
         if (placeholder.length > hashSize) {
-            return error(errFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
+            return error(errorFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
         }
         return placeholder;
     };
@@ -14530,36 +14555,45 @@ const getOutputBundle = (outputBundleBase) => {
 
 function renderNamePattern(pattern, patternName, replacements) {
     if (isPathFragment(pattern))
-        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
+        return error(errorFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
     return pattern.replace(/\[(\w+)(:\d+)?]/g, (_match, type, size) => {
         if (!replacements.hasOwnProperty(type) || (size && type !== 'hash')) {
-            return error(errFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
+            return error(errorFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
         }
-        const replacement = replacements[type](size && parseInt(size.slice(1)));
+        const replacement = replacements[type](size && Number.parseInt(size.slice(1)));
         if (isPathFragment(replacement))
-            return error(errFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
+            return error(errorFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
         return replacement;
     });
 }
 function makeUnique(name, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
     if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
         return name;
-    const ext = extname(name);
-    name = name.substring(0, name.length - ext.length);
+    const extension = extname(name);
+    name = name.slice(0, Math.max(0, name.length - extension.length));
     let uniqueName, uniqueIndex = 1;
-    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
+    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + extension).toLowerCase()))
         ;
     return uniqueName;
 }
 
-const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.mts', '.cjs', '.cts'];
+const NON_ASSET_EXTENSIONS = new Set([
+    '.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(errMissingGlobalName(chunk.id, chunk.variableName));
+        warn(errorMissingGlobalName(chunk.id, chunk.variableName));
         return chunk.variableName;
     }
 }
@@ -14709,6 +14743,7 @@ class Chunk {
             }
         }
         for (const module of entryModules) {
+            // eslint-disable-next-line unicorn/prefer-spread
             const requiredFacades = Array.from(new Set(module.chunkNames.filter(({ isUserDefined }) => isUserDefined).map(({ name }) => name)), 
             // mapping must run after Set 'name' dedupe
             name => ({
@@ -14717,6 +14752,7 @@ class Chunk {
             if (requiredFacades.length === 0 && module.isUserDefinedEntryPoint) {
                 requiredFacades.push({});
             }
+            // eslint-disable-next-line unicorn/prefer-spread
             requiredFacades.push(...Array.from(module.chunkFileNames, fileName => ({ fileName })));
             if (requiredFacades.length === 0) {
                 requiredFacades.push({});
@@ -14724,7 +14760,7 @@ class Chunk {
             if (!this.facadeModule) {
                 const needsStrictFacade = module.preserveSignature === 'strict' ||
                     (module.preserveSignature === 'exports-only' &&
-                        module.getExportNamesByVariable().size !== 0);
+                        module.getExportNamesByVariable().size > 0);
                 if (!needsStrictFacade ||
                     this.outputOptions.preserveModules ||
                     this.canModuleBeFacade(module, exposedVariables)) {
@@ -14786,7 +14822,7 @@ class Chunk {
         return (this.name ?? (this.name = this.outputOptions.sanitizeFileName(this.getFallbackChunkName())));
     }
     getExportNames() {
-        return (this.sortedExportNames ?? (this.sortedExportNames = Array.from(this.exportsByName.keys()).sort()));
+        return (this.sortedExportNames ?? (this.sortedExportNames = [...this.exportsByName.keys()].sort()));
     }
     getFileName() {
         return this.preliminaryFileName?.fileName || this.getPreliminaryFileName().fileName;
@@ -14830,13 +14866,14 @@ class Chunk {
         if (this.renderedChunkInfo) {
             return this.renderedChunkInfo;
         }
-        const resolveFileName = (dependency) => dependency.getFileName();
         return (this.renderedChunkInfo = {
             ...this.getPreRenderedChunkInfo(),
             dynamicImports: this.getDynamicDependencies().map(resolveFileName),
             fileName: this.getFileName(),
+            // eslint-disable-next-line unicorn/prefer-spread
             implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, resolveFileName),
             importedBindings: getImportedBindingsPerDependency(this.getRenderedDependencies(), resolveFileName),
+            // eslint-disable-next-line unicorn/prefer-spread
             imports: Array.from(this.dependencies, resolveFileName),
             modules: this.renderedModules,
             referencedFiles: this.getReferencedFiles()
@@ -14870,7 +14907,7 @@ class Chunk {
         const { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait } = this.renderModules(preliminaryFileName.fileName);
         const renderedDependencies = [...this.getRenderedDependencies().values()];
         const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
-        let hasExports = renderedExports.length !== 0;
+        let hasExports = renderedExports.length > 0;
         let hasDefaultExport = false;
         for (const { reexports } of renderedDependencies) {
             if (reexports?.length) {
@@ -14919,9 +14956,9 @@ class Chunk {
         };
     }
     addImplicitlyLoadedBeforeFromModule(baseModule) {
-        const { implicitlyLoadedBefore } = this;
+        const { chunkByModule, implicitlyLoadedBefore } = this;
         for (const module of baseModule.implicitlyLoadedBefore) {
-            const chunk = this.chunkByModule.get(module);
+            const chunk = chunkByModule.get(module);
             if (chunk && chunk !== this) {
                 implicitlyLoadedBefore.add(chunk);
             }
@@ -14957,7 +14994,7 @@ class Chunk {
                 if (alternativeReexportModule) {
                     const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
                     if (exportingChunk && exportingChunk !== exportChunk) {
-                        this.inputOptions.onwarn(errCyclicCrossChunkReexport(variableModule.getExportNamesByVariable().get(variable)[0], variableModule.id, alternativeReexportModule.id, importingModule.id));
+                        this.inputOptions.onwarn(errorCyclicCrossChunkReexport(variableModule.getExportNamesByVariable().get(variable)[0], variableModule.id, alternativeReexportModule.id, importingModule.id));
                     }
                     importingModule = alternativeReexportModule;
                 }
@@ -14987,7 +15024,7 @@ class Chunk {
                 }
             }
         }
-        if (includedReexports.length) {
+        if (includedReexports.length > 0) {
             this.includedReexportsByModule.set(module, includedReexports);
         }
     }
@@ -15059,10 +15096,9 @@ class Chunk {
                                 deconflictedDefault.add(chunk);
                             }
                         }
-                        else if (variable.name === '*') {
-                            if (namespaceInteropHelpersByInteropType[interop(module.id)]) {
-                                deconflictedNamespace.add(chunk);
-                            }
+                        else if (variable.name === '*' &&
+                            namespaceInteropHelpersByInteropType[interop(module.id)]) {
+                            deconflictedNamespace.add(chunk);
                         }
                     }
                 }
@@ -15128,7 +15164,7 @@ class Chunk {
                 dependency = this.externalChunkByModule.get(module);
                 imported = variable.name;
                 if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
-                    return error(errUnexpectedNamedImport(module.id, imported, false));
+                    return error(errorUnexpectedNamedImport(module.id, imported, false));
                 }
             }
             else {
@@ -15177,14 +15213,14 @@ class Chunk {
         if (this.preRenderedChunkInfo) {
             return this.preRenderedChunkInfo;
         }
-        const { facadeModule } = this;
+        const { dynamicEntryModules, facadeModule, implicitEntryModules, orderedModules } = this;
         return (this.preRenderedChunkInfo = {
             exports: this.getExportNames(),
             facadeModuleId: facadeModule && facadeModule.id,
-            isDynamicEntry: this.dynamicEntryModules.length > 0,
+            isDynamicEntry: dynamicEntryModules.length > 0,
             isEntry: !!facadeModule?.info.isEntry,
-            isImplicitEntry: this.implicitEntryModules.length > 0,
-            moduleIds: this.orderedModules.map(({ id }) => id),
+            isImplicitEntry: implicitEntryModules.length > 0,
+            moduleIds: orderedModules.map(({ id }) => id),
             name: this.getChunkName(),
             type: 'chunk'
         });
@@ -15195,13 +15231,13 @@ class Chunk {
             return predefinedChunkName;
         const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
         const sanitizedId = sanitizeFileName(module.id.split(QUERY_HASH_REGEX, 1)[0]);
-        const extName = extname(sanitizedId);
-        const idWithoutExtension = NON_ASSET_EXTENSIONS.includes(extName)
-            ? sanitizedId.slice(0, -extName.length)
+        const extensionName = extname(sanitizedId);
+        const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
+            ? sanitizedId.slice(0, -extensionName.length)
             : sanitizedId;
         if (isAbsolute(idWithoutExtension)) {
             return preserveModulesRoot && resolve(idWithoutExtension).startsWith(preserveModulesRoot)
-                ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[\\/]/, '')
+                ? idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '')
                 : relative(this.inputBase, idWithoutExtension);
         }
         else {
@@ -15216,9 +15252,9 @@ class Chunk {
             let imported;
             let needsLiveBinding = false;
             if (exportName[0] === '*') {
-                const id = exportName.substring(1);
+                const id = exportName.slice(1);
                 if (interop(id) === 'defaultOnly') {
-                    this.inputOptions.onwarn(errUnexpectedNamespaceReexport(id));
+                    this.inputOptions.onwarn(errorUnexpectedNamespaceReexport(id));
                 }
                 needsLiveBinding = externalLiveBindings;
                 dependency = this.externalChunkByModule.get(this.modulesById.get(id));
@@ -15240,7 +15276,7 @@ class Chunk {
                     dependency = this.externalChunkByModule.get(module);
                     imported = variable.name;
                     if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
-                        return error(errUnexpectedNamedImport(module.id, imported, true));
+                        return error(errorUnexpectedNamedImport(module.id, imported, true));
                     }
                     needsLiveBinding =
                         externalLiveBindings &&
@@ -15309,9 +15345,9 @@ class Chunk {
     }
     // This method changes properties on the AST before rendering and must not be async
     renderModules(fileName) {
-        const { dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onwarn }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
+        const { accessedGlobalsByScope, dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onwarn }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
         const { compact, dynamicImportFunction, format, freeze, namespaceToStringTag, preserveModules } = outputOptions;
-        const { _, n } = snippets;
+        const { _, cnst, n } = snippets;
         this.setDynamicImportResolutions(fileName);
         this.setImportMetaResolutions(fileName);
         this.setIdentifierRenderResolutions();
@@ -15355,7 +15391,7 @@ class Chunk {
                     else
                         magicString.addSource(new MagicString(rendered));
                 }
-                const accessedGlobalVariables = this.accessedGlobalsByScope.get(module.scope);
+                const accessedGlobalVariables = accessedGlobalsByScope.get(module.scope);
                 if (accessedGlobalVariables) {
                     for (const name of accessedGlobalVariables) {
                         accessedGlobals.add(name);
@@ -15375,12 +15411,13 @@ class Chunk {
         }
         if (hoistedSource)
             magicString.prepend(hoistedSource + n + n);
+        // eslint-disable-next-line unicorn/consistent-destructuring
         if (this.needsExportsShim) {
-            magicString.prepend(`${n}${snippets.cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
+            magicString.prepend(`${n}${cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
         }
         const renderedSource = compact ? magicString : magicString.trim();
         if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
-            onwarn(errEmptyChunk(this.getChunkName()));
+            onwarn(errorEmptyChunk(this.getChunkName()));
         }
         return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
     }
@@ -15397,14 +15434,14 @@ class Chunk {
                 }
             }
             else {
-                const { resolution } = resolvedDynamicImport;
+                const { node, resolution } = resolvedDynamicImport;
                 const [resolutionString, assertions] = this.getDynamicImportStringAndAssertions(resolution, fileName);
-                resolvedDynamicImport.node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, assertions);
+                node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, assertions);
             }
         }
     }
     setIdentifierRenderResolutions() {
-        const { format, interop, namespaceToStringTag } = this.outputOptions;
+        const { format, interop, namespaceToStringTag, preserveModules, externalLiveBindings } = this.outputOptions;
         const syntheticExports = new Set();
         for (const exportName of this.getExportNames()) {
             const exportVariable = this.exportsByName.get(exportName);
@@ -15435,25 +15472,29 @@ class Chunk {
             usedNames.add('Symbol');
         }
         switch (format) {
-            case 'system':
+            case 'system': {
                 usedNames.add('module').add('exports');
                 break;
-            case 'es':
+            }
+            case 'es': {
                 break;
-            case 'cjs':
+            }
+            case 'cjs': {
                 usedNames.add('module').add('require').add('__filename').add('__dirname');
+            }
             // fallthrough
-            default:
+            default: {
                 usedNames.add('exports');
                 for (const helper of HELPER_NAMES) {
                     usedNames.add(helper);
                 }
+            }
         }
-        deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, this.outputOptions.preserveModules, this.outputOptions.externalLiveBindings, this.chunkByModule, this.externalChunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
+        deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, preserveModules, externalLiveBindings, this.chunkByModule, this.externalChunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
     }
     setImportMetaResolutions(fileName) {
-        const { accessedGlobalsByScope, includedNamespaces, outputOptions: { format, preserveModules } } = this;
-        for (const module of this.orderedModules) {
+        const { accessedGlobalsByScope, includedNamespaces, orderedModules, outputOptions: { format, preserveModules } } = this;
+        for (const module of orderedModules) {
             for (const importMeta of module.importMetas) {
                 importMeta.setResolution(format, accessedGlobalsByScope, fileName);
             }
@@ -15466,12 +15507,10 @@ class Chunk {
         const moduleImports = new Set(module.includedImports);
         // when we are not preserving modules, we need to make all namespace variables available for
         // rendering the namespace object
-        if (!this.outputOptions.preserveModules) {
-            if (this.includedNamespaces.has(module)) {
-                const memberVariables = module.namespace.getMemberVariables();
-                for (const variable of Object.values(memberVariables)) {
-                    moduleImports.add(variable);
-                }
+        if (!this.outputOptions.preserveModules && this.includedNamespaces.has(module)) {
+            const memberVariables = module.namespace.getMemberVariables();
+            for (const variable of Object.values(memberVariables)) {
+                moduleImports.add(variable);
             }
         }
         for (let variable of moduleImports) {
@@ -15531,7 +15570,8 @@ function getImportedBindingsPerDependency(renderedDependencies, resolveFileName)
     }
     return importedBindingsPerDependency;
 }
-const QUERY_HASH_REGEX = /[?#]/;
+const QUERY_HASH_REGEX = /[#?]/;
+const resolveFileName = (dependency) => dependency.getFileName();
 
 function getChunkAssignments(entryModules, manualChunkAliasByEntry) {
     const chunkDefinitions = [];
@@ -15677,11 +15717,11 @@ function commondir(files) {
         return dirname(files[0]);
     const commonSegments = files.slice(1).reduce((commonSegments, file) => {
         const pathSegements = file.split(/\/+|\\+/);
-        let i;
-        for (i = 0; commonSegments[i] === pathSegements[i] &&
-            i < Math.min(commonSegments.length, pathSegements.length); i++)
+        let index;
+        for (index = 0; commonSegments[index] === pathSegements[index] &&
+            index < Math.min(commonSegments.length, pathSegements.length); index++)
             ;
-        return commonSegments.slice(0, i);
+        return commonSegments.slice(0, index);
     }, files[0].split(/\/+|\\+/));
     // Windows correctly handles paths with forward-slashes
     return commonSegments.length > 1 ? commonSegments.join('/') : '/';
@@ -15723,16 +15763,16 @@ function analyseModuleExecution(entryModules) {
         module.execIndex = nextExecIndex++;
         analysedModules.add(module);
     };
-    for (const curEntry of entryModules) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
+    for (const currentEntry of entryModules) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
         }
     }
-    for (const curEntry of dynamicImports) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
+    for (const currentEntry of dynamicImports) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
         }
     }
     return { cyclePaths, orderedModules };
@@ -15755,16 +15795,16 @@ function getCyclePath(module, parent, parents) {
 function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, constBindings, objectShorthand, reservedNamesAsProps } }) {
     const { _, n, s } = compact ? { _: '', n: '', s: '' } : { _: ' ', n: '\n', s: ';' };
     const cnst = constBindings ? 'const' : 'var';
-    const getNonArrowFunctionIntro = (params, { isAsync, name }) => `${isAsync ? `async ` : ''}function${name ? ` ${name}` : ''}${_}(${params.join(`,${_}`)})${_}`;
+    const getNonArrowFunctionIntro = (parameters, { isAsync, name }) => `${isAsync ? `async ` : ''}function${name ? ` ${name}` : ''}${_}(${parameters.join(`,${_}`)})${_}`;
     const getFunctionIntro = arrowFunctions
-        ? (params, { isAsync, name }) => {
-            const singleParam = params.length === 1;
-            const asyncString = isAsync ? `async${singleParam ? ' ' : _}` : '';
-            return `${name ? `${cnst} ${name}${_}=${_}` : ''}${asyncString}${singleParam ? params[0] : `(${params.join(`,${_}`)})`}${_}=>${_}`;
+        ? (parameters, { isAsync, name }) => {
+            const singleParameter = parameters.length === 1;
+            const asyncString = isAsync ? `async${singleParameter ? ' ' : _}` : '';
+            return `${name ? `${cnst} ${name}${_}=${_}` : ''}${asyncString}${singleParameter ? parameters[0] : `(${parameters.join(`,${_}`)})`}${_}=>${_}`;
         }
         : getNonArrowFunctionIntro;
-    const getDirectReturnFunction = (params, { functionReturn, lineBreakIndent, name }) => [
-        `${getFunctionIntro(params, {
+    const getDirectReturnFunction = (parameters, { functionReturn, lineBreakIndent, name }) => [
+        `${getFunctionIntro(parameters, {
             isAsync: false,
             name
         })}${arrowFunctions
@@ -15776,15 +15816,15 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
             ? `${name ? ';' : ''}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : ''}`
             : `${s}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`
     ];
-    const isValidPropName = reservedNamesAsProps
-        ? (name) => validPropName.test(name)
-        : (name) => !RESERVED_NAMES$1.has(name) && validPropName.test(name);
+    const isValidPropertyName = reservedNamesAsProps
+        ? (name) => validPropertyName.test(name)
+        : (name) => !RESERVED_NAMES$1.has(name) && validPropertyName.test(name);
     return {
         _,
         cnst,
         getDirectReturnFunction,
-        getDirectReturnIifeLeft: (params, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
-            const [left, right] = getDirectReturnFunction(params, {
+        getDirectReturnIifeLeft: (parameters, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
+            const [left, right] = getDirectReturnFunction(parameters, {
                 functionReturn: true,
                 lineBreakIndent: null,
                 name: null
@@ -15799,20 +15839,20 @@ function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, con
                 .map(([key, value]) => {
                 if (key === null)
                     return `${prefix}${value}`;
-                const needsQuotes = !isValidPropName(key);
+                const needsQuotes = !isValidPropertyName(key);
                 return key === value && objectShorthand && !needsQuotes
                     ? prefix + key
                     : `${prefix}${needsQuotes ? `'${key}'` : key}:${_}${value}`;
             })
                 .join(`,`)}${fields.length === 0 ? '' : lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`;
         },
-        getPropertyAccess: (name) => isValidPropName(name) ? `.${name}` : `[${JSON.stringify(name)}]`,
+        getPropertyAccess: (name) => isValidPropertyName(name) ? `.${name}` : `[${JSON.stringify(name)}]`,
         n,
         s
     };
 }
 const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
-const validPropName = /^(?!\d)[\w$]+$/;
+const validPropertyName = /^(?!\d)[\w$]+$/;
 
 class Source {
     constructor(filename, content) {
@@ -15916,7 +15956,7 @@ function getLinkMap(warn) {
         if (map.mappings) {
             return new Link(map, [source]);
         }
-        warn(errSourcemapBroken(map.plugin));
+        warn(errorSourcemapBroken(map.plugin));
         return new Link({
             mappings: [],
             names: []
@@ -15933,7 +15973,7 @@ function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapCha
         const sourcesContent = originalSourcemap.sourcesContent || [];
         const directory = dirname(id) || '.';
         const sourceRoot = originalSourcemap.sourceRoot || '.';
-        const baseSources = sources.map((source, i) => new Source(resolve(directory, sourceRoot, source), sourcesContent[i]));
+        const baseSources = sources.map((source, index) => new Source(resolve(directory, sourceRoot, source), sourcesContent[index]));
         source = new Link(originalSourcemap, baseSources);
     }
     return sourcemapChain.reduce(linkMap, source);
@@ -15955,7 +15995,7 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     return new SourceMap({ file, mappings, names, sources, sourcesContent });
 }
 function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn) {
-    if (!sourcemapChain.length) {
+    if (sourcemapChain.length === 0) {
         return originalSourcemap;
     }
     const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(warn));
@@ -16027,26 +16067,26 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         }
         return result.code;
     });
-    const { compact, sourcemap, sourcemapPathTransform } = options;
+    const { compact, dir, file, sourcemap, sourcemapExcludeSources, sourcemapFile, sourcemapPathTransform } = options;
     if (!compact && code[code.length - 1] !== '\n')
         code += '\n';
     if (sourcemap) {
         timeStart('sourcemaps', 3);
-        let file;
-        if (options.file)
-            file = resolve(options.sourcemapFile || options.file);
-        else if (options.dir)
-            file = resolve(options.dir, fileName);
+        let resultingFile;
+        if (file)
+            resultingFile = resolve(sourcemapFile || file);
+        else if (dir)
+            resultingFile = resolve(dir, fileName);
         else
-            file = resolve(fileName);
+            resultingFile = resolve(fileName);
         const decodedMap = magicString.generateDecodedMap({});
-        map = collapseSourcemaps(file, decodedMap, usedModules, sourcemapChain, options.sourcemapExcludeSources, onwarn);
+        map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, onwarn);
         map.sources = map.sources
             .map(sourcePath => {
             if (sourcemapPathTransform) {
-                const newSourcePath = sourcemapPathTransform(sourcePath, `${file}.map`);
+                const newSourcePath = sourcemapPathTransform(sourcePath, `${resultingFile}.map`);
                 if (typeof newSourcePath !== 'string') {
-                    error(errFailedValidation(`sourcemapPathTransform function must return a string.`));
+                    error(errorFailedValidation(`sourcemapPathTransform function must return a string.`));
                 }
                 return newSourcePath;
             }
@@ -16147,9 +16187,7 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bun
         bundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
     for (const { chunk, code, fileName, map } of nonHashedChunksWithPlaceholders) {
-        let updatedCode = hashesByPlaceholder.size
-            ? replacePlaceholders(code, hashesByPlaceholder)
-            : code;
+        let updatedCode = hashesByPlaceholder.size > 0 ? replacePlaceholders(code, hashesByPlaceholder) : code;
         if (map) {
             updatedCode += emitSourceMapAndGetComment(fileName, map, pluginDriver, options);
         }
@@ -16203,9 +16241,9 @@ class Bundle {
             timeEnd('generate chunks', 2);
             await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onwarn);
         }
-        catch (err) {
-            await this.pluginDriver.hookParallel('renderError', [err]);
-            throw err;
+        catch (error_) {
+            await this.pluginDriver.hookParallel('renderError', [error_]);
+            throw error_;
         }
         timeStart('generate bundle', 2);
         await this.pluginDriver.hookSeq('generateBundle', [
@@ -16232,6 +16270,7 @@ class Bundle {
         return manualChunkAliasByEntry;
     }
     assignManualChunks(getManualChunk) {
+        // eslint-disable-next-line unicorn/prefer-module
         const manualChunkAliasesWithEntry = [];
         const manualChunksApi = {
             getModuleIds: () => this.graph.modulesById.keys(),
@@ -16262,8 +16301,8 @@ class Bundle {
                             ecmaVersion: 'latest'
                         });
                     }
-                    catch (err) {
-                        this.inputOptions.onwarn(errChunkInvalid(file, err));
+                    catch (error_) {
+                        this.inputOptions.onwarn(errorChunkInvalid(file, error_));
                     }
                 }
             }
@@ -16302,13 +16341,13 @@ class Bundle {
 }
 function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
     if (outputOptions.format === 'umd' || outputOptions.format === 'iife')
-        return error(errInvalidOption('output.format', 'outputformat', 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
+        return error(errorInvalidOption('output.format', 'outputformat', 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
     if (typeof outputOptions.file === 'string')
-        return error(errInvalidOption('output.file', 'outputdir', 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
+        return error(errorInvalidOption('output.file', 'outputdir', 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
     if (outputOptions.sourcemapFile)
-        return error(errInvalidOption('output.sourcemapFile', 'outputsourcemapfile', '"output.sourcemapFile" is only supported for single-file builds'));
+        return error(errorInvalidOption('output.sourcemapFile', 'outputsourcemapfile', '"output.sourcemapFile" is only supported for single-file builds'));
     if (!outputOptions.amd.autoId && outputOptions.amd.id)
-        onWarn(errInvalidOption('output.amd.id', 'outputamd', 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
+        onWarn(errorInvalidOption('output.amd.id', 'outputamd', 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
 }
 function getIncludedModules(modulesById) {
     const includedModules = [];
@@ -16341,7 +16380,7 @@ function getExternalChunkByModule(modulesById, outputOptions, inputBase) {
 function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
     const existingAlias = manualChunkAliasByEntry.get(module);
     if (typeof existingAlias === 'string' && existingAlias !== alias) {
-        return error(errCannotAssignModuleToChunk(module.id, alias, existingAlias));
+        return error(errorCannotAssignModuleToChunk(module.id, alias, existingAlias));
     }
     manualChunkAliasByEntry.set(module, alias);
 }
@@ -22013,7 +22052,7 @@ function createPluginCache(cache) {
         get(id) {
             const item = cache[id];
             if (!item)
-                return undefined;
+                return;
             item[0] = 0;
             return item[1];
         },
@@ -22064,9 +22103,9 @@ const NO_CACHE = {
 function uncacheablePluginError(pluginName) {
     if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
         pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
-        return error(errAnonymousPluginCache());
+        return error(errorAnonymousPluginCache());
     }
-    return error(errDuplicatePluginName(pluginName));
+    return error(errorDuplicatePluginName(pluginName));
 }
 function getCacheForUncacheablePlugin(pluginName) {
     return {
@@ -22096,7 +22135,7 @@ async function transform(source, module, pluginDriver, warn) {
     let customTransformCache = false;
     const useCustomTransformCache = () => (customTransformCache = true);
     let pluginName = '';
-    const curSource = source.code;
+    const currentSource = source.code;
     function transformReducer(previousCode, result, plugin) {
         let code;
         let map;
@@ -22107,7 +22146,7 @@ async function transform(source, module, pluginDriver, warn) {
             module.updateOptions(result);
             if (result.code == null) {
                 if (result.map || result.ast) {
-                    warn(errNoTransformMapOrAstWithoutCode(plugin.name));
+                    warn(errorNoTransformMapOrAstWithoutCode(plugin.name));
                 }
                 return previousCode;
             }
@@ -22128,7 +22167,7 @@ async function transform(source, module, pluginDriver, warn) {
     }
     let code;
     try {
-        code = await pluginDriver.hookReduceArg0('transform', [curSource, id], transformReducer, (pluginContext, plugin) => {
+        code = await pluginDriver.hookReduceArg0('transform', [currentSource, id], transformReducer, (pluginContext, plugin) => {
             pluginName = plugin.name;
             return {
                 ...pluginContext,
@@ -22143,14 +22182,14 @@ async function transform(source, module, pluginDriver, warn) {
                     emittedFiles.push(emittedFile);
                     return pluginDriver.emitFile(emittedFile);
                 },
-                error(err, pos) {
-                    if (typeof err === 'string')
-                        err = { message: err };
+                error(error_, pos) {
+                    if (typeof error_ === 'string')
+                        error_ = { message: error_ };
                     if (pos)
-                        augmentCodeLocation(err, pos, curSource, id);
-                    err.id = id;
-                    err.hook = 'transform';
-                    return pluginContext.error(err);
+                        augmentCodeLocation(error_, pos, currentSource, id);
+                    error_.id = id;
+                    error_.hook = 'transform';
+                    return pluginContext.error(error_);
                 },
                 getCombinedSourcemap() {
                     const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn);
@@ -22169,13 +22208,13 @@ async function transform(source, module, pluginDriver, warn) {
                     });
                 },
                 setAssetSource() {
-                    return this.error(errInvalidSetAssetSourceCall());
+                    return this.error(errorInvalidSetAssetSourceCall());
                 },
                 warn(warning, pos) {
                     if (typeof warning === 'string')
                         warning = { message: warning };
                     if (pos)
-                        augmentCodeLocation(warning, pos, curSource, id);
+                        augmentCodeLocation(warning, pos, currentSource, id);
                     warning.id = id;
                     warning.hook = 'transform';
                     pluginContext.warn(warning);
@@ -22183,14 +22222,12 @@ async function transform(source, module, pluginDriver, warn) {
             };
         });
     }
-    catch (err) {
-        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
-        if (emittedFiles.length)
-            module.transformFiles = emittedFiles;
+    catch (error_) {
+        return error(errorPluginError(error_, pluginName, { hook: 'transform', id }));
     }
+    if (!customTransformCache && // files emitted by a transform hook need to be emitted again if the hook is skipped
+        emittedFiles.length > 0)
+        module.transformFiles = emittedFiles;
     return {
         ast,
         code,
@@ -22234,8 +22271,7 @@ class ModuleLoader {
         const firstChunkNamePriority = this.nextChunkNamePriority;
         this.nextChunkNamePriority += unresolvedEntryModules.length;
         const newEntryModules = await this.extendLoadModulesPromise(Promise.all(unresolvedEntryModules.map(({ id, importer }) => this.loadEntryModule(id, true, importer, null))).then(entryModules => {
-            for (let index = 0; index < entryModules.length; index++) {
-                const entryModule = entryModules[index];
+            for (const [index, entryModule] of entryModules.entries()) {
                 entryModule.isUserDefinedEntryPoint =
                     entryModule.isUserDefinedEntryPoint || isUserDefined;
                 addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined, firstChunkNamePriority + index);
@@ -22301,19 +22337,19 @@ class ModuleLoader {
         try {
             source = await this.graph.fileOperationQueue.run(async () => (await this.pluginDriver.hookFirst('load', [id])) ?? (await promises.readFile(id, 'utf8')));
         }
-        catch (err) {
-            let msg = `Could not load ${id}`;
+        catch (error_) {
+            let message = `Could not load ${id}`;
             if (importer)
-                msg += ` (imported by ${relativeId(importer)})`;
-            msg += `: ${err.message}`;
-            err.message = msg;
-            throw err;
+                message += ` (imported by ${relativeId(importer)})`;
+            message += `: ${error_.message}`;
+            error_.message = message;
+            throw error_;
         }
         const sourceDescription = typeof source === 'string'
             ? { code: source }
             : source != null && typeof source === 'object' && typeof source.code === 'string'
                 ? source
-                : error(errBadLoader(id));
+                : error(errorBadLoader(id));
         const cachedModule = this.graph.cachedModules.get(id);
         if (cachedModule &&
             !cachedModule.customTransformCache &&
@@ -22383,7 +22419,7 @@ class ModuleLoader {
         const existingModule = this.modulesById.get(id);
         if (existingModule instanceof Module) {
             if (importer && doAssertionsDiffer(assertions, existingModule.info.assertions)) {
-                this.options.onwarn(errInconsistentImportAssertions(existingModule.info.assertions, assertions, id, importer));
+                this.options.onwarn(errorInconsistentImportAssertions(existingModule.info.assertions, assertions, id, importer));
             }
             await this.handleExistingModule(existingModule, isEntry, isPreload);
             return existingModule;
@@ -22432,10 +22468,10 @@ class ModuleLoader {
                 this.modulesById.set(id, externalModule);
             }
             else if (!(externalModule instanceof ExternalModule)) {
-                return error(errInternalIdCannotBeExternal(source, importer));
+                return error(errorInternalIdCannotBeExternal(source, importer));
             }
             else if (doAssertionsDiffer(externalModule.info.assertions, assertions)) {
-                this.options.onwarn(errInconsistentImportAssertions(externalModule.info.assertions, assertions, source, importer));
+                this.options.onwarn(errorInconsistentImportAssertions(externalModule.info.assertions, assertions, source, importer));
             }
             return Promise.resolve(externalModule);
         }
@@ -22502,6 +22538,7 @@ class ModuleLoader {
         });
     }
     getResolveStaticDependencyPromises(module) {
+        // eslint-disable-next-line unicorn/prefer-spread
         return Array.from(module.sourcesWithAssertions, async ([source, assertions]) => [
             source,
             (module.resolvedIds[source] =
@@ -22543,9 +22580,9 @@ class ModuleLoader {
     handleInvalidResolvedId(resolvedId, source, importer, assertions) {
         if (resolvedId === null) {
             if (isRelative(source)) {
-                return error(errUnresolvedImport(source, importer));
+                return error(errorUnresolvedImport(source, importer));
             }
-            this.options.onwarn(errUnresolvedImportTreatedAsExternal(source, importer));
+            this.options.onwarn(errorUnresolvedImportTreatedAsExternal(source, importer));
             return {
                 assertions,
                 external: true,
@@ -22556,7 +22593,7 @@ class ModuleLoader {
             };
         }
         else if (resolvedId.external && resolvedId.syntheticNamedExports) {
-            this.options.onwarn(errExternalSyntheticExports(source, importer));
+            this.options.onwarn(errorExternalSyntheticExports(source, importer));
         }
         return resolvedId;
     }
@@ -22564,14 +22601,14 @@ class ModuleLoader {
         const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT);
         if (resolveIdResult == null) {
             return error(implicitlyLoadedBefore === null
-                ? errUnresolvedEntry(unresolvedId)
-                : errUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
+                ? errorUnresolvedEntry(unresolvedId)
+                : errorUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
         }
         if (resolveIdResult === false ||
             (typeof resolveIdResult === 'object' && resolveIdResult.external)) {
             return error(implicitlyLoadedBefore === null
-                ? errEntryCannotBeExternal(unresolvedId)
-                : errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
+                ? errorEntryCannotBeExternal(unresolvedId)
+                : errorImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
         }
         return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
             ? resolveIdResult
@@ -22596,7 +22633,7 @@ class ModuleLoader {
             const existingResolution = module.resolvedIds[specifier];
             if (existingResolution) {
                 if (doAssertionsDiffer(existingResolution.assertions, assertions)) {
-                    this.options.onwarn(errInconsistentImportAssertions(existingResolution.assertions, assertions, specifier, importer));
+                    this.options.onwarn(errorInconsistentImportAssertions(existingResolution.assertions, assertions, specifier, importer));
                 }
                 return existingResolution;
             }
@@ -22655,18 +22692,18 @@ function generateAssetFileName(name, source, outputOptions, bundle) {
     return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
         ? outputOptions.assetFileNames({ name, source, type: 'asset' })
         : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => extname(emittedName).substring(1),
+        ext: () => extname(emittedName).slice(1),
         extname: () => extname(emittedName),
         hash: size => createHash()
             .update(source)
             .digest('hex')
-            .substring(0, size || defaultHashSize),
-        name: () => emittedName.substring(0, emittedName.length - extname(emittedName).length)
+            .slice(0, Math.max(0, size || defaultHashSize)),
+        name: () => emittedName.slice(0, Math.max(0, emittedName.length - extname(emittedName).length))
     }), bundle);
 }
 function reserveFileNameInBundle(fileName, { bundle }, warn) {
     if (bundle[lowercaseBundleKeys].has(fileName.toLowerCase())) {
-        warn(errFileNameConflict(fileName));
+        warn(errorFileNameConflict(fileName));
     }
     else {
         bundle[fileName] = FILE_PLACEHOLDER;
@@ -22684,13 +22721,13 @@ function hasValidName(emittedFile) {
 function getValidSource(source, emittedFile, fileReferenceId) {
     if (!(typeof source === 'string' || source instanceof Uint8Array)) {
         const assetName = emittedFile.fileName || emittedFile.name || fileReferenceId;
-        return error(errFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
+        return error(errorFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
     }
     return source;
 }
 function getAssetFileName(file, referenceId) {
     if (typeof file.fileName !== 'string') {
-        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
+        return error(errorAssetNotFinalisedForFileName(file.name || referenceId));
     }
     return file.fileName;
 }
@@ -22702,7 +22739,7 @@ function getChunkFileName(file, facadeChunkByModule) {
         const chunk = facadeChunkByModule.get(file.module);
         return chunk.id || chunk.getFileName();
     }
-    return error(errChunkNotGeneratedForFileName(file.fileName || file.name));
+    return error(errorChunkNotGeneratedForFileName(file.fileName || file.name));
 }
 class FileEmitter {
     constructor(graph, options, baseFileEmitter) {
@@ -22713,10 +22750,10 @@ class FileEmitter {
         this.output = null;
         this.emitFile = (emittedFile) => {
             if (!hasValidType(emittedFile)) {
-                return error(errFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
+                return error(errorFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
             }
             if (!hasValidName(emittedFile)) {
-                return error(errFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
+                return error(errorFailedValidation(`The "fileName" or "name" properties of emitted files must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
             }
             if (emittedFile.type === 'chunk') {
                 return this.emitChunk(emittedFile);
@@ -22726,13 +22763,13 @@ class FileEmitter {
         this.finaliseAssets = () => {
             for (const [referenceId, emittedFile] of this.filesByReferenceId) {
                 if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
-                    return error(errNoAssetSourceSet(emittedFile.name || referenceId));
+                    return error(errorNoAssetSourceSet(emittedFile.name || referenceId));
             }
         };
         this.getFileName = (fileReferenceId) => {
             const emittedFile = this.filesByReferenceId.get(fileReferenceId);
             if (!emittedFile)
-                return error(errFileReferenceIdNotFoundForFilename(fileReferenceId));
+                return error(errorFileReferenceIdNotFoundForFilename(fileReferenceId));
             if (emittedFile.type === 'chunk') {
                 return getChunkFileName(emittedFile, this.facadeChunkByModule);
             }
@@ -22741,12 +22778,12 @@ class FileEmitter {
         this.setAssetSource = (referenceId, requestedSource) => {
             const consumedFile = this.filesByReferenceId.get(referenceId);
             if (!consumedFile)
-                return error(errAssetReferenceIdNotFoundForSetSource(referenceId));
+                return error(errorAssetReferenceIdNotFoundForSetSource(referenceId));
             if (consumedFile.type !== 'asset') {
-                return error(errFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
+                return error(errorFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
             }
             if (consumedFile.source !== undefined) {
-                return error(errAssetSourceAlreadySet(consumedFile.name || referenceId));
+                return error(errorAssetSourceAlreadySet(consumedFile.name || referenceId));
             }
             const source = getValidSource(requestedSource, consumedFile, referenceId);
             if (this.output) {
@@ -22786,7 +22823,7 @@ class FileEmitter {
             referenceId = createHash()
                 .update(referenceId || idBase)
                 .digest('hex')
-                .substring(0, 8);
+                .slice(0, 8);
         } while (this.filesByReferenceId.has(referenceId));
         this.filesByReferenceId.set(referenceId, file);
         return referenceId;
@@ -22814,10 +22851,10 @@ class FileEmitter {
     }
     emitChunk(emittedChunk) {
         if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
-            return error(errInvalidRollupPhaseForChunkEmission());
+            return error(errorInvalidRollupPhaseForChunkEmission());
         }
         if (typeof emittedChunk.id !== 'string') {
-            return error(errFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+            return error(errorFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
         }
         const consumedChunk = {
             fileName: emittedChunk.fileName,
@@ -22879,14 +22916,14 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     return {
         addWatchFile(id) {
             if (graph.phase >= BuildPhase.GENERATE) {
-                return this.error(errInvalidRollupPhaseForAddWatchFile());
+                return this.error(errorInvalidRollupPhaseForAddWatchFile());
             }
             graph.watchFiles[id] = true;
         },
         cache: cacheInstance,
         emitFile: fileEmitter.emitFile.bind(fileEmitter),
-        error(err) {
-            return error(errPluginError(err, plugin.name));
+        error(error_) {
+            return error(errorPluginError(error_, plugin.name));
         },
         getFileName: fileEmitter.getFileName,
         getModuleIds: () => graph.modulesById.keys(),
@@ -22957,7 +22994,7 @@ class PluginDriver {
         this.finaliseAssets = this.fileEmitter.finaliseAssets.bind(this.fileEmitter);
         this.setChunkInformation = this.fileEmitter.setChunkInformation.bind(this.fileEmitter);
         this.setOutputBundle = this.fileEmitter.setOutputBundle.bind(this.fileEmitter);
-        this.plugins = (basePluginDriver ? basePluginDriver.plugins : []).concat(userPlugins);
+        this.plugins = [...(basePluginDriver ? basePluginDriver.plugins : []), ...userPlugins];
         const existingPluginNames = new Set();
         this.pluginContexts = new Map(this.plugins.map(plugin => [
             plugin,
@@ -22967,7 +23004,7 @@ class PluginDriver {
             for (const plugin of userPlugins) {
                 for (const hook of inputHooks) {
                     if (hook in plugin) {
-                        options.onwarn(errInputHookInOutputPlugin(plugin.name, hook));
+                        options.onwarn(errorInputHookInOutputPlugin(plugin.name, hook));
                     }
                 }
             }
@@ -22980,7 +23017,7 @@ class PluginDriver {
         return this.unfulfilledActions;
     }
     // chains, first non-null result stops and returns
-    hookFirst(hookName, args, replaceContext, skipped) {
+    hookFirst(hookName, parameters, replaceContext, skipped) {
         let promise = Promise.resolve(null);
         for (const plugin of this.getSortedPlugins(hookName)) {
             if (skipped && skipped.has(plugin))
@@ -22988,83 +23025,83 @@ class PluginDriver {
             promise = promise.then(result => {
                 if (result != null)
                     return result;
-                return this.runHook(hookName, args, plugin, replaceContext);
+                return this.runHook(hookName, parameters, plugin, replaceContext);
             });
         }
         return promise;
     }
     // chains synchronously, first non-null result stops and returns
-    hookFirstSync(hookName, args, replaceContext) {
+    hookFirstSync(hookName, parameters, replaceContext) {
         for (const plugin of this.getSortedPlugins(hookName)) {
-            const result = this.runHookSync(hookName, args, plugin, replaceContext);
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
             if (result != null)
                 return result;
         }
         return null;
     }
     // parallel, ignores returns
-    async hookParallel(hookName, args, replaceContext) {
+    async hookParallel(hookName, parameters, 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);
+                await this.runHook(hookName, parameters, plugin, replaceContext);
             }
             else {
-                parallelPromises.push(this.runHook(hookName, args, plugin, replaceContext));
+                parallelPromises.push(this.runHook(hookName, parameters, plugin, replaceContext));
             }
         }
         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);
+    hookReduceArg0(hookName, [argument0, ...rest], reduce, replaceContext) {
+        let promise = Promise.resolve(argument0);
         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)));
+            promise = promise.then(argument0 => this.runHook(hookName, [argument0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin)));
         }
         return promise;
     }
     // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
-    hookReduceArg0Sync(hookName, [arg0, ...rest], reduce, replaceContext) {
+    hookReduceArg0Sync(hookName, [argument0, ...rest], reduce, replaceContext) {
         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);
+            const parameters = [argument0, ...rest];
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            argument0 = reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin);
         }
-        return arg0;
+        return argument0;
     }
     // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
-    async hookReduceValue(hookName, initialValue, args, reducer) {
+    async hookReduceValue(hookName, initialValue, parameters, 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));
+                results.push(await this.runHook(hookName, parameters, plugin));
             }
             else {
-                parallelResults.push(this.runHook(hookName, args, plugin));
+                parallelResults.push(this.runHook(hookName, parameters, plugin));
             }
         }
         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;
+    hookReduceValueSync(hookName, initialValue, parameters, reduce, replaceContext) {
+        let accumulator = initialValue;
         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);
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            accumulator = reduce.call(this.pluginContexts.get(plugin), accumulator, result, plugin);
         }
-        return acc;
+        return accumulator;
     }
     // chains, ignores returns
-    hookSeq(hookName, args, replaceContext) {
+    hookSeq(hookName, parameters, replaceContext) {
         let promise = Promise.resolve();
         for (const plugin of this.getSortedPlugins(hookName)) {
-            promise = promise.then(() => this.runHook(hookName, args, plugin, replaceContext));
+            promise = promise.then(() => this.runHook(hookName, parameters, plugin, replaceContext));
         }
         return promise.then(noReturn);
     }
@@ -23072,7 +23109,7 @@ class PluginDriver {
         return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
     }
     // Implementation signature
-    runHook(hookName, args, plugin, replaceContext) {
+    runHook(hookName, parameters, plugin, replaceContext) {
         // We always filter for plugins that support the hook before running it
         const hook = plugin[hookName];
         const handler = typeof hook === 'object' ? hook.handler : hook;
@@ -23087,7 +23124,7 @@ class PluginDriver {
                 return handler;
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            const hookResult = handler.apply(context, args);
+            const hookResult = handler.apply(context, parameters);
             if (!hookResult?.then) {
                 // short circuit for non-thenables and non-Promises
                 return hookResult;
@@ -23096,7 +23133,7 @@ class PluginDriver {
             // unfulfilled promises cause rollup to abruptly and confusingly
             // exit with a successful 0 return code but without producing any
             // output, errors or warnings.
-            action = [plugin.name, hookName, args];
+            action = [plugin.name, hookName, parameters];
             this.unfulfilledActions.add(action);
             // Although it would be more elegant to just return hookResult here
             // and put the .then() handler just above the .catch() handler below,
@@ -23108,12 +23145,12 @@ class PluginDriver {
                 return result;
             });
         })
-            .catch(err => {
+            .catch(error_ => {
             if (action !== null) {
                 // action considered to be fulfilled since error being handled
                 this.unfulfilledActions.delete(action);
             }
-            return error(errPluginError(err, plugin.name, { hook: hookName }));
+            return error(errorPluginError(error_, plugin.name, { hook: hookName }));
         });
     }
     /**
@@ -23123,7 +23160,7 @@ class PluginDriver {
      * @param plugin The acutal plugin
      * @param replaceContext When passed, the plugin context can be overridden.
      */
-    runHookSync(hookName, args, plugin, replaceContext) {
+    runHookSync(hookName, parameters, plugin, replaceContext) {
         const hook = plugin[hookName];
         const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
@@ -23132,10 +23169,10 @@ class PluginDriver {
         }
         try {
             // eslint-disable-next-line @typescript-eslint/ban-types
-            return handler.apply(context, args);
+            return handler.apply(context, parameters);
         }
-        catch (err) {
-            return error(errPluginError(err, plugin.name, { hook: hookName }));
+        catch (error_) {
+            return error(errorPluginError(error_, plugin.name, { hook: hookName }));
         }
     }
 }
@@ -23167,12 +23204,12 @@ function getSortedValidatedPlugins(hookName, plugins, validateHandler = validate
 }
 function validateFunctionPluginHandler(handler, hookName, plugin) {
     if (typeof handler !== 'function') {
-        error(errInvalidFunctionPluginHook(hookName, plugin.name));
+        error(errorInvalidFunctionPluginHook(hookName, plugin.name));
     }
 }
 function validateAddonPluginHandler(handler, hookName, plugin) {
     if (typeof handler !== 'string' && typeof handler !== 'function') {
-        return error(errInvalidAddonPluginHook(hookName, plugin.name));
+        return error(errorInvalidAddonPluginHook(hookName, plugin.name));
     }
 }
 function noReturn() { }
@@ -23200,8 +23237,8 @@ class Queue {
                 const result = await task();
                 resolve(result);
             }
-            catch (err) {
-                reject(err);
+            catch (error) {
+                reject(error);
             }
         }
         this.workerCount--;
@@ -23262,7 +23299,7 @@ class Graph {
         }
         if (watcher) {
             this.watchMode = true;
-            const handleChange = (...args) => this.pluginDriver.hookParallel('watchChange', args);
+            const handleChange = (...parameters) => this.pluginDriver.hookParallel('watchChange', parameters);
             const handleClose = () => this.pluginDriver.hookParallel('closeWatcher', []);
             watcher.onCurrentRun('change', handleChange);
             watcher.onCurrentRun('close', handleClose);
@@ -23288,15 +23325,13 @@ class Graph {
     contextParse(code, options = {}) {
         const onCommentOrig = options.onComment;
         const comments = [];
-        if (onCommentOrig && typeof onCommentOrig == 'function') {
-            options.onComment = (block, text, start, end, ...args) => {
-                comments.push({ end, start, type: block ? 'Block' : 'Line', value: text });
-                return onCommentOrig.call(options, block, text, start, end, ...args);
-            };
-        }
-        else {
-            options.onComment = comments;
-        }
+        options.onComment =
+            onCommentOrig && typeof onCommentOrig == 'function'
+                ? (block, text, start, end, ...parameters) => {
+                    comments.push({ end, start, type: block ? 'Block' : 'Line', value: text });
+                    return onCommentOrig.call(options, block, text, start, end, ...parameters);
+                }
+                : comments;
         const ast = this.acornParser.parse(code, {
             ...this.options.acorn,
             ...options
@@ -23383,7 +23418,7 @@ class Graph {
         for (const module of this.implicitEntryModules) {
             for (const dependant of module.implicitlyLoadedAfter) {
                 if (!(dependant.info.isEntry || dependant.isIncluded())) {
-                    error(errImplicitDependantIsNotIncluded(dependant));
+                    error(errorImplicitDependantIsNotIncluded(dependant));
                 }
             }
         }
@@ -23391,7 +23426,7 @@ class Graph {
     sortModules() {
         const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
         for (const cyclePath of cyclePaths) {
-            this.options.onwarn(errCircularDependency(cyclePath));
+            this.options.onwarn(errorCircularDependency(cyclePath));
         }
         this.modules = orderedModules;
         for (const module of this.modules) {
@@ -23404,37 +23439,32 @@ class Graph {
             for (const importDescription of module.importDescriptions.values()) {
                 if (importDescription.name !== '*' &&
                     !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
-                    module.warn(errMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
+                    module.warn(errorMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
                 }
             }
         }
     }
 }
 
-function ensureArray(items) {
-    if (Array.isArray(items)) {
-        return items.filter(Boolean);
-    }
-    if (items) {
-        return [items];
-    }
-    return [];
-}
-
-function formatAction([pluginName, hookName, args]) {
+function formatAction([pluginName, hookName, parameters]) {
     const action = `(${pluginName}) ${hookName}`;
     const s = JSON.stringify;
     switch (hookName) {
-        case 'resolveId':
-            return `${action} ${s(args[0])} ${s(args[1])}`;
-        case 'load':
-            return `${action} ${s(args[0])}`;
-        case 'transform':
-            return `${action} ${s(args[1])}`;
-        case 'shouldTransformCachedModule':
-            return `${action} ${s(args[0].id)}`;
-        case 'moduleParsed':
-            return `${action} ${s(args[0].id)}`;
+        case 'resolveId': {
+            return `${action} ${s(parameters[0])} ${s(parameters[1])}`;
+        }
+        case 'load': {
+            return `${action} ${s(parameters[0])}`;
+        }
+        case 'transform': {
+            return `${action} ${s(parameters[1])}`;
+        }
+        case 'shouldTransformCachedModule': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
+        case 'moduleParsed': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
     }
     return action;
 }
@@ -23748,12 +23778,29 @@ function importAssertions(Parser) {
   };
 }
 
+function ensureArray(items) {
+    if (Array.isArray(items)) {
+        return items.filter(Boolean);
+    }
+    if (items) {
+        return [items];
+    }
+    return [];
+}
+
+async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}
+
 const defaultOnWarn = warning => console.warn(warning.message || warning);
 function warnUnknownOptions(passedOptions, validOptions, optionType, warn, ignoredKeys = /$./) {
     const validOptionSet = new Set(validOptions);
     const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
     if (unknownOptions.length > 0) {
-        warn(errUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
+        warn(errorUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
     }
 }
 const treeshakePresets = {
@@ -23805,7 +23852,7 @@ const objectifyOptionWithPresets = (presets, optionName, additionalValues) => (v
         if (preset) {
             return preset;
         }
-        error(errInvalidOption(optionName, getHashFromObjectOption(optionName), `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
+        error(errorInvalidOption(optionName, getHashFromObjectOption(optionName), `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
     }
     return objectifyOption(value);
 };
@@ -23817,15 +23864,15 @@ const getOptionWithPreset = (value, presets, optionName, additionalValues) => {
             return { ...preset, ...value };
         }
         else {
-            error(errInvalidOption(`${optionName}.preset`, getHashFromObjectOption(optionName), `valid values are ${printQuotedStringList(Object.keys(presets))}`, presetName));
+            error(errorInvalidOption(`${optionName}.preset`, getHashFromObjectOption(optionName), `valid values are ${printQuotedStringList(Object.keys(presets))}`, presetName));
         }
     }
     return objectifyOptionWithPresets(presets, optionName, additionalValues)(value);
 };
 const getHashFromObjectOption = (optionName) => optionName.split('.').join('').toLowerCase();
-const normalizePluginOption = (plugins) => [plugins].flat(Infinity).filter(Boolean);
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
 
-function normalizeInputOptions(config) {
+async function normalizeInputOptions(config) {
     // These are options that may trigger special warnings or behaviour later
     // if the user did not select an explicit value
     const unsetOptions = new Set();
@@ -23849,7 +23896,7 @@ function normalizeInputOptions(config) {
         moduleContext: getModuleContext(config, context),
         onwarn,
         perf: config.perf || false,
-        plugins: normalizePluginOption(config.plugins),
+        plugins: await normalizePluginOption(config.plugins),
         preserveEntrySignatures: config.preserveEntrySignatures ?? 'exports-only',
         preserveModules: getPreserveModules$1(config, onwarn, strictDeprecations),
         preserveSymlinks: config.preserveSymlinks || false,
@@ -23865,13 +23912,13 @@ const getOnwarn = (config) => {
     return onwarn
         ? warning => {
             warning.toString = () => {
-                let str = '';
+                let warningString = '';
                 if (warning.plugin)
-                    str += `(${warning.plugin} plugin) `;
+                    warningString += `(${warning.plugin} plugin) `;
                 if (warning.loc)
-                    str += `${relativeId(warning.loc.file)} (${warning.loc.line}:${warning.loc.column}) `;
-                str += warning.message;
-                return str;
+                    warningString += `${relativeId(warning.loc.file)} (${warning.loc.line}:${warning.loc.column}) `;
+                warningString += warning.message;
+                return warningString;
             };
             onwarn(warning, defaultOnWarn);
         }
@@ -23894,7 +23941,7 @@ const getIdMatcher = (option) => {
         return () => true;
     }
     if (typeof option === 'function') {
-        return (id, ...args) => (!id.startsWith('\0') && option(id, ...args)) || false;
+        return (id, ...parameters) => (!id.startsWith('\0') && option(id, ...parameters)) || false;
     }
     if (option) {
         const ids = new Set();
@@ -23907,7 +23954,7 @@ const getIdMatcher = (option) => {
                 ids.add(value);
             }
         }
-        return (id, ..._args) => ids.has(id) || matchers.some(matcher => matcher.test(id));
+        return (id, ..._arguments) => ids.has(id) || matchers.some(matcher => matcher.test(id));
     }
     return () => false;
 };
@@ -23995,34 +24042,34 @@ const getHasModuleSideEffects = (moduleSideEffectsOption) => {
         return id => ids.has(id);
     }
     if (moduleSideEffectsOption) {
-        error(errInvalidOption('treeshake.moduleSideEffects', 'treeshake', 'please use one of false, "no-external", a function or an array'));
+        error(errorInvalidOption('treeshake.moduleSideEffects', 'treeshake', 'please use one of false, "no-external", a function or an array'));
     }
     return () => true;
 };
 
 // https://datatracker.ietf.org/doc/html/rfc2396
 // eslint-disable-next-line no-control-regex
-const INVALID_CHAR_REGEX = /[\x00-\x1F\x7F<>*#"{}|^[\]`;?:&=+$,]/g;
+const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$&*+,:;<=>?[\]^`{|}\u007F]/g;
 const DRIVE_LETTER_REGEX = /^[a-z]:/i;
 function sanitizeFileName(name) {
     const match = DRIVE_LETTER_REGEX.exec(name);
     const driveLetter = match ? match[0] : '';
     // A `:` is only allowed as part of a windows drive letter (ex: C:\foo)
     // Otherwise, avoid them because they can refer to NTFS alternate data streams.
-    return driveLetter + name.substr(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
+    return driveLetter + name.slice(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
 }
 
 function isValidUrl(url) {
     try {
         new URL(url);
     }
-    catch (_) {
+    catch {
         return false;
     }
     return true;
 }
 
-function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
+async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
     // These are options that may trigger special warnings or behaviour later
     // if the user did not select an explicit value
     const unsetOptions = new Set(unsetInputOptions);
@@ -24066,7 +24113,7 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         noConflict: config.noConflict || false,
         outro: getAddon(config, 'outro'),
         paths: config.paths || {},
-        plugins: normalizePluginOption(config.plugins),
+        plugins: await normalizePluginOption(config.plugins),
         preferConst,
         preserveModules,
         preserveModulesRoot: getPreserveModulesRoot(config),
@@ -24091,10 +24138,10 @@ const getFile = (config, preserveModules, inputOptions) => {
     const { file } = config;
     if (typeof file === 'string') {
         if (preserveModules) {
-            return error(errInvalidOption('output.file', 'outputdir', 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
+            return error(errorInvalidOption('output.file', 'outputdir', 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
         }
         if (!Array.isArray(inputOptions.input))
-            return error(errInvalidOption('output.file', 'outputdir', 'you must set "output.dir" instead of "output.file" when providing named inputs'));
+            return error(errorInvalidOption('output.file', 'outputdir', 'you must set "output.dir" instead of "output.file" when providing named inputs'));
     }
     return file;
 };
@@ -24104,30 +24151,35 @@ const getFormat = (config) => {
         case undefined:
         case 'es':
         case 'esm':
-        case 'module':
+        case 'module': {
             return 'es';
+        }
         case 'cjs':
-        case 'commonjs':
+        case 'commonjs': {
             return 'cjs';
+        }
         case 'system':
-        case 'systemjs':
+        case 'systemjs': {
             return 'system';
+        }
         case 'amd':
         case 'iife':
-        case 'umd':
+        case 'umd': {
             return configFormat;
-        default:
+        }
+        default: {
             return error({
                 message: `You must specify "output.format", which can be one of "amd", "cjs", "system", "es", "iife" or "umd".`,
                 url: `https://rollupjs.org/guide/en/#outputformat`
             });
+        }
     }
 };
 const getInlineDynamicImports = (config, inputOptions) => {
     const inlineDynamicImports = (config.inlineDynamicImports ?? inputOptions.inlineDynamicImports) || false;
     const { input } = inputOptions;
     if (inlineDynamicImports && (Array.isArray(input) ? input : Object.keys(input)).length > 1) {
-        return error(errInvalidOption('output.inlineDynamicImports', 'outputinlinedynamicimports', 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
+        return error(errorInvalidOption('output.inlineDynamicImports', 'outputinlinedynamicimports', 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
     }
     return inlineDynamicImports;
 };
@@ -24135,10 +24187,10 @@ const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
     const preserveModules = (config.preserveModules ?? inputOptions.preserveModules) || false;
     if (preserveModules) {
         if (inlineDynamicImports) {
-            return error(errInvalidOption('output.inlineDynamicImports', 'outputinlinedynamicimports', `this option is not supported for "output.preserveModules"`));
+            return error(errorInvalidOption('output.inlineDynamicImports', 'outputinlinedynamicimports', `this option is not supported for "output.preserveModules"`));
         }
         if (inputOptions.preserveEntrySignatures === false) {
-            return error(errInvalidOption('preserveEntrySignatures', 'preserveentrysignatures', 'setting this option to false is not supported for "output.preserveModules"'));
+            return error(errorInvalidOption('preserveEntrySignatures', 'preserveentrysignatures', 'setting this option to false is not supported for "output.preserveModules"'));
         }
     }
     return preserveModules;
@@ -24166,29 +24218,24 @@ const getAmd = (config) => {
         ...config.amd
     };
     if ((mergedOption.autoId || mergedOption.basePath) && mergedOption.id) {
-        return error(errInvalidOption('output.amd.id', 'outputamd', 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
+        return error(errorInvalidOption('output.amd.id', 'outputamd', 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
     }
     if (mergedOption.basePath && !mergedOption.autoId) {
-        return error(errInvalidOption('output.amd.basePath', 'outputamd', 'this option only works with "output.amd.autoId"'));
+        return error(errorInvalidOption('output.amd.basePath', 'outputamd', 'this option only works with "output.amd.autoId"'));
     }
-    let normalized;
-    if (mergedOption.autoId) {
-        normalized = {
+    return mergedOption.autoId
+        ? {
             autoId: true,
             basePath: mergedOption.basePath,
             define: mergedOption.define,
             forceJsExtensionForImports: mergedOption.forceJsExtensionForImports
-        };
-    }
-    else {
-        normalized = {
+        }
+        : {
             autoId: false,
             define: mergedOption.define,
             forceJsExtensionForImports: mergedOption.forceJsExtensionForImports,
             id: mergedOption.id
         };
-    }
-    return normalized;
 };
 const getAddon = (config, name) => {
     const configAddon = config[name];
@@ -24197,10 +24244,11 @@ const getAddon = (config, name) => {
     }
     return () => configAddon || '';
 };
+// eslint-disable-next-line unicorn/prevent-abbreviations
 const getDir = (config, file) => {
     const { dir } = config;
     if (typeof dir === 'string' && typeof file === 'string') {
-        return error(errInvalidOption('output.dir', 'outputdir', 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
+        return error(errorInvalidOption('output.dir', 'outputdir', 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
     }
     return dir;
 };
@@ -24209,7 +24257,7 @@ const getDynamicImportFunction = (config, inputOptions, format) => {
     if (configDynamicImportFunction) {
         warnDeprecation(`The "output.dynamicImportFunction" option is deprecated. Use the "renderDynamicImport" plugin hook instead.`, true, inputOptions);
         if (format !== 'es') {
-            inputOptions.onwarn(errInvalidOption('output.dynamicImportFunction', 'outputdynamicImportFunction', 'this option is ignored for formats other than "es"'));
+            inputOptions.onwarn(errorInvalidOption('output.dynamicImportFunction', 'outputdynamicImportFunction', 'this option is ignored for formats other than "es"'));
         }
     }
     return configDynamicImportFunction;
@@ -24227,7 +24275,7 @@ function getExports(config, unsetOptions) {
         unsetOptions.add('exports');
     }
     else if (!['default', 'named', 'none', 'auto'].includes(configExports)) {
-        return error(errInvalidExportOptionValue(configExports));
+        return error(errorInvalidExportOptionValue(configExports));
     }
     return configExports || 'auto';
 }
@@ -24257,12 +24305,6 @@ const ALLOWED_INTEROP_TYPES = new Set([
 ]);
 const getInterop = (config) => {
     const configInterop = config.interop;
-    const validateInterop = (interop) => {
-        if (!ALLOWED_INTEROP_TYPES.has(interop)) {
-            return error(errInvalidOption('output.interop', 'outputinterop', `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
-        }
-        return interop;
-    };
     if (typeof configInterop === 'function') {
         const interopPerId = Object.create(null);
         let defaultInterop = null;
@@ -24274,14 +24316,22 @@ const getInterop = (config) => {
     }
     return configInterop === undefined ? () => 'default' : () => validateInterop(configInterop);
 };
+const validateInterop = (interop) => {
+    if (!ALLOWED_INTEROP_TYPES.has(interop)) {
+        return error(errorInvalidOption('output.interop', 'outputinterop', 
+        // eslint-disable-next-line unicorn/prefer-spread
+        `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
+    }
+    return interop;
+};
 const getManualChunks = (config, inlineDynamicImports, preserveModules, inputOptions) => {
     const configManualChunks = config.manualChunks || inputOptions.manualChunks;
     if (configManualChunks) {
         if (inlineDynamicImports) {
-            return error(errInvalidOption('output.manualChunks', 'outputmanualchunks', 'this option is not supported for "output.inlineDynamicImports"'));
+            return error(errorInvalidOption('output.manualChunks', 'outputmanualchunks', 'this option is not supported for "output.inlineDynamicImports"'));
         }
         if (preserveModules) {
-            return error(errInvalidOption('output.manualChunks', 'outputmanualchunks', 'this option is not supported for "output.preserveModules"'));
+            return error(errorInvalidOption('output.manualChunks', 'outputmanualchunks', 'this option is not supported for "output.preserveModules"'));
         }
     }
     return configManualChunks || {};
@@ -24301,7 +24351,7 @@ const getSourcemapBaseUrl = (config) => {
         if (isValidUrl(sourcemapBaseUrl)) {
             return sourcemapBaseUrl;
         }
-        return error(errInvalidOption('output.sourcemapBaseUrl', 'outputsourcemapbaseurl', `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
+        return error(errorInvalidOption('output.sourcemapBaseUrl', 'outputsourcemapbaseurl', `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
     }
 };
 
@@ -24324,14 +24374,14 @@ async function rollupInternal(rawInputOptions, watcher) {
             timeEnd('initialize', 2);
             await graph.build();
         }
-        catch (err) {
+        catch (error_) {
             const watchFiles = Object.keys(graph.watchFiles);
             if (watchFiles.length > 0) {
-                err.watchFiles = watchFiles;
+                error_.watchFiles = watchFiles;
             }
-            await graph.pluginDriver.hookParallel('buildEnd', [err]);
+            await graph.pluginDriver.hookParallel('buildEnd', [error_]);
             await graph.pluginDriver.hookParallel('closeBundle', []);
-            throw err;
+            throw error_;
         }
         await graph.pluginDriver.hookParallel('buildEnd', []);
     });
@@ -24347,13 +24397,13 @@ async function rollupInternal(rawInputOptions, watcher) {
         closed: false,
         async generate(rawOutputOptions) {
             if (result.closed)
-                return error(errAlreadyClosed());
+                return error(errorAlreadyClosed());
             return handleGenerateWrite(false, inputOptions, unsetInputOptions, rawOutputOptions, graph);
         },
         watchFiles: Object.keys(graph.watchFiles),
         async write(rawOutputOptions) {
             if (result.closed)
-                return error(errAlreadyClosed());
+                return error(errorAlreadyClosed());
             return handleGenerateWrite(true, inputOptions, unsetInputOptions, rawOutputOptions, graph);
         }
     };
@@ -24365,33 +24415,34 @@ async function getInputOptions(rawInputOptions, watchMode) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    const rawPlugins = getSortedValidatedPlugins('options', ensureArray(rawInputOptions.plugins));
-    const { options, unsetOptions } = normalizeInputOptions(await rawPlugins.reduce(applyOptionHook(watchMode), Promise.resolve(rawInputOptions)));
+    const rawPlugins = getSortedValidatedPlugins('options', await normalizePluginOption(rawInputOptions.plugins));
+    const { options, unsetOptions } = await 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) => {
         const handler = 'handler' in plugin.options ? plugin.options.handler : plugin.options;
-        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
+        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) ||
+            inputOptions);
     };
 }
 function normalizePlugins(plugins, anonymousPrefix) {
-    plugins.forEach((plugin, index) => {
+    for (const [index, plugin] of plugins.entries()) {
         if (!plugin.name) {
             plugin.name = `${anonymousPrefix}${index + 1}`;
         }
-    });
+    }
 }
-function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutputOptions, graph) {
-    const { options: outputOptions, outputPluginDriver, unsetOptions } = getOutputOptionsAndPluginDriver(rawOutputOptions, graph.pluginDriver, inputOptions, unsetInputOptions);
+async function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutputOptions, graph) {
+    const { options: outputOptions, outputPluginDriver, unsetOptions } = await getOutputOptionsAndPluginDriver(rawOutputOptions, graph.pluginDriver, inputOptions, unsetInputOptions);
     return catchUnfinishedHookActions(outputPluginDriver, async () => {
         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(errMissingFileOrDirOption());
+                return error(errorMissingFileOrDirOption());
             }
             await Promise.all(Object.values(generated).map(chunk => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
             await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);
@@ -24400,21 +24451,21 @@ function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutput
         return createOutput(generated);
     });
 }
-function getOutputOptionsAndPluginDriver(rawOutputOptions, inputPluginDriver, inputOptions, unsetInputOptions) {
+async function getOutputOptionsAndPluginDriver(rawOutputOptions, inputPluginDriver, inputOptions, unsetInputOptions) {
     if (!rawOutputOptions) {
         throw new Error('You must supply an options object');
     }
-    const rawPlugins = ensureArray(rawOutputOptions.plugins);
+    const rawPlugins = await normalizePluginOption(rawOutputOptions.plugins);
     normalizePlugins(rawPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX);
     const outputPluginDriver = inputPluginDriver.createOutputPluginDriver(rawPlugins);
     return {
-        ...getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver),
+        ...(await getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver)),
         outputPluginDriver
     };
 }
 function getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver) {
-    return normalizeOutputOptions(outputPluginDriver.hookReduceArg0Sync('outputOptions', [rawOutputOptions.output || rawOutputOptions], (outputOptions, result) => result || outputOptions, pluginContext => {
-        const emitError = () => pluginContext.error(errCannotEmitFromOptionsHook());
+    return normalizeOutputOptions(outputPluginDriver.hookReduceArg0Sync('outputOptions', [rawOutputOptions], (outputOptions, result) => result || outputOptions, pluginContext => {
+        const emitError = () => pluginContext.error(errorCannotEmitFromOptionsHook());
         return {
             ...pluginContext,
             emitFile: emitError,
@@ -24457,6 +24508,321 @@ function defineConfig(options) {
     return options;
 }
 
+const {
+  env = {},
+  argv = [],
+  platform = "",
+} = typeof process === "undefined" ? {} : process;
+
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+
+const isCompatibleTerminal =
+  tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled &&
+  (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: String }),
+        {}
+      );
+
+createColors();
+
+// @see https://no-color.org
+// @see https://www.npmjs.com/package/chalk
+const { bold, cyan, dim, gray, green, red, underline, yellow } = createColors({
+    useColor: env$1.FORCE_COLOR !== '0' && !env$1.NO_COLOR
+});
+
+// log to stderr to keep `rollup main.js > bundle.js` from breaking
+const stderr = (...parameters) => process$1.stderr.write(`${parameters.join('')}\n`);
+function handleError(error, recover = false) {
+    const name = error.name || error.cause?.name;
+    const nameSection = name ? `${name}: ` : '';
+    const pluginSection = error.plugin ? `(plugin ${error.plugin}) ` : '';
+    const message = `${pluginSection}${nameSection}${error.message}`;
+    stderr(bold(red(`[!] ${bold(message.toString())}`)));
+    if (error.url) {
+        stderr(cyan(error.url));
+    }
+    if (error.loc) {
+        stderr(`${relativeId((error.loc.file || error.id))} (${error.loc.line}:${error.loc.column})`);
+    }
+    else if (error.id) {
+        stderr(relativeId(error.id));
+    }
+    if (error.frame) {
+        stderr(dim(error.frame));
+    }
+    if (error.stack) {
+        stderr(dim(error.stack));
+    }
+    stderr('');
+    // eslint-disable-next-line unicorn/no-process-exit
+    if (!recover)
+        process$1.exit(1);
+}
+
+const commandAliases = {
+    c: 'config',
+    d: 'dir',
+    e: 'external',
+    f: 'format',
+    g: 'globals',
+    h: 'help',
+    i: 'input',
+    m: 'sourcemap',
+    n: 'name',
+    o: 'file',
+    p: 'plugin',
+    v: 'version',
+    w: 'watch'
+};
+const EMPTY_COMMAND_OPTIONS = { external: [], globals: undefined };
+async function mergeOptions(config, rawCommandOptions = EMPTY_COMMAND_OPTIONS, defaultOnWarnHandler = defaultOnWarn) {
+    const command = getCommandOptions(rawCommandOptions);
+    const inputOptions = await mergeInputOptions(config, command, defaultOnWarnHandler);
+    const warn = inputOptions.onwarn;
+    if (command.output) {
+        Object.assign(command, command.output);
+    }
+    const outputOptionsArray = ensureArray(config.output);
+    if (outputOptionsArray.length === 0)
+        outputOptionsArray.push({});
+    const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn)));
+    warnUnknownOptions(command, [
+        ...Object.keys(inputOptions),
+        ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapPathTransform'),
+        ...Object.keys(commandAliases),
+        'bundleConfigAsCjs',
+        'config',
+        'environment',
+        'plugin',
+        'silent',
+        'failAfterWarnings',
+        'stdin',
+        'waitForBundleInput',
+        'configPlugin'
+    ], 'CLI flags', warn, /^_$|output$|config/);
+    inputOptions.output = outputOptions;
+    return inputOptions;
+}
+function getCommandOptions(rawCommandOptions) {
+    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
+        ? rawCommandOptions.external.split(',')
+        : [];
+    return {
+        ...rawCommandOptions,
+        external,
+        globals: typeof rawCommandOptions.globals === 'string'
+            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
+                const [id, variableName] = globalDefinition.split(':');
+                globals[id] = variableName;
+                if (!external.includes(id)) {
+                    external.push(id);
+                }
+                return globals;
+            }, Object.create(null))
+            : undefined
+    };
+}
+async function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const inputOptions = {
+        acorn: getOption('acorn'),
+        acornInjectPlugins: config.acornInjectPlugins,
+        cache: config.cache,
+        context: getOption('context'),
+        experimentalCacheExpiry: getOption('experimentalCacheExpiry'),
+        external: getExternal(config, overrides),
+        inlineDynamicImports: getOption('inlineDynamicImports'),
+        input: getOption('input') || [],
+        makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
+        manualChunks: getOption('manualChunks'),
+        maxParallelFileOps: getOption('maxParallelFileOps'),
+        maxParallelFileReads: getOption('maxParallelFileReads'),
+        moduleContext: getOption('moduleContext'),
+        onwarn: getOnWarn(config, defaultOnWarnHandler),
+        perf: getOption('perf'),
+        plugins: await normalizePluginOption(config.plugins),
+        preserveEntrySignatures: getOption('preserveEntrySignatures'),
+        preserveModules: getOption('preserveModules'),
+        preserveSymlinks: getOption('preserveSymlinks'),
+        shimMissingExports: getOption('shimMissingExports'),
+        strictDeprecations: getOption('strictDeprecations'),
+        treeshake: getObjectOption(config, overrides, 'treeshake', objectifyOptionWithPresets(treeshakePresets, 'treeshake', 'false, true, ')),
+        watch: getWatch(config, overrides)
+    };
+    warnUnknownOptions(config, Object.keys(inputOptions), 'input options', inputOptions.onwarn, /^output$/);
+    return inputOptions;
+}
+const getExternal = (config, overrides) => {
+    const configExternal = config.external;
+    return typeof configExternal === 'function'
+        ? (source, importer, isResolved) => configExternal(source, importer, isResolved) || overrides.external.includes(source)
+        : [...ensureArray(configExternal), ...overrides.external];
+};
+const getOnWarn = (config, defaultOnWarnHandler) => config.onwarn
+    ? warning => config.onwarn(warning, defaultOnWarnHandler)
+    : defaultOnWarnHandler;
+const getObjectOption = (config, overrides, name, objectifyValue = objectifyOption) => {
+    const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
+    const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
+    if (commandOption !== undefined) {
+        return commandOption && { ...configOption, ...commandOption };
+    }
+    return configOption;
+};
+const getWatch = (config, overrides) => config.watch !== false && getObjectOption(config, overrides, 'watch');
+const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
+    if (!optionValue) {
+        return optionValue;
+    }
+    if (Array.isArray(optionValue)) {
+        return optionValue.reduce((result, value) => value && result && { ...result, ...objectifyValue(value) }, {});
+    }
+    return objectifyValue(optionValue);
+};
+async function mergeOutputOptions(config, overrides, warn) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const outputOptions = {
+        amd: getObjectOption(config, overrides, 'amd'),
+        assetFileNames: getOption('assetFileNames'),
+        banner: getOption('banner'),
+        chunkFileNames: getOption('chunkFileNames'),
+        compact: getOption('compact'),
+        dir: getOption('dir'),
+        dynamicImportFunction: getOption('dynamicImportFunction'),
+        dynamicImportInCjs: getOption('dynamicImportInCjs'),
+        entryFileNames: getOption('entryFileNames'),
+        esModule: getOption('esModule'),
+        exports: getOption('exports'),
+        extend: getOption('extend'),
+        externalImportAssertions: getOption('externalImportAssertions'),
+        externalLiveBindings: getOption('externalLiveBindings'),
+        file: getOption('file'),
+        footer: getOption('footer'),
+        format: getOption('format'),
+        freeze: getOption('freeze'),
+        generatedCode: getObjectOption(config, overrides, 'generatedCode', objectifyOptionWithPresets(generatedCodePresets, 'output.generatedCode', '')),
+        globals: getOption('globals'),
+        hoistTransitiveImports: getOption('hoistTransitiveImports'),
+        indent: getOption('indent'),
+        inlineDynamicImports: getOption('inlineDynamicImports'),
+        interop: getOption('interop'),
+        intro: getOption('intro'),
+        manualChunks: getOption('manualChunks'),
+        minifyInternalExports: getOption('minifyInternalExports'),
+        name: getOption('name'),
+        namespaceToStringTag: getOption('namespaceToStringTag'),
+        noConflict: getOption('noConflict'),
+        outro: getOption('outro'),
+        paths: getOption('paths'),
+        plugins: await normalizePluginOption(config.plugins),
+        preferConst: getOption('preferConst'),
+        preserveModules: getOption('preserveModules'),
+        preserveModulesRoot: getOption('preserveModulesRoot'),
+        sanitizeFileName: getOption('sanitizeFileName'),
+        sourcemap: getOption('sourcemap'),
+        sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
+        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
+        sourcemapFile: getOption('sourcemapFile'),
+        sourcemapPathTransform: getOption('sourcemapPathTransform'),
+        strict: getOption('strict'),
+        systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate')
+    };
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', warn);
+    return outputOptions;
+}
+
 class WatchEmitter {
     constructor() {
         this.currentHandlers = Object.create(null);
@@ -24464,10 +24830,8 @@ class WatchEmitter {
     }
     // Will be overwritten by Rollup
     async close() { }
-    emit(event, ...args) {
-        return Promise.all(this.getCurrentHandlers(event)
-            .concat(this.getPersistentHandlers(event))
-            .map(handler => handler(...args)));
+    emit(event, ...parameters) {
+        return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
     }
     off(event, listener) {
         const listeners = this.persistentHandlers[event];
@@ -24488,9 +24852,9 @@ class WatchEmitter {
         return this;
     }
     once(event, listener) {
-        const selfRemovingListener = (...args) => {
+        const selfRemovingListener = (...parameters) => {
             this.off(event, selfRemovingListener);
-            return listener(...args);
+            return listener(...parameters);
         };
         this.on(event, selfRemovingListener);
         return this;
@@ -24518,8 +24882,8 @@ async function loadFsEvents() {
     try {
         ({ default: fsEvents } = await import('fsevents'));
     }
-    catch (err) {
-        fsEventsImportError = err;
+    catch (error) {
+        fsEventsImportError = error;
     }
 }
 // A call to this function will be injected into the chokidar code
@@ -24537,15 +24901,20 @@ const fseventsImporter = /*#__PURE__*/Object.defineProperty({
 
 function watch(configs) {
     const emitter = new WatchEmitter();
-    const configArray = ensureArray(configs);
-    const watchConfigs = configArray.filter(config => config.watch !== false);
-    if (watchConfigs.length === 0) {
-        return error(errInvalidOption('watch', 'watch', 'there must be at least one config where "watch" is not set to "false"'));
-    }
-    loadFsEvents()
-        .then(() => import('./watch.js'))
-        .then(({ Watcher }) => new Watcher(watchConfigs, emitter));
+    watchInternal(configs, emitter).catch(error => {
+        handleError(error);
+    });
     return emitter;
 }
+async function watchInternal(configs, emitter) {
+    const optionsList = await Promise.all(ensureArray(configs).map(config => mergeOptions(config)));
+    const watchOptionsList = optionsList.filter(config => config.watch !== false);
+    if (watchOptionsList.length === 0) {
+        return error(errorInvalidOption('watch', 'watch', 'there must be at least one config where "watch" is not set to "false"'));
+    }
+    await loadFsEvents();
+    const { Watcher } = await import('./watch.js');
+    new Watcher(watchOptionsList, emitter);
+}
 
-export { createFilter, defaultOnWarn, defineConfig, ensureArray, fseventsImporter, generatedCodePresets, getAugmentedNamespace, normalizePluginOption, objectifyOption, objectifyOptionWithPresets, picomatch$1 as picomatch, rollup, rollupInternal, treeshakePresets, version$1 as version, warnUnknownOptions, watch };
+export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, picomatch$1 as picomatch, rollup, rollupInternal, version$1 as version, watch };