rollup 2.65.0 → 2.67.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.65.0
-	Fri, 21 Jan 2022 07:42:35 GMT - commit bebc50ddb613d240a03988d51787fd71b1a3914f
+	Rollup.js v2.67.1
+	Mon, 07 Feb 2022 05:29:30 GMT - commit efd71e930e86ab30f4911ed8caa7f78aca005729
 
 
 	https://github.com/rollup/rollup
@@ -14,8 +14,8 @@ const require$$0 = require('path');
 const process$1 = require('process');
 const perf_hooks = require('perf_hooks');
 const crypto = require('crypto');
-const fs = require('fs');
-const require$$0$1 = require('events');
+const require$$0$1 = require('fs');
+const require$$0$2 = require('events');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null);
@@ -28,7 +28,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.65.0";
+var version$1 = "2.67.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -381,22 +381,22 @@ function errMixedExport(facadeModuleId, name) {
         url: `https://rollupjs.org/guide/en/#outputexports`
     };
 }
-function errNamespaceConflict(name, reexportingModule, additionalExportAllModule) {
+function errNamespaceConflict(name, reexportingModuleId, sources) {
     return {
         code: Errors.NAMESPACE_CONFLICT,
-        message: `Conflicting namespaces: "${relativeId(reexportingModule.id)}" re-exports "${name}" from both "${relativeId(reexportingModule.exportsAll[name])}" and "${relativeId(additionalExportAllModule.exportsAll[name])}" (will be ignored)`,
+        message: `Conflicting namespaces: "${relativeId(reexportingModuleId)}" re-exports "${name}" from one of the modules ${printQuotedStringList(sources.map(moduleId => relativeId(moduleId)))} (will be ignored)`,
         name,
-        reexporter: reexportingModule.id,
-        sources: [reexportingModule.exportsAll[name], additionalExportAllModule.exportsAll[name]]
+        reexporter: reexportingModuleId,
+        sources
     };
 }
-function errAmbiguousExternalNamespaces(name, reexportingModule, usedExternalModule, externalModules) {
+function errAmbiguousExternalNamespaces(name, reexportingModule, usedModule, sources) {
     return {
         code: Errors.AMBIGUOUS_EXTERNAL_NAMESPACES,
-        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${name}" from one of the external modules ${printQuotedStringList(externalModules.map(module => relativeId(module)))}, guessing "${relativeId(usedExternalModule)}".`,
+        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${name}" from one of the external modules ${printQuotedStringList(sources.map(module => relativeId(module)))}, guessing "${relativeId(usedModule)}".`,
         name,
         reexporter: reexportingModule,
-        sources: externalModules
+        sources
     };
 }
 function errNoTransformMapOrAstWithoutCode(pluginName) {
@@ -420,7 +420,7 @@ function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOp
         code: Errors.SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
         id,
         message: `Module "${relativeId(id)}" that is marked with 'syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}' needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
-            ? `an export named "${syntheticNamedExportsOption}"`
+            ? `an explicit export named "${syntheticNamedExportsOption}"`
             : 'a default export'} that does not reexport an unresolved named export of the same module.`
     };
 }
@@ -2322,7 +2322,7 @@ function makeLegal(str) {
 }
 
 class ExternalModule {
-    constructor(options, id, hasModuleSideEffects, meta, renormalizeRenderPath) {
+    constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath) {
         this.options = options;
         this.id = id;
         this.renormalizeRenderPath = renormalizeRenderPath;
@@ -2341,7 +2341,7 @@ class ExternalModule {
         this.variableName = '';
         this.suggestedVariableName = makeLegal(id.split(/[\\/]/).pop());
         const { importers, dynamicImporters } = this;
-        this.info = {
+        const info = (this.info = {
             ast: null,
             code: null,
             dynamicallyImportedIdResolutions: EMPTY_ARRAY,
@@ -2349,7 +2349,11 @@ class ExternalModule {
             get dynamicImporters() {
                 return dynamicImporters.sort();
             },
-            hasModuleSideEffects,
+            hasDefaultExport: null,
+            get hasModuleSideEffects() {
+                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', false, options);
+                return info.moduleSideEffects;
+            },
             id,
             implicitlyLoadedAfterOneOf: EMPTY_ARRAY,
             implicitlyLoadedBefore: EMPTY_ARRAY,
@@ -2362,16 +2366,22 @@ class ExternalModule {
             isExternal: true,
             isIncluded: null,
             meta,
+            moduleSideEffects,
             syntheticNamedExports: false
-        };
+        });
+        // Hide the deprecated key so that it only warns when accessed explicitly
+        Object.defineProperty(this.info, 'hasModuleSideEffects', {
+            ...Object.getOwnPropertyDescriptor(this.info, 'hasModuleSideEffects'),
+            enumerable: false
+        });
     }
     getVariableForExportName(name) {
         let declaration = this.declarations[name];
         if (declaration)
-            return declaration;
+            return [declaration];
         this.declarations[name] = declaration = new ExternalVariable(this, name);
         this.exportedVariables.set(declaration, name);
-        return declaration;
+        return [declaration];
     }
     setRenderPath(options, inputBase) {
         this.renderPath =
@@ -4905,15 +4915,6 @@ exports.SOURCEMAPPING_URL += 'ppingURL';
 const whiteSpaceNoNewline = '[ \\f\\r\\t\\v\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]';
 const SOURCEMAPPING_URL_RE = new RegExp(`^#${whiteSpaceNoNewline}+${exports.SOURCEMAPPING_URL}=.+`);
 
-// patch up acorn-walk until class-fields are officially supported
-base$1.PropertyDefinition = function (node, st, c) {
-    if (node.computed) {
-        c(node.key, st, 'Expression');
-    }
-    if (node.value) {
-        c(node.value, st, 'Expression');
-    }
-};
 const ANNOTATION_KEY = '_rollupAnnotations';
 const INVALID_COMMENT_KEY = '_rollupRemoved';
 function handlePureAnnotationsOfNode(node, state, type = node.type) {
@@ -8642,6 +8643,8 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    groupBy: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    groupByToMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
     join: METHOD_RETURNS_STRING,
@@ -12252,7 +12255,7 @@ function markModuleAndImpureDependenciesAsExecuted(baseModule) {
         for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
             if (!(dependency instanceof ExternalModule) &&
                 !dependency.isExecuted &&
-                (dependency.info.hasModuleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
+                (dependency.info.moduleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
                 !visitedModules.has(dependency.id)) {
                 dependency.isExecuted = true;
                 visitedModules.add(dependency.id);
@@ -12266,11 +12269,11 @@ const MISSING_EXPORT_SHIM_DESCRIPTION = {
     identifier: null,
     localName: MISSING_EXPORT_SHIM_VARIABLE
 };
-function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map(), skipExternalNamespaceReexports) {
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map()) {
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
-            return isExportAllSearch ? null : error(errCircularReexport(name, target.id));
+            return isExportAllSearch ? [null] : error(errCircularReexport(name, target.id));
         }
         searchedModules.add(target);
     }
@@ -12280,8 +12283,7 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
     return target.getVariableForExportName(name, {
         importerForSideEffects,
         isExportAllSearch,
-        searchedNamesAndModules,
-        skipExternalNamespaceReexports
+        searchedNamesAndModules
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
@@ -12311,14 +12313,14 @@ function getAndExtendSideEffectModules(variable, module) {
     return sideEffectModules;
 }
 class Module {
-    constructor(graph, id, options, isEntry, hasModuleSideEffects, syntheticNamedExports, meta) {
+    constructor(graph, id, options, isEntry, moduleSideEffects, syntheticNamedExports, meta) {
         this.graph = graph;
         this.id = id;
         this.options = options;
         this.alternativeReexportModules = new Map();
         this.ast = null;
         this.chunkFileNames = new Set();
-        this.chunkName = null;
+        this.chunkNames = [];
         this.cycles = new Set();
         this.dependencies = new Set();
         this.dynamicDependencies = new Set();
@@ -12327,7 +12329,6 @@ class Module {
         this.execIndex = Infinity;
         this.exportAllSources = new Set();
         this.exports = Object.create(null);
-        this.exportsAll = Object.create(null);
         this.implicitlyLoadedAfter = new Set();
         this.implicitlyLoadedBefore = new Set();
         this.importDescriptions = Object.create(null);
@@ -12342,7 +12343,6 @@ class Module {
         this.reexportDescriptions = Object.create(null);
         this.sideEffectDependenciesByVariable = new Map();
         this.sources = new Set();
-        this.userChunkNames = new Set();
         this.usesTopLevelAwait = false;
         this.allExportNames = null;
         this.exportAllModules = [];
@@ -12359,17 +12359,18 @@ class Module {
         this.preserveSignature = this.options.preserveEntrySignatures;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const module = this;
+        const { dynamicImports, dynamicImporters, reexportDescriptions, implicitlyLoadedAfter, implicitlyLoadedBefore, sources, importers } = this;
         this.info = {
             ast: null,
             code: null,
             get dynamicallyImportedIdResolutions() {
-                return module.dynamicImports
+                return dynamicImports
                     .map(({ argument }) => typeof argument === 'string' && module.resolvedIds[argument])
                     .filter(Boolean);
             },
             get dynamicallyImportedIds() {
                 const dynamicallyImportedIds = [];
-                for (const { id } of module.dynamicImports) {
+                for (const { id } of dynamicImports) {
                     if (id) {
                         dynamicallyImportedIds.push(id);
                     }
@@ -12377,36 +12378,52 @@ class Module {
                 return dynamicallyImportedIds;
             },
             get dynamicImporters() {
-                return module.dynamicImporters.sort();
+                return dynamicImporters.sort();
+            },
+            get hasDefaultExport() {
+                // This information is only valid after parsing
+                if (!module.ast) {
+                    return null;
+                }
+                return 'default' in module.exports || 'default' in reexportDescriptions;
+            },
+            get hasModuleSideEffects() {
+                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', false, options);
+                return module.info.moduleSideEffects;
             },
-            hasModuleSideEffects,
             id,
             get implicitlyLoadedAfterOneOf() {
-                return Array.from(module.implicitlyLoadedAfter, getId).sort();
+                return Array.from(implicitlyLoadedAfter, getId).sort();
             },
             get implicitlyLoadedBefore() {
-                return Array.from(module.implicitlyLoadedBefore, getId).sort();
+                return Array.from(implicitlyLoadedBefore, getId).sort();
             },
             get importedIdResolutions() {
-                return Array.from(module.sources, source => module.resolvedIds[source]).filter(Boolean);
+                return Array.from(sources, source => module.resolvedIds[source]).filter(Boolean);
             },
             get importedIds() {
-                return Array.from(module.sources, source => { var _a; return (_a = module.resolvedIds[source]) === null || _a === void 0 ? void 0 : _a.id; }).filter(Boolean);
+                return Array.from(sources, source => { var _a; return (_a = module.resolvedIds[source]) === null || _a === void 0 ? void 0 : _a.id; }).filter(Boolean);
             },
             get importers() {
-                return module.importers.sort();
+                return importers.sort();
             },
             isEntry,
             isExternal: false,
             get isIncluded() {
-                if (module.graph.phase !== BuildPhase.GENERATE) {
+                if (graph.phase !== BuildPhase.GENERATE) {
                     return null;
                 }
                 return module.isIncluded();
             },
             meta: { ...meta },
+            moduleSideEffects,
             syntheticNamedExports
         };
+        // Hide the deprecated key so that it only warns when accessed explicitly
+        Object.defineProperty(this.info, 'hasModuleSideEffects', {
+            ...Object.getOwnPropertyDescriptor(this.info, 'hasModuleSideEffects'),
+            enumerable: false
+        });
     }
     basename() {
         const base = require$$0.basename(this.id);
@@ -12441,6 +12458,11 @@ class Module {
                     allExportNames.add(name);
             }
         }
+        // We do not count the synthetic namespace as a regular export to hide it
+        // from entry signatures and namespace objects
+        if (typeof this.info.syntheticNamedExports === 'string') {
+            allExportNames.delete(this.info.syntheticNamedExports);
+        }
         return allExportNames;
     }
     getDependenciesToBeIncluded() {
@@ -12455,7 +12477,7 @@ class Module {
             this.namespace.included ||
             this.implicitlyLoadedAfter.size > 0) {
             for (const exportName of [...this.getReexports(), ...this.getExports()]) {
-                const exportedVariable = this.getVariableForExportName(exportName);
+                const [exportedVariable] = this.getVariableForExportName(exportName);
                 if (exportedVariable) {
                     dependencyVariables.add(exportedVariable);
                 }
@@ -12476,7 +12498,7 @@ class Module {
             }
             necessaryDependencies.add(variable.module);
         }
-        if (!this.options.treeshake || this.info.hasModuleSideEffects === 'no-treeshake') {
+        if (!this.options.treeshake || this.info.moduleSideEffects === 'no-treeshake') {
             for (const dependency of this.dependencies) {
                 relevantDependencies.add(dependency);
             }
@@ -12495,9 +12517,7 @@ class Module {
         }
         const exportNamesByVariable = new Map();
         for (const exportName of this.getAllExportNames()) {
-            if (exportName === this.info.syntheticNamedExports)
-                continue;
-            let tracedVariable = this.getVariableForExportName(exportName);
+            let [tracedVariable] = this.getVariableForExportName(exportName);
             if (tracedVariable instanceof ExportDefaultVariable) {
                 tracedVariable = tracedVariable.getOriginalVariable();
             }
@@ -12546,7 +12566,7 @@ class Module {
         const renderedExports = [];
         const removedExports = [];
         for (const exportName in this.exports) {
-            const variable = this.getVariableForExportName(exportName);
+            const [variable] = this.getVariableForExportName(exportName);
             (variable && variable.included ? renderedExports : removedExports).push(exportName);
         }
         return { removedExports, renderedExports };
@@ -12554,20 +12574,20 @@ class Module {
     getSyntheticNamespace() {
         if (this.syntheticNamespace === null) {
             this.syntheticNamespace = undefined;
-            this.syntheticNamespace = this.getVariableForExportName(typeof this.info.syntheticNamedExports === 'string'
+            [this.syntheticNamespace] = this.getVariableForExportName(typeof this.info.syntheticNamedExports === 'string'
                 ? this.info.syntheticNamedExports
-                : 'default');
+                : 'default', { onlyExplicit: true });
         }
         if (!this.syntheticNamespace) {
             return error(errSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules, skipExternalNamespaceReexports } = EMPTY_OBJECT) {
+    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, onlyExplicit, searchedNamesAndModules } = EMPTY_OBJECT) {
         if (name[0] === '*') {
             if (name.length === 1) {
                 // export * from './other'
-                return this.namespace;
+                return [this.namespace];
             }
             else {
                 // export * from 'external'
@@ -12578,19 +12598,19 @@ class Module {
         // export { foo } from './other'
         const reexportDeclaration = this.reexportDescriptions[name];
         if (reexportDeclaration) {
-            const variable = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules, false);
+            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);
             }
             if (importerForSideEffects) {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
-            return variable;
+            return [variable];
         }
         const exportDeclaration = this.exports[name];
         if (exportDeclaration) {
             if (exportDeclaration === MISSING_EXPORT_SHIM_DESCRIPTION) {
-                return this.exportShimVariable;
+                return [this.exportShimVariable];
             }
             const name = exportDeclaration.localName;
             const variable = this.traceVariable(name, importerForSideEffects);
@@ -12598,41 +12618,37 @@ class Module {
                 getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, () => new Set()).add(this);
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
             }
-            return variable;
+            return [variable];
+        }
+        if (onlyExplicit) {
+            return [null];
         }
         if (name !== 'default') {
             const foundNamespaceReexport = name in this.namespaceReexportsByName
                 ? this.namespaceReexportsByName[name]
-                : this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules, skipExternalNamespaceReexports);
-            if (!skipExternalNamespaceReexports) {
-                this.namespaceReexportsByName[name] = foundNamespaceReexport;
-            }
-            if (foundNamespaceReexport) {
+                : this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules);
+            this.namespaceReexportsByName[name] = foundNamespaceReexport;
+            if (foundNamespaceReexport[0]) {
                 return foundNamespaceReexport;
             }
         }
         if (this.info.syntheticNamedExports) {
-            let syntheticExport = this.syntheticExports.get(name);
-            if (!syntheticExport) {
-                const syntheticNamespace = this.getSyntheticNamespace();
-                syntheticExport = new SyntheticNamedExportVariable(this.astContext, name, syntheticNamespace);
-                this.syntheticExports.set(name, syntheticExport);
-                return syntheticExport;
-            }
-            return syntheticExport;
+            return [
+                getOrCreate(this.syntheticExports, name, () => new SyntheticNamedExportVariable(this.astContext, name, this.getSyntheticNamespace()))
+            ];
         }
         // 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;
+                return [this.exportShimVariable];
             }
         }
-        return null;
+        return [null];
     }
     hasEffects() {
-        return (this.info.hasModuleSideEffects === 'no-treeshake' ||
+        return (this.info.moduleSideEffects === 'no-treeshake' ||
             (this.ast.included && this.ast.hasEffects(createHasEffectsContext())));
     }
     include() {
@@ -12647,7 +12663,7 @@ class Module {
         }
         for (const exportName of this.getExports()) {
             if (includeNamespaceMembers || exportName !== this.info.syntheticNamedExports) {
-                const variable = this.getVariableForExportName(exportName);
+                const variable = this.getVariableForExportName(exportName)[0];
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
                     this.includeVariable(variable);
@@ -12655,7 +12671,7 @@ class Module {
             }
         }
         for (const name of this.getReexports()) {
-            const variable = this.getVariableForExportName(name);
+            const [variable] = this.getVariableForExportName(name);
             if (variable) {
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
@@ -12680,11 +12696,6 @@ class Module {
     linkImports() {
         this.addModulesToImportDescriptions(this.importDescriptions);
         this.addModulesToImportDescriptions(this.reexportDescriptions);
-        for (const name in this.exports) {
-            if (name !== 'default' && name !== this.info.syntheticNamedExports) {
-                this.exportsAll[name] = this.id;
-            }
-        }
         const externalExportAllModules = [];
         for (const source of this.exportAllSources) {
             const module = this.graph.modulesById.get(this.resolvedIds[source].id);
@@ -12693,14 +12704,6 @@ class Module {
                 continue;
             }
             this.exportAllModules.push(module);
-            for (const name in module.exportsAll) {
-                if (name in this.exportsAll) {
-                    this.options.onwarn(errNamespaceConflict(name, this, module));
-                }
-                else {
-                    this.exportsAll[name] = module.exportsAll[name];
-                }
-            }
         }
         this.exportAllModules.push(...externalExportAllModules);
     }
@@ -12758,7 +12761,7 @@ class Module {
             moduleContext: this.context,
             options: this.options,
             requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
-            traceExport: this.getVariableForExportName.bind(this),
+            traceExport: (name) => this.getVariableForExportName(name)[0],
             traceVariable: this.traceVariable.bind(this),
             usesTopLevelAwait: false,
             warn: this.warn.bind(this)
@@ -12777,7 +12780,7 @@ class Module {
             dependencies: Array.from(this.dependencies, getId),
             id: this.id,
             meta: this.info.meta,
-            moduleSideEffects: this.info.hasModuleSideEffects,
+            moduleSideEffects: this.info.moduleSideEffects,
             originalCode: this.originalCode,
             originalSourcemap: this.originalSourcemap,
             resolvedIds: this.resolvedIds,
@@ -12798,7 +12801,7 @@ class Module {
             if (otherModule instanceof Module && importDeclaration.name === '*') {
                 return otherModule.namespace;
             }
-            const declaration = otherModule.getVariableForExportName(importDeclaration.name, {
+            const [declaration] = otherModule.getVariableForExportName(importDeclaration.name, {
                 importerForSideEffects: importerForSideEffects || this
             });
             if (!declaration) {
@@ -12829,7 +12832,7 @@ class Module {
     }
     updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
         if (moduleSideEffects != null) {
-            this.info.hasModuleSideEffects = moduleSideEffects;
+            this.info.moduleSideEffects = moduleSideEffects;
         }
         if (syntheticNamedExports != null) {
             this.info.syntheticNamedExports = syntheticNamedExports;
@@ -12983,7 +12986,7 @@ class Module {
                     relevantDependencies.add(dependency);
                     continue;
                 }
-                if (!(dependency.info.hasModuleSideEffects || alwaysCheckedDependencies.has(dependency))) {
+                if (!(dependency.info.moduleSideEffects || alwaysCheckedDependencies.has(dependency))) {
                     continue;
                 }
                 if (dependency instanceof ExternalModule || dependency.hasEffects()) {
@@ -12996,58 +12999,57 @@ class Module {
         addSideEffectDependencies(this.dependencies);
         addSideEffectDependencies(alwaysCheckedDependencies);
     }
-    getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules, skipExternalNamespaceReexports = false) {
+    getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules) {
         let foundSyntheticDeclaration = null;
-        const skipExternalNamespaceValues = [{ searchedNamesAndModules, skipExternalNamespaces: true }];
-        if (!skipExternalNamespaceReexports) {
-            const clonedSearchedNamesAndModules = new Map();
-            for (const [name, modules] of searchedNamesAndModules || []) {
-                clonedSearchedNamesAndModules.set(name, new Set(modules));
-            }
-            skipExternalNamespaceValues.push({
-                searchedNamesAndModules: clonedSearchedNamesAndModules,
-                skipExternalNamespaces: false
-            });
-        }
-        for (const { skipExternalNamespaces, searchedNamesAndModules } of skipExternalNamespaceValues) {
-            const foundDeclarations = new Set();
-            for (const module of this.exportAllModules) {
-                if (module instanceof Module || !skipExternalNamespaces) {
-                    const declaration = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, searchedNamesAndModules, skipExternalNamespaces);
-                    if (declaration) {
-                        if (!(declaration instanceof SyntheticNamedExportVariable)) {
-                            foundDeclarations.add(declaration);
-                        }
-                        else if (!foundSyntheticDeclaration) {
-                            foundSyntheticDeclaration = declaration;
-                        }
-                    }
-                }
+        const foundInternalDeclarations = new Map();
+        const foundExternalDeclarations = new Set();
+        for (const module of this.exportAllModules) {
+            // Synthetic namespaces should not hide "regular" exports of the same name
+            if (module.info.syntheticNamedExports === name) {
+                continue;
             }
-            if (foundDeclarations.size === 1) {
-                return [...foundDeclarations][0];
+            const [variable, indirectExternal] = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, searchedNamesAndModules);
+            if (module instanceof ExternalModule || indirectExternal) {
+                foundExternalDeclarations.add(variable);
             }
-            if (foundDeclarations.size > 1) {
-                if (skipExternalNamespaces) {
-                    return null;
+            else if (variable instanceof SyntheticNamedExportVariable) {
+                if (!foundSyntheticDeclaration) {
+                    foundSyntheticDeclaration = variable;
                 }
-                const foundDeclarationList = [...foundDeclarations];
-                const usedDeclaration = foundDeclarationList[0];
+            }
+            else if (variable) {
+                foundInternalDeclarations.set(variable, module);
+            }
+        }
+        if (foundInternalDeclarations.size > 0) {
+            const foundDeclarationList = [...foundInternalDeclarations];
+            const usedDeclaration = foundDeclarationList[0][0];
+            if (foundDeclarationList.length === 1) {
+                return [usedDeclaration];
+            }
+            this.options.onwarn(errNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
+            // TODO we are pretending it was not found while it should behave like "undefined"
+            return [null];
+        }
+        if (foundExternalDeclarations.size > 0) {
+            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)));
-                return usedDeclaration;
             }
+            return [usedDeclaration, true];
         }
         if (foundSyntheticDeclaration) {
-            return foundSyntheticDeclaration;
+            return [foundSyntheticDeclaration];
         }
-        return null;
+        return [null];
     }
     includeAndGetAdditionalMergedNamespaces() {
         const externalNamespaces = new Set();
         const syntheticNamespaces = new Set();
         for (const module of [this, ...this.exportAllModules]) {
             if (module instanceof ExternalModule) {
-                const externalVariable = module.getVariableForExportName('*');
+                const [externalVariable] = module.getVariableForExportName('*');
                 externalVariable.include();
                 this.imports.add(externalVariable);
                 externalNamespaces.add(externalVariable);
@@ -13128,12 +13130,10 @@ function removeJsExtension(name) {
 }
 
 function getCompleteAmdId(options, chunkId) {
-    if (!options.autoId) {
-        return options.id || '';
-    }
-    else {
+    if (options.autoId) {
         return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
     }
+    return options.id || '';
 }
 
 function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, mechanism = 'return ') {
@@ -14035,10 +14035,8 @@ function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeCon
     const moduleSources = modules
         .filter(module => !module.excludeFromSourcemap)
         .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
-    // DecodedSourceMap (from magic-string) uses a number[] instead of the more
-    // correct SourceMapSegment tuples. Cast it here to gain type safety.
-    let source = new Link(map, moduleSources);
-    source = bundleSourcemapChain.reduce(linkMap, source);
+    const link = new Link(map, moduleSources);
+    const source = bundleSourcemapChain.reduce(linkMap, link);
     let { sources, sourcesContent, names, mappings } = source.traceMappings();
     if (file) {
         const directory = require$$0.dirname(file);
@@ -14190,7 +14188,7 @@ function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariab
     let nameIndex = 0;
     for (const variable of exports) {
         let [exportName] = variable.name;
-        if (exportsByName[exportName]) {
+        if (exportsByName.has(exportName)) {
             do {
                 exportName = toBase64(++nameIndex);
                 // skip past leading number identifiers
@@ -14198,9 +14196,9 @@ function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariab
                     nameIndex += 9 * 64 ** (exportName.length - 1);
                     exportName = toBase64(nameIndex);
                 }
-            } while (RESERVED_NAMES$1.has(exportName) || exportsByName[exportName]);
+            } while (RESERVED_NAMES$1.has(exportName) || exportsByName.has(exportName));
         }
-        exportsByName[exportName] = variable;
+        exportsByName.set(exportName, variable);
         exportNamesByVariable.set(variable, [exportName]);
     }
 }
@@ -14208,10 +14206,10 @@ function assignExportsToNames(exports, exportsByName, exportNamesByVariable) {
     for (const variable of exports) {
         let nameIndex = 0;
         let exportName = variable.name;
-        while (exportsByName[exportName]) {
+        while (exportsByName.has(exportName)) {
             exportName = variable.name + '$' + ++nameIndex;
         }
-        exportsByName[exportName] = variable;
+        exportsByName.set(exportName, variable);
         exportNamesByVariable.set(variable, [exportName]);
     }
 }
@@ -14329,13 +14327,7 @@ function decodedSourcemap(map) {
             version: 3
         };
     }
-    let mappings;
-    if (typeof map.mappings === 'string') {
-        mappings = decode(map.mappings);
-    }
-    else {
-        mappings = map.mappings;
-    }
+    const mappings = typeof map.mappings === 'string' ? decode(map.mappings) : map.mappings;
     return { ...map, mappings };
 }
 
@@ -14425,7 +14417,7 @@ class Chunk {
         this.dynamicName = null;
         this.exportNamesByVariable = new Map();
         this.exports = new Set();
-        this.exportsByName = Object.create(null);
+        this.exportsByName = new Map();
         this.fileName = null;
         this.implicitEntryModules = [];
         this.implicitlyLoadedBefore = new Set();
@@ -14481,7 +14473,7 @@ class Chunk {
             chunk.dependencies.add(dependency instanceof Module ? chunkByModule.get(dependency) : dependency);
         }
         if (!chunk.dependencies.has(chunkByModule.get(facadedModule)) &&
-            facadedModule.info.hasModuleSideEffects &&
+            facadedModule.info.moduleSideEffects &&
             facadedModule.hasEffects()) {
             chunk.dependencies.add(chunkByModule.get(facadedModule));
         }
@@ -14524,7 +14516,7 @@ class Chunk {
             for (const [variable, exportNames] of exportNamesByVariable) {
                 this.exportNamesByVariable.set(variable, [...exportNames]);
                 for (const exportName of exportNames) {
-                    this.exportsByName[exportName] = variable;
+                    this.exportsByName.set(exportName, variable);
                 }
                 remainingExports.delete(variable);
             }
@@ -14551,7 +14543,7 @@ class Chunk {
             }
         }
         for (const module of entryModules) {
-            const requiredFacades = Array.from(module.userChunkNames, name => ({
+            const requiredFacades = Array.from(new Set(module.chunkNames.filter(({ isUserDefined }) => isUserDefined).map(({ name }) => name)), name => ({
                 name
             }));
             if (requiredFacades.length === 0 && module.isUserDefinedEntryPoint) {
@@ -14618,15 +14610,15 @@ class Chunk {
     }
     generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames, unsetOptions) {
         const [{ id }] = this.orderedModules;
-        const sanitizedId = this.outputOptions.sanitizeFileName(id);
+        const sanitizedId = this.outputOptions.sanitizeFileName(id.split(QUERY_HASH_REGEX, 1)[0]);
         let path;
         const patternOpt = unsetOptions.has('entryFileNames')
             ? '[name][assetExtname].js'
             : options.entryFileNames;
         const pattern = typeof patternOpt === 'function' ? patternOpt(this.getChunkInfo()) : patternOpt;
-        if (isAbsolute(id)) {
+        if (isAbsolute(sanitizedId)) {
             const currentDir = require$$0.dirname(sanitizedId);
-            const extension = require$$0.extname(id);
+            const extension = require$$0.extname(sanitizedId);
             const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
                 assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
                 ext: () => extension.substr(1),
@@ -14685,10 +14677,12 @@ class Chunk {
         });
     }
     getChunkName() {
-        return (this.name || (this.name = this.outputOptions.sanitizeFileName(this.getFallbackChunkName())));
+        var _a;
+        return ((_a = this.name) !== null && _a !== void 0 ? _a : (this.name = this.outputOptions.sanitizeFileName(this.getFallbackChunkName())));
     }
     getExportNames() {
-        return (this.sortedExportNames || (this.sortedExportNames = Object.keys(this.exportsByName).sort()));
+        var _a;
+        return ((_a = this.sortedExportNames) !== null && _a !== void 0 ? _a : (this.sortedExportNames = Array.from(this.exportsByName.keys()).sort()));
     }
     getRenderedHash() {
         if (this.renderedHash)
@@ -14704,7 +14698,7 @@ class Chunk {
         hash.update(this.renderedSource.toString());
         hash.update(this.getExportNames()
             .map(exportName => {
-            const variable = this.exportsByName[exportName];
+            const variable = this.exportsByName.get(exportName);
             return `${relativeId(variable.module.id).replace(/\\/g, '/')}:${variable.name}:${exportName}`;
         })
             .join(','));
@@ -14963,12 +14957,12 @@ class Chunk {
     }
     computeContentHashWithDependencies(addons, options, existingNames) {
         const hash = createHash();
-        hash.update([addons.intro, addons.outro, addons.banner, addons.footer].map(addon => addon || '').join(':'));
+        hash.update([addons.intro, addons.outro, addons.banner, addons.footer].join(':'));
         hash.update(options.format);
         const dependenciesForHashing = new Set([this]);
         for (const current of dependenciesForHashing) {
             if (current instanceof ExternalModule) {
-                hash.update(':' + current.renderPath);
+                hash.update(`:${current.renderPath}`);
             }
             else {
                 hash.update(current.getRenderedHash());
@@ -15042,7 +15036,7 @@ class Chunk {
             this.dynamicEntryModules[0] ||
             this.orderedModules[this.orderedModules.length - 1];
         if (moduleForNaming) {
-            return moduleForNaming.chunkName || getAliasName(moduleForNaming.id);
+            return getChunkNameFromModule(moduleForNaming);
         }
         return 'chunk';
     }
@@ -15075,7 +15069,7 @@ class Chunk {
         for (const exportName of this.getExportNames()) {
             if (exportName[0] === '*')
                 continue;
-            const variable = this.exportsByName[exportName];
+            const variable = this.exportsByName.get(exportName);
             if (!(variable instanceof SyntheticNamedExportVariable)) {
                 const module = variable.module;
                 if (module && this.chunkByModule.get(module) !== this)
@@ -15223,7 +15217,7 @@ class Chunk {
                 imported = exportName = '*';
             }
             else {
-                const variable = this.exportsByName[exportName];
+                const variable = this.exportsByName.get(exportName);
                 if (variable instanceof SyntheticNamedExportVariable)
                     continue;
                 const module = variable.module;
@@ -15324,7 +15318,7 @@ class Chunk {
     setIdentifierRenderResolutions({ format, interop, namespaceToStringTag }) {
         const syntheticExports = new Set();
         for (const exportName of this.getExportNames()) {
-            const exportVariable = this.exportsByName[exportName];
+            const exportVariable = this.exportsByName.get(exportName);
             if (format !== 'es' &&
                 format !== 'system' &&
                 exportVariable.isReassigned &&
@@ -15414,8 +15408,10 @@ class Chunk {
     }
 }
 function getChunkNameFromModule(module) {
-    return module.chunkName || getAliasName(module.id);
+    var _a, _b, _c, _d;
+    return ((_d = (_b = (_a = module.chunkNames.find(({ isUserDefined }) => isUserDefined)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = module.chunkNames[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : getAliasName(module.id));
 }
+const QUERY_HASH_REGEX = /[?#]/;
 
 function generateAssetFileName(name, source, outputOptions, bundle) {
     const emittedName = outputOptions.sanitizeFileName(name || 'asset');
@@ -21724,25 +21720,6 @@ Parser.acorn = {
   nonASCIIwhitespace: nonASCIIwhitespace
 };
 
-const readFile = (file) => new Promise((fulfil, reject) => fs.readFile(file, 'utf-8', (err, contents) => (err ? reject(err) : fulfil(contents))));
-function mkdirpath(path) {
-    const dir = require$$0.dirname(path);
-    fs.mkdirSync(dir, { recursive: true });
-}
-function writeFile(dest, data) {
-    return new Promise((fulfil, reject) => {
-        mkdirpath(dest);
-        fs.writeFile(dest, data, err => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                fulfil();
-            }
-        });
-    });
-}
-
 class Queue {
     constructor(maxParallel) {
         this.maxParallel = maxParallel;
@@ -21808,26 +21785,20 @@ async function resolveId(source, importer, preserveSymlinks, pluginDriver, modul
     // See https://nodejs.org/api/path.html#path_path_resolve_paths
     return addJsExtensionIfNecessary(importer ? require$$0.resolve(require$$0.dirname(importer), source) : require$$0.resolve(source), preserveSymlinks);
 }
-function addJsExtensionIfNecessary(file, preserveSymlinks) {
-    let found = findFile(file, preserveSymlinks);
-    if (found)
-        return found;
-    found = findFile(file + '.mjs', preserveSymlinks);
-    if (found)
-        return found;
-    found = findFile(file + '.js', preserveSymlinks);
-    return found;
-}
-function findFile(file, preserveSymlinks) {
+async function addJsExtensionIfNecessary(file, preserveSymlinks) {
+    var _a, _b;
+    return ((_b = (_a = (await findFile(file, preserveSymlinks))) !== null && _a !== void 0 ? _a : (await findFile(file + '.mjs', preserveSymlinks))) !== null && _b !== void 0 ? _b : (await findFile(file + '.js', preserveSymlinks)));
+}
+async function findFile(file, preserveSymlinks) {
     try {
-        const stats = fs.lstatSync(file);
+        const stats = await require$$0$1.promises.lstat(file);
         if (!preserveSymlinks && stats.isSymbolicLink())
-            return findFile(fs.realpathSync(file), preserveSymlinks);
+            return await findFile(await require$$0$1.promises.realpath(file), preserveSymlinks);
         if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
             // check case
             const name = require$$0.basename(file);
-            const files = fs.readdirSync(require$$0.dirname(file));
-            if (files.indexOf(name) !== -1)
+            const files = await require$$0$1.promises.readdir(require$$0.dirname(file));
+            if (files.includes(name))
                 return file;
         }
     }
@@ -22084,6 +22055,7 @@ async function transform(source, module, pluginDriver, warn) {
     };
 }
 
+const RESOLVE_DEPENDENCIES = 'resolveDependencies';
 class ModuleLoader {
     constructor(graph, modulesById, options, pluginDriver) {
         this.graph = graph;
@@ -22095,9 +22067,10 @@ class ModuleLoader {
         this.latestLoadModulesPromise = Promise.resolve();
         this.moduleLoadPromises = new Map();
         this.modulesWithLoadedDependencies = new Set();
+        this.nextChunkNamePriority = 0;
         this.nextEntryModuleIndex = 0;
         this.resolveId = async (source, importer, customOptions, isEntry, skip = null) => {
-            return this.addDefaultsToResolvedId(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
+            return this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
                 ? false
                 : await resolveId(source, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, skip, customOptions, typeof isEntry === 'boolean' ? isEntry : !importer), importer, source));
         };
@@ -22114,21 +22087,24 @@ class ModuleLoader {
     async addEntryModules(unresolvedEntryModules, isUserDefined) {
         const firstEntryModuleIndex = this.nextEntryModuleIndex;
         this.nextEntryModuleIndex += unresolvedEntryModules.length;
+        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 => {
-            let moduleIndex = firstEntryModuleIndex;
             for (let index = 0; index < entryModules.length; index++) {
                 const entryModule = entryModules[index];
                 entryModule.isUserDefinedEntryPoint =
                     entryModule.isUserDefinedEntryPoint || isUserDefined;
-                addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined);
+                addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined, firstChunkNamePriority + index);
                 const existingIndexedModule = this.indexedEntryModules.find(indexedModule => indexedModule.module === entryModule);
                 if (!existingIndexedModule) {
-                    this.indexedEntryModules.push({ index: moduleIndex, module: entryModule });
+                    this.indexedEntryModules.push({
+                        index: firstEntryModuleIndex + index,
+                        module: entryModule
+                    });
                 }
                 else {
-                    existingIndexedModule.index = Math.min(existingIndexedModule.index, moduleIndex);
+                    existingIndexedModule.index = Math.min(existingIndexedModule.index, firstEntryModuleIndex + index);
                 }
-                moduleIndex++;
             }
             this.indexedEntryModules.sort(({ index: indexA }, { index: indexB }) => indexA > indexB ? 1 : -1);
             return entryModules;
@@ -22156,26 +22132,13 @@ class ModuleLoader {
         return module;
     }
     async preloadModule(resolvedId) {
-        const module = await this.fetchModule(this.addDefaultsToResolvedId(resolvedId), undefined, false, true);
+        const module = await this.fetchModule(this.getResolvedIdWithDefaults(resolvedId), undefined, false, resolvedId.resolveDependencies ? RESOLVE_DEPENDENCIES : true);
         return module.info;
     }
-    addDefaultsToResolvedId(resolvedId) {
-        var _a, _b;
-        if (!resolvedId) {
-            return null;
-        }
-        const external = resolvedId.external || false;
-        return {
-            external,
-            id: resolvedId.id,
-            meta: resolvedId.meta || {},
-            moduleSideEffects: (_a = resolvedId.moduleSideEffects) !== null && _a !== void 0 ? _a : this.hasModuleSideEffects(resolvedId.id, !!external),
-            syntheticNamedExports: (_b = resolvedId.syntheticNamedExports) !== null && _b !== void 0 ? _b : false
-        };
-    }
     addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfter) {
+        const chunkNamePriority = this.nextChunkNamePriority++;
         return this.extendLoadModulesPromise(this.loadEntryModule(unresolvedModule.id, false, unresolvedModule.importer, null).then(async (entryModule) => {
-            addChunkNamesToModule(entryModule, unresolvedModule, false);
+            addChunkNamesToModule(entryModule, unresolvedModule, false, chunkNamePriority);
             if (!entryModule.info.isEntry) {
                 this.implicitEntryModules.add(entryModule);
                 const implicitlyLoadedAfterModules = await Promise.all(implicitlyLoadedAfter.map(id => this.loadEntryModule(id, false, unresolvedModule.importer, entryModule.id)));
@@ -22193,7 +22156,7 @@ class ModuleLoader {
         timeStart('load modules', 3);
         let source;
         try {
-            source = await this.readQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await readFile(id)); });
+            source = await this.readQueue.run(async () => { var _a; return (_a = (await this.pluginDriver.hookFirst('load', [id]))) !== null && _a !== void 0 ? _a : (await require$$0$1.promises.readFile(id, 'utf8')); });
         }
         catch (err) {
             timeEnd('load modules', 3);
@@ -22286,9 +22249,7 @@ class ModuleLoader {
             this.getResolveDynamicImportPromises(module),
             loadAndResolveDependenciesPromise
         ]);
-        const loadAndResolveDependenciesPromise = loadPromise
-            .then(([resolveStaticDependencyPromises, resolveDynamicImportPromises]) => Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]))
-            .then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
+        const loadAndResolveDependenciesPromise = waitForDependencyResolution(loadPromise).then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
         loadAndResolveDependenciesPromise.catch(() => {
             /* avoid unhandled promise rejections */
         });
@@ -22297,6 +22258,9 @@ class ModuleLoader {
         if (!isPreload) {
             await this.fetchModuleDependencies(module, ...resolveDependencyPromises);
         }
+        else if (isPreload === RESOLVE_DEPENDENCIES) {
+            await loadAndResolveDependenciesPromise;
+        }
         return module;
     }
     async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises, loadAndResolveDependenciesPromise) {
@@ -22333,7 +22297,7 @@ class ModuleLoader {
             module.dependencies.add(dependency);
             dependency.importers.push(module.id);
         }
-        if (!this.options.treeshake || module.info.hasModuleSideEffects === 'no-treeshake') {
+        if (!this.options.treeshake || module.info.moduleSideEffects === 'no-treeshake') {
             for (const dependency of module.dependencies) {
                 if (dependency instanceof Module) {
                     dependency.importedFromNotTreeshaken = true;
@@ -22396,10 +22360,26 @@ class ModuleLoader {
                     this.handleResolveId(await this.resolveId(source, module.id, EMPTY_OBJECT, false), source, module.id))
         ]);
     }
+    getResolvedIdWithDefaults(resolvedId) {
+        var _a, _b;
+        if (!resolvedId) {
+            return null;
+        }
+        const external = resolvedId.external || false;
+        return {
+            external,
+            id: resolvedId.id,
+            meta: resolvedId.meta || {},
+            moduleSideEffects: (_a = resolvedId.moduleSideEffects) !== null && _a !== void 0 ? _a : this.hasModuleSideEffects(resolvedId.id, !!external),
+            syntheticNamedExports: (_b = resolvedId.syntheticNamedExports) !== null && _b !== void 0 ? _b : false
+        };
+    }
     async handleExistingModule(module, isEntry, isPreload) {
         const loadPromise = this.moduleLoadPromises.get(module);
         if (isPreload) {
-            return loadPromise;
+            return isPreload === RESOLVE_DEPENDENCIES
+                ? waitForDependencyResolution(loadPromise)
+                : loadPromise;
         }
         if (isEntry) {
             module.info.isEntry = true;
@@ -22425,10 +22405,8 @@ class ModuleLoader {
                 syntheticNamedExports: false
             };
         }
-        else {
-            if (resolvedId.external && resolvedId.syntheticNamedExports) {
-                this.options.onwarn(errExternalSyntheticExports(source, importer));
-            }
+        else if (resolvedId.external && resolvedId.syntheticNamedExports) {
+            this.options.onwarn(errExternalSyntheticExports(source, importer));
         }
         return resolvedId;
     }
@@ -22445,7 +22423,7 @@ class ModuleLoader {
                 ? errEntryCannotBeExternal(unresolvedId)
                 : errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
         }
-        return this.fetchModule(this.addDefaultsToResolvedId(typeof resolveIdResult === 'object'
+        return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
             ? resolveIdResult
             : { id: resolveIdResult }), undefined, isEntry, false);
     }
@@ -22472,7 +22450,7 @@ class ModuleLoader {
                 module.resolvedIds[specifier] ||
                     this.handleResolveId(await this.resolveId(specifier, module.id, EMPTY_OBJECT, false), specifier, module.id));
         }
-        return this.handleResolveId(this.addDefaultsToResolvedId(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier)), specifier, importer);
+        return this.handleResolveId(this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier)), specifier, importer);
     }
 }
 function normalizeRelativeExternalId(source, importer) {
@@ -22482,17 +22460,17 @@ function normalizeRelativeExternalId(source, importer) {
             : require$$0.resolve(source)
         : source;
 }
-function addChunkNamesToModule(module, { fileName, name }, isUserDefined) {
+function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
+    var _a;
     if (fileName !== null) {
         module.chunkFileNames.add(fileName);
     }
     else if (name !== null) {
-        if (module.chunkName === null) {
-            module.chunkName = name;
-        }
-        if (isUserDefined) {
-            module.userChunkNames.add(name);
-        }
+        // Always keep chunkNames sorted by priority
+        let namePosition = 0;
+        while (((_a = module.chunkNames[namePosition]) === null || _a === void 0 ? void 0 : _a.priority) < priority)
+            namePosition++;
+        module.chunkNames.splice(namePosition, 0, { isUserDefined, name, priority });
     }
 }
 function isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) {
@@ -22500,6 +22478,10 @@ function isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) {
         (makeAbsoluteExternalsRelative === 'ifRelativeSource' && isRelative(source)) ||
         !isAbsolute(id));
 }
+async function waitForDependencyResolution(loadPromise) {
+    const [resolveStaticDependencyPromises, resolveDynamicImportPromises] = await loadPromise;
+    return Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]);
+}
 
 class GlobalScope extends Scope$1 {
     constructor() {
@@ -22638,14 +22620,14 @@ function formatAction([pluginName, hookName, args]) {
     }
     return action;
 }
-process.on('exit', () => {
+process$1.on('exit', () => {
     if (unfulfilledActions.size) {
         let err = '[!] Error: unfinished hook action(s) on exit:\n';
         for (const action of unfulfilledActions) {
             err += formatAction(action) + '\n';
         }
         console.error('%s', err);
-        process.exit(1);
+        process$1.exit(1);
     }
 });
 
@@ -22674,7 +22656,6 @@ class PluginDriver {
     constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
         this.graph = graph;
         this.options = options;
-        this.pluginContexts = new Map();
         warnDeprecatedHooks(userPlugins, options);
         this.pluginCache = pluginCache;
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
@@ -22684,9 +22665,10 @@ class PluginDriver {
         this.setOutputBundle = this.fileEmitter.setOutputBundle.bind(this.fileEmitter);
         this.plugins = userPlugins.concat(basePluginDriver ? basePluginDriver.plugins : []);
         const existingPluginNames = new Set();
-        for (const plugin of this.plugins) {
-            this.pluginContexts.set(plugin, getPluginContext(plugin, pluginCache, graph, options, this.fileEmitter, existingPluginNames));
-        }
+        this.pluginContexts = new Map(this.plugins.map(plugin => [
+            plugin,
+            getPluginContext(plugin, pluginCache, graph, options, this.fileEmitter, existingPluginNames)
+        ]));
         if (basePluginDriver) {
             for (const plugin of userPlugins) {
                 for (const hook of inputHooks) {
@@ -23019,7 +23001,7 @@ class Graph {
                 this.needsTreeshakingPass = false;
                 for (const module of this.modules) {
                     if (module.isExecuted) {
-                        if (module.info.hasModuleSideEffects === 'no-treeshake') {
+                        if (module.info.moduleSideEffects === 'no-treeshake') {
                             module.includeAllInBundle();
                         }
                         else {
@@ -23074,7 +23056,7 @@ class Graph {
         for (const module of this.modules) {
             for (const importDescription of Object.values(module.importDescriptions)) {
                 if (importDescription.name !== '*' &&
-                    !importDescription.module.getVariableForExportName(importDescription.name)) {
+                    !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
                     module.warn({
                         code: 'NON_EXISTENT_EXPORT',
                         message: `Non-existent export '${importDescription.name}' is imported from ${relativeId(importDescription.module.id)}`,
@@ -23269,13 +23251,14 @@ const getHasModuleSideEffects = (moduleSideEffectsOption, pureExternalModules) =
 
 // https://datatracker.ietf.org/doc/html/rfc2396
 // eslint-disable-next-line no-control-regex
-const INVALID_CHAR_RE = /[\x00-\x1F\x7F<>*#"{}|^[\]`;?:&=+$,]/g;
+const INVALID_CHAR_REGEX = /[\x00-\x1F\x7F<>*#"{}|^[\]`;?:&=+$,]/g;
+const DRIVE_LETTER_REGEX = /^[a-z]:/i;
 function sanitizeFileName(name) {
-    const match = /^[a-z]:/i.exec(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_RE, '_');
+    return driveLetter + name.substr(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
 }
 
 function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
@@ -23496,7 +23479,14 @@ const getIndent = (config, compact) => {
     const configIndent = config.indent;
     return configIndent === false ? '' : configIndent !== null && configIndent !== void 0 ? configIndent : true;
 };
-const ALLOWED_INTEROP_TYPES = new Set(['auto', 'esModule', 'default', 'defaultOnly', true, false]);
+const ALLOWED_INTEROP_TYPES = new Set([
+    'auto',
+    'esModule',
+    'default',
+    'defaultOnly',
+    true,
+    false
+]);
 const getInterop = (config, inputOptions) => {
     const configInterop = config.interop;
     const validatedInteropTypes = new Set();
@@ -23681,8 +23671,10 @@ function getSortingFileType(file) {
     }
     return SortingFileType.SECONDARY_CHUNK;
 }
-function writeOutputFile(outputFile, outputOptions) {
+async function writeOutputFile(outputFile, outputOptions) {
     const fileName = require$$0.resolve(outputOptions.dir || require$$0.dirname(outputOptions.file), outputFile.fileName);
+    // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
+    await require$$0$1.promises.mkdir(require$$0.dirname(fileName), { recursive: true });
     let writeSourceMapPromise;
     let source;
     if (outputFile.type === 'asset') {
@@ -23697,14 +23689,14 @@ function writeOutputFile(outputFile, outputOptions) {
             }
             else {
                 url = `${require$$0.basename(outputFile.fileName)}.map`;
-                writeSourceMapPromise = writeFile(`${fileName}.map`, outputFile.map.toString());
+                writeSourceMapPromise = require$$0$1.promises.writeFile(`${fileName}.map`, outputFile.map.toString());
             }
             if (outputOptions.sourcemap !== 'hidden') {
                 source += `//# ${exports.SOURCEMAPPING_URL}=${url}\n`;
             }
         }
     }
-    return Promise.all([writeFile(fileName, source), writeSourceMapPromise]);
+    return Promise.all([require$$0$1.promises.writeFile(fileName, source), writeSourceMapPromise]);
 }
 /**
  * Auxiliary function for defining rollup configuration
@@ -23715,7 +23707,7 @@ function defineConfig(options) {
     return options;
 }
 
-class WatchEmitter extends require$$0$1.EventEmitter {
+class WatchEmitter extends require$$0$2.EventEmitter {
     constructor() {
         super();
         // Allows more than 10 bundles to be watched without