rollup 2.75.7 → 3.0.0-0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.75.7
-	Mon, 20 Jun 2022 07:24:02 GMT - commit 057171c2d3bc2092b7f543fc05ead01f12595f12
+	Rollup.js v3.0.0-0
+	Tue, 05 Jul 2022 04:32:12 GMT - commit 7a8316af2262c390e7ed72586cb83add1286dec2
 
 	https://github.com/rollup/rollup
 
@@ -14,7 +14,7 @@ import { createHash as createHash$1 } from 'crypto';
 import { promises } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.75.7";
+var version$1 = "3.0.0-0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1510,6 +1510,88 @@ function relative(from, to) {
     return toParts.join('/');
 }
 
+const needsEscapeRegEx = /[\\'\r\n\u2028\u2029]/;
+const quoteNewlineRegEx = /(['\r\n\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+    if (!id.match(needsEscapeRegEx))
+        return id;
+    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
+}
+
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[\\|/])/;
+const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
+function isAbsolute(path) {
+    return ABSOLUTE_PATH_REGEX.test(path);
+}
+function isRelative(path) {
+    return RELATIVE_PATH_REGEX.test(path);
+}
+const BACKSLASH_REGEX = /\\/g;
+function normalize(path) {
+    return path.replace(BACKSLASH_REGEX, '/');
+}
+
+function getAliasName(id) {
+    const base = basename(id);
+    return base.substring(0, base.length - extname(id).length);
+}
+function relativeId(id) {
+    if (!isAbsolute(id))
+        return id;
+    return relative(resolve(), id);
+}
+function isPathFragment(name) {
+    // starting with "/", "./", "../", "C:/"
+    return (name[0] === '/' || (name[0] === '.' && (name[1] === '/' || name[1] === '.')) || isAbsolute(name));
+}
+const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
+function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
+    let relativePath = normalize(relative(dirname(importerId), targetPath));
+    if (stripJsExtension && relativePath.endsWith('.js')) {
+        relativePath = relativePath.slice(0, -3);
+    }
+    if (ensureFileName) {
+        if (relativePath === '')
+            return '../' + basename(targetPath);
+        if (UPPER_DIR_REGEX.test(relativePath)) {
+            return relativePath
+                .split('/')
+                .concat(['..', basename(targetPath)])
+                .join('/');
+        }
+    }
+    return !relativePath ? '.' : relativePath.startsWith('..') ? relativePath : './' + relativePath;
+}
+
+class ExternalChunk {
+    constructor(module, options, inputBase) {
+        this.options = options;
+        this.inputBase = inputBase;
+        this.defaultVariableName = '';
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.fileName = null;
+        this.id = module.id;
+        this.renormalizeRenderPath = module.renormalizeRenderPath;
+        this.suggestedVariableName = module.suggestedVariableName;
+    }
+    getFileName() {
+        if (this.fileName) {
+            return this.fileName;
+        }
+        const { paths } = this.options;
+        return (this.fileName =
+            (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
+                (this.renormalizeRenderPath ? normalize(relative$1(this.inputBase, this.id)) : this.id));
+    }
+    getImportPath(importer) {
+        return escapeId(this.renormalizeRenderPath
+            ? getImportPath(importer, this.getFileName(), this.options.format === 'amd', false)
+            : this.getFileName());
+    }
+}
+
 function getOrCreate(map, key, init) {
     const existing = map.get(key);
     if (existing) {
@@ -1808,51 +1890,6 @@ function printQuotedStringList(list, verbs) {
     return output;
 }
 
-const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[\\|/])/;
-const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
-function isAbsolute(path) {
-    return ABSOLUTE_PATH_REGEX.test(path);
-}
-function isRelative(path) {
-    return RELATIVE_PATH_REGEX.test(path);
-}
-const BACKSLASH_REGEX = /\\/g;
-function normalize(path) {
-    return path.replace(BACKSLASH_REGEX, '/');
-}
-
-function getAliasName(id) {
-    const base = basename(id);
-    return base.substring(0, base.length - extname(id).length);
-}
-function relativeId(id) {
-    if (!isAbsolute(id))
-        return id;
-    return relative(resolve(), id);
-}
-function isPathFragment(name) {
-    // starting with "/", "./", "../", "C:/"
-    return (name[0] === '/' || (name[0] === '.' && (name[1] === '/' || name[1] === '.')) || isAbsolute(name));
-}
-const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
-function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
-    let relativePath = normalize(relative(dirname(importerId), targetPath));
-    if (stripJsExtension && relativePath.endsWith('.js')) {
-        relativePath = relativePath.slice(0, -3);
-    }
-    if (ensureFileName) {
-        if (relativePath === '')
-            return '../' + basename(targetPath);
-        if (UPPER_DIR_REGEX.test(relativePath)) {
-            return relativePath
-                .split('/')
-                .concat(['..', basename(targetPath)])
-                .join('/');
-        }
-    }
-    return !relativePath ? '.' : relativePath.startsWith('..') ? relativePath : './' + relativePath;
-}
-
 function error(base) {
     if (!(base instanceof Error))
         base = Object.assign(new Error(base.message), base);
@@ -1875,6 +1912,7 @@ function augmentCodeLocation(props, pos, source, id) {
 }
 var Errors;
 (function (Errors) {
+    Errors["ADDON_ERROR"] = "ADDON_ERROR";
     Errors["ALREADY_CLOSED"] = "ALREADY_CLOSED";
     Errors["ASSET_NOT_FINALISED"] = "ASSET_NOT_FINALISED";
     Errors["ASSET_NOT_FOUND"] = "ASSET_NOT_FOUND";
@@ -1897,6 +1935,7 @@ var Errors;
     Errors["INVALID_OPTION"] = "INVALID_OPTION";
     Errors["INVALID_PLUGIN_HOOK"] = "INVALID_PLUGIN_HOOK";
     Errors["INVALID_ROLLUP_PHASE"] = "INVALID_ROLLUP_PHASE";
+    Errors["INVALID_TLA_FORMAT"] = "INVALID_TLA_FORMAT";
     Errors["MISSING_EXPORT"] = "MISSING_EXPORT";
     Errors["MISSING_IMPLICIT_DEPENDANT"] = "MISSING_IMPLICIT_DEPENDANT";
     Errors["MIXED_EXPORTS"] = "MIXED_EXPORTS";
@@ -1911,10 +1950,17 @@ var Errors;
     Errors["UNRESOLVED_IMPORT"] = "UNRESOLVED_IMPORT";
     Errors["VALIDATION_ERROR"] = "VALIDATION_ERROR";
 })(Errors || (Errors = {}));
+function errAddonNotGenerated(message, hook, plugin) {
+    return {
+        code: Errors.ADDON_ERROR,
+        message: `Could not retrieve ${hook}. Check configuration of plugin ${plugin}.
+\tError Message: ${message}`
+    };
+}
 function errAssetNotFinalisedForFileName(name) {
     return {
         code: Errors.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.`
+        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 errCannotEmitFromOptionsHook() {
@@ -1926,7 +1972,7 @@ function errCannotEmitFromOptionsHook() {
 function errChunkNotGeneratedForFileName(name) {
     return {
         code: Errors.CHUNK_NOT_GENERATED,
-        message: `Plugin error - Unable to get file name for chunk "${name}". Ensure that generate is called first.`
+        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) {
@@ -2045,6 +2091,13 @@ function errInvalidRollupPhaseForChunkEmission() {
         message: `Cannot emit chunks after module loading has finished.`
     };
 }
+function errInvalidFormatForTopLevelAwait(id, format) {
+    return {
+        code: Errors.INVALID_TLA_FORMAT,
+        id,
+        message: `Module format ${format} does not support top-level await. Use the "es" or "system" output formats rather.`
+    };
+}
 function errMissingExport(exportName, importingModule, importedModule) {
     return {
         code: Errors.MISSING_EXPORT,
@@ -2272,19 +2325,15 @@ class ExternalModule {
         this.options = options;
         this.id = id;
         this.renormalizeRenderPath = renormalizeRenderPath;
-        this.declarations = new Map();
-        this.defaultVariableName = '';
         this.dynamicImporters = [];
         this.execIndex = Infinity;
         this.exportedVariables = new Map();
         this.importers = [];
-        this.mostCommonSuggestion = 0;
-        this.nameSuggestions = new Map();
-        this.namespaceVariableName = '';
         this.reexported = false;
-        this.renderPath = undefined;
         this.used = false;
-        this.variableName = '';
+        this.declarations = new Map();
+        this.mostCommonSuggestion = 0;
+        this.nameSuggestions = new Map();
         this.suggestedVariableName = makeLegal(id.split(/[\\/]/).pop());
         const { importers, dynamicImporters } = this;
         const info = (this.info = {
@@ -2297,7 +2346,7 @@ class ExternalModule {
             },
             hasDefaultExport: null,
             get hasModuleSideEffects() {
-                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', false, options);
+                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', true, options);
                 return info.moduleSideEffects;
             },
             id,
@@ -2329,15 +2378,6 @@ class ExternalModule {
         this.exportedVariables.set(externalVariable, name);
         return [externalVariable];
     }
-    setRenderPath(options, inputBase) {
-        this.renderPath =
-            typeof options.paths === 'function' ? options.paths(this.id) : options.paths[this.id];
-        if (!this.renderPath) {
-            this.renderPath = this.renormalizeRenderPath
-                ? normalize(relative$1(inputBase, this.id))
-                : this.id;
-        }
-    }
     suggestName(name) {
         var _a;
         const value = ((_a = this.nameSuggestions.get(name)) !== null && _a !== void 0 ? _a : 0) + 1;
@@ -10226,7 +10266,9 @@ class ImportExpression extends NodeBase {
         super(...arguments);
         this.inlineNamespace = null;
         this.mechanism = null;
+        this.namespaceExportName = undefined;
         this.resolution = null;
+        this.resolutionString = null;
     }
     hasEffects() {
         return true;
@@ -10243,8 +10285,8 @@ class ImportExpression extends NodeBase {
         this.context.addDynamicImport(this);
     }
     render(code, options) {
+        const { snippets: { getDirectReturnFunction, getPropertyAccess } } = options;
         if (this.inlineNamespace) {
-            const { snippets: { getDirectReturnFunction, getPropertyAccess } } = options;
             const [left, right] = getDirectReturnFunction([], {
                 functionReturn: true,
                 lineBreakIndent: null,
@@ -10257,22 +10299,26 @@ class ImportExpression extends NodeBase {
             code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, this.mechanism.left, { contentOnly: true });
             code.overwrite(this.end - 1, this.end, this.mechanism.right, { contentOnly: true });
         }
-        this.source.render(code, options);
-    }
-    renderFinalResolution(code, resolution, namespaceExportName, { getDirectReturnFunction }) {
-        code.overwrite(this.source.start, this.source.end, resolution);
-        if (namespaceExportName) {
-            const [left, right] = getDirectReturnFunction(['n'], {
-                functionReturn: true,
-                lineBreakIndent: null,
-                name: null
-            });
-            code.prependLeft(this.end, `.then(${left}n.${namespaceExportName}${right})`);
+        if (this.resolutionString) {
+            code.overwrite(this.source.start, this.source.end, this.resolutionString);
+            if (this.namespaceExportName) {
+                const [left, right] = getDirectReturnFunction(['n'], {
+                    functionReturn: true,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                code.prependLeft(this.end, `.then(${left}n.${this.namespaceExportName}${right})`);
+            }
+        }
+        else {
+            this.source.render(code, options);
         }
     }
-    setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope) {
+    setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName) {
         const { format } = options;
         this.resolution = resolution;
+        this.resolutionString = resolutionString;
+        this.namespaceExportName = namespaceExportName;
         const accessedGlobals = [...(accessedImportGlobals[format] || [])];
         let helper;
         ({ helper, mechanism: this.mechanism } = this.getDynamicImportMechanismAndHelper(resolution, exportMode, options, snippets, pluginDriver));
@@ -10567,25 +10613,17 @@ class LogicalExpression extends NodeBase {
     }
 }
 
-const ASSET_PREFIX = 'ROLLUP_ASSET_URL_';
-const CHUNK_PREFIX = 'ROLLUP_CHUNK_URL_';
 const FILE_PREFIX = 'ROLLUP_FILE_URL_';
 class MetaProperty extends NodeBase {
-    addAccessedGlobals(format, accessedGlobalsByScope) {
-        const metaProperty = this.metaProperty;
-        const accessedGlobals = (metaProperty &&
-            (metaProperty.startsWith(FILE_PREFIX) ||
-                metaProperty.startsWith(ASSET_PREFIX) ||
-                metaProperty.startsWith(CHUNK_PREFIX))
-            ? accessedFileUrlGlobals
-            : accessedMetaUrlGlobals)[format];
-        if (accessedGlobals.length > 0) {
-            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
-        }
+    constructor() {
+        super(...arguments);
+        this.metaProperty = null;
+        this.preliminaryChunkId = null;
+        this.referenceId = null;
     }
     getReferencedFileName(outputPluginDriver) {
-        const metaProperty = this.metaProperty;
-        if (metaProperty && metaProperty.startsWith(FILE_PREFIX)) {
+        const { metaProperty } = this;
+        if (metaProperty === null || metaProperty === void 0 ? void 0 : metaProperty.startsWith(FILE_PREFIX)) {
             return outputPluginDriver.getFileName(metaProperty.substring(FILE_PREFIX.length));
         }
         return null;
@@ -10602,71 +10640,37 @@ class MetaProperty extends NodeBase {
             if (this.meta.name === 'import') {
                 this.context.addImportMeta(this);
                 const parent = this.parent;
-                this.metaProperty =
+                const metaProperty = (this.metaProperty =
                     parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
                         ? parent.propertyKey
-                        : null;
+                        : null);
+                if (metaProperty === null || metaProperty === void 0 ? void 0 : metaProperty.startsWith(FILE_PREFIX)) {
+                    this.referenceId = metaProperty.substring(FILE_PREFIX.length);
+                }
             }
         }
     }
-    renderFinalMechanism(code, chunkId, format, snippets, outputPluginDriver) {
+    render(code, { format, pluginDriver, snippets }) {
         var _a;
-        const parent = this.parent;
-        const metaProperty = this.metaProperty;
-        if (metaProperty &&
-            (metaProperty.startsWith(FILE_PREFIX) ||
-                metaProperty.startsWith(ASSET_PREFIX) ||
-                metaProperty.startsWith(CHUNK_PREFIX))) {
-            let referenceId = null;
-            let assetReferenceId = null;
-            let chunkReferenceId = null;
-            let fileName;
-            if (metaProperty.startsWith(FILE_PREFIX)) {
-                referenceId = metaProperty.substring(FILE_PREFIX.length);
-                fileName = outputPluginDriver.getFileName(referenceId);
-            }
-            else if (metaProperty.startsWith(ASSET_PREFIX)) {
-                warnDeprecation(`Using the "${ASSET_PREFIX}" prefix to reference files is deprecated. Use the "${FILE_PREFIX}" prefix instead.`, true, this.context.options);
-                assetReferenceId = metaProperty.substring(ASSET_PREFIX.length);
-                fileName = outputPluginDriver.getFileName(assetReferenceId);
-            }
-            else {
-                warnDeprecation(`Using the "${CHUNK_PREFIX}" prefix to reference files is deprecated. Use the "${FILE_PREFIX}" prefix instead.`, true, this.context.options);
-                chunkReferenceId = metaProperty.substring(CHUNK_PREFIX.length);
-                fileName = outputPluginDriver.getFileName(chunkReferenceId);
-            }
+        const { metaProperty, parent, referenceId } = this;
+        const chunkId = this.preliminaryChunkId;
+        if (referenceId) {
+            const fileName = pluginDriver.getFileName(referenceId);
             const relativePath = normalize(relative$1(dirname(chunkId), fileName));
-            let replacement;
-            if (assetReferenceId !== null) {
-                replacement = outputPluginDriver.hookFirstSync('resolveAssetUrl', [
-                    {
-                        assetFileName: fileName,
-                        chunkId,
-                        format,
-                        moduleId: this.context.module.id,
-                        relativeAssetPath: relativePath
-                    }
-                ]);
-            }
-            if (!replacement) {
-                replacement =
-                    outputPluginDriver.hookFirstSync('resolveFileUrl', [
-                        {
-                            assetReferenceId,
-                            chunkId,
-                            chunkReferenceId,
-                            fileName,
-                            format,
-                            moduleId: this.context.module.id,
-                            referenceId: referenceId || assetReferenceId || chunkReferenceId,
-                            relativePath
-                        }
-                    ]) || relativeUrlMechanisms[format](relativePath);
-            }
+            const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
+                {
+                    chunkId,
+                    fileName,
+                    format,
+                    moduleId: this.context.module.id,
+                    referenceId,
+                    relativePath
+                }
+            ]) || relativeUrlMechanisms[format](relativePath);
             code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
             return;
         }
-        const replacement = outputPluginDriver.hookFirstSync('resolveImportMeta', [
+        const replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
             metaProperty,
             {
                 chunkId,
@@ -10683,6 +10687,14 @@ class MetaProperty extends NodeBase {
             }
         }
     }
+    setResolution(format, accessedGlobalsByScope, preliminaryChunkId) {
+        var _a;
+        this.preliminaryChunkId = preliminaryChunkId;
+        const accessedGlobals = (((_a = this.metaProperty) === null || _a === void 0 ? void 0 : _a.startsWith(FILE_PREFIX)) ? accessedFileUrlGlobals : accessedMetaUrlGlobals)[format];
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
 }
 const accessedMetaUrlGlobals = {
     amd: ['document', 'module', 'URL'],
@@ -12328,7 +12340,6 @@ class Module {
         this.needsExportShim = false;
         this.sideEffectDependenciesByVariable = new Map();
         this.sources = new Set();
-        this.usesTopLevelAwait = false;
         this.allExportNames = null;
         this.ast = null;
         this.exportAllModules = [];
@@ -12373,7 +12384,7 @@ class Module {
                 return module.exports.has('default') || reexportDescriptions.has('default');
             },
             get hasModuleSideEffects() {
-                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', false, options);
+                warnDeprecation('Accessing ModuleInfo.hasModuleSideEffects from plugins is deprecated. Please use ModuleInfo.moduleSideEffects instead.', true, options);
                 return this.moduleSideEffects;
             },
             id,
@@ -12685,10 +12696,14 @@ class Module {
         this.exportAllModules.push(...externalExportAllModules);
     }
     render(options) {
-        const magicString = this.magicString.clone();
-        this.ast.render(magicString, options);
-        this.usesTopLevelAwait = this.astContext.usesTopLevelAwait;
-        return magicString;
+        const source = this.magicString.clone();
+        this.ast.render(source, options);
+        source.trim();
+        const { usesTopLevelAwait } = this.astContext;
+        if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
+            return error(errInvalidFormatForTopLevelAwait(this.id, options.format));
+        }
+        return { source, usesTopLevelAwait };
     }
     setSource({ ast, code, customTransformCache, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles, ...moduleOptions }) {
         this.info.code = code;
@@ -13122,11 +13137,11 @@ function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snip
         return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
     }
     let exportBlock = '';
-    for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+    for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
         if (reexports && namedExportsMode) {
             for (const specifier of reexports) {
                 if (specifier.reexported !== '*') {
-                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings, getPropertyAccess);
+                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
                     if (exportBlock)
                         exportBlock += n;
                     if (specifier.imported !== '*' && specifier.needsLiveBinding) {
@@ -13184,9 +13199,9 @@ function getSingleDefaultExport(exports, dependencies, interop, externalLiveBind
         return exports[0].local;
     }
     else {
-        for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
             if (reexports) {
-                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings, getPropertyAccess);
+                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
             }
         }
     }
@@ -13261,7 +13276,7 @@ function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, na
         neededInteropHelpers.add(helper);
         interopStatements.push(`${cnst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
     };
-    for (const { defaultVariableName, imports, id, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
+    for (const { defaultVariableName, imports, importPath, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
         if (isChunk) {
             for (const { imported, reexported } of [
                 ...(imports || []),
@@ -13276,7 +13291,7 @@ function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, na
             }
         }
         else {
-            const moduleInterop = String(interop(id));
+            const moduleInterop = String(interop(importPath));
             let hasDefault = false;
             let hasNamespace = false;
             for (const { imported, reexported } of [
@@ -13341,7 +13356,9 @@ const builtins = {
     zlib: true
 };
 function warnOnBuiltins(warn, dependencies) {
-    const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins);
+    const externalBuiltins = dependencies
+        .map(({ importPath }) => importPath)
+        .filter(importPath => importPath in builtins);
     if (!externalBuiltins.length)
         return;
     warn({
@@ -13351,9 +13368,9 @@ function warnOnBuiltins(warn, dependencies) {
     });
 }
 
-function amd(magicString, { accessedGlobals, dependencies, exports, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets, warn }, { amd, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
-    warnOnBuiltins(warn, dependencies);
-    const deps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.id)}'`);
+function amd(magicString, { accessedGlobals, dependencies, exports, 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 => `'${removeExtensionFromRelativeAmdId(m.importPath)}'`);
     const args = dependencies.map(m => m.name);
     const { n, getNonArrowFunctionIntro, _ } = snippets;
     if (namedExportsMode && hasExports) {
@@ -13378,8 +13395,8 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
     }
-    magicString.append(`${exportBlock}${namespaceMarkers}${outro}`);
-    return (magicString
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
         .indent(t)
         // factory function should be wrapped by parentheses to avoid lazy parsing,
         // cf. https://v8.dev/blog/preparser#pife
@@ -13387,7 +13404,7 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         isAsync: false,
         name: null
     })}{${useStrict}${n}${n}`)
-        .append(`${n}${n}}));`));
+        .append(`${n}${n}}));`);
 }
 
 function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
@@ -13401,23 +13418,23 @@ function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports,
     const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, t, snippets);
     magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
     const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, `module.exports${_}=${_}`);
-    return magicString.append(`${exportBlock}${outro}`);
+    magicString.append(`${exportBlock}${outro}`);
 }
 function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
     let importBlock = '';
     let definingVariable = false;
-    for (const { id, name, reexports, imports } of dependencies) {
+    for (const { importPath, name, reexports, imports } of dependencies) {
         if (!reexports && !imports) {
             if (importBlock) {
                 importBlock += compact && !definingVariable ? ',' : `;${n}`;
             }
             definingVariable = false;
-            importBlock += `require('${id}')`;
+            importBlock += `require('${importPath}')`;
         }
         else {
             importBlock += compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${cnst} `;
             definingVariable = true;
-            importBlock += `${name}${_}=${_}require('${id}')`;
+            importBlock += `${name}${_}=${_}require('${importPath}')`;
         }
     }
     if (importBlock) {
@@ -13439,13 +13456,13 @@ function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencie
         magicString.append(n + n + exportBlock.join(n).trim());
     if (outro)
         magicString.append(outro);
-    return magicString.trim();
+    magicString.trim();
 }
 function getImportBlock(dependencies, _) {
     const importBlock = [];
-    for (const { id, reexports, imports, name } of dependencies) {
+    for (const { importPath, reexports, imports, name } of dependencies) {
         if (!reexports && !imports) {
-            importBlock.push(`import${_}'${id}';`);
+            importBlock.push(`import${_}'${importPath}';`);
             continue;
         }
         if (imports) {
@@ -13464,10 +13481,10 @@ function getImportBlock(dependencies, _) {
                 }
             }
             if (starImport) {
-                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}'${id}';`);
+                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}'${importPath}';`);
             }
             if (defaultImport && importedNames.length === 0) {
-                importBlock.push(`import ${defaultImport.local} from${_}'${id}';`);
+                importBlock.push(`import ${defaultImport.local} from${_}'${importPath}';`);
             }
             else if (importedNames.length > 0) {
                 importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
@@ -13479,7 +13496,7 @@ function getImportBlock(dependencies, _) {
                         return `${specifier.imported} as ${specifier.local}`;
                     }
                 })
-                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
+                    .join(`,${_}`)}${_}}${_}from${_}'${importPath}';`);
             }
         }
         if (reexports) {
@@ -13498,12 +13515,12 @@ function getImportBlock(dependencies, _) {
                 }
             }
             if (starExport) {
-                importBlock.push(`export${_}*${_}from${_}'${id}';`);
+                importBlock.push(`export${_}*${_}from${_}'${importPath}';`);
             }
             if (namespaceReexports.length > 0) {
                 if (!imports ||
                     !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
-                    importBlock.push(`import${_}*${_}as ${name} from${_}'${id}';`);
+                    importBlock.push(`import${_}*${_}as ${name} from${_}'${importPath}';`);
                 }
                 for (const specifier of namespaceReexports) {
                     importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${specifier.reexported}`} };`);
@@ -13519,7 +13536,7 @@ function getImportBlock(dependencies, _) {
                         return `${specifier.imported} as ${specifier.reexported}`;
                     }
                 })
-                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
+                    .join(`,${_}`)}${_}}${_}from${_}'${importPath}';`);
             }
         }
     }
@@ -13585,7 +13602,7 @@ function trimEmptyImports(dependencies) {
     return [];
 }
 
-function iife(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, namedExportsMode, outro, snippets, warn }, { compact, esModule, extend, freeze, externalLiveBindings, globals, interop, name, namespaceToStringTag, strict }) {
+function iife(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, namedExportsMode, outro, snippets, onwarn }, { compact, esModule, extend, freeze, externalLiveBindings, globals, interop, name, namespaceToStringTag, strict }) {
     const { _, cnst, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
     const isNamespaced = name && name.includes('.');
     const useVariableAssignment = !extend && !isNamespaced;
@@ -13595,12 +13612,12 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasExports,
             message: `Given name "${name}" is not a legal JS identifier. If you need this, you can try "output.extend: true".`
         });
     }
-    warnOnBuiltins(warn, dependencies);
+    warnOnBuiltins(onwarn, dependencies);
     const external = trimEmptyImports(dependencies);
     const deps = external.map(dep => dep.globalName || 'null');
     const args = external.map(m => m.name);
     if (hasExports && !name) {
-        warn({
+        onwarn({
             code: 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT',
             message: `If you do not supply "output.name", you may not be able to access the exports of an IIFE bundle.`
         });
@@ -13641,8 +13658,11 @@ function iife(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
     }
-    magicString.append(`${exportBlock}${namespaceMarkers}${outro}`);
-    return magicString.indent(t).prepend(wrapperIntro).append(wrapperOutro);
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        .prepend(wrapperIntro)
+        .append(wrapperOutro);
 }
 
 function system(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, namespaceToStringTag, strict, systemNullSetters }) {
@@ -13657,7 +13677,7 @@ function system(magicString, { accessedGlobals, dependencies, exports, hasExport
     // factory function should be wrapped by parentheses to avoid lazy parsing,
     // cf. https://v8.dev/blog/preparser#pife
     let wrapperStart = `System.register(${registeredName}[` +
-        dependencies.map(({ id }) => `'${id}'`).join(`,${_}`) +
+        dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
         `],${_}(${getNonArrowFunctionIntro(wrapperParams, { isAsync: false, name: null })}{${n}${t}${strict ? "'use strict';" : ''}` +
         getStarExcludesBlock(starExcludes, t, snippets) +
         getImportBindingsBlock(importBindings, t, snippets) +
@@ -13678,13 +13698,16 @@ function system(magicString, { accessedGlobals, dependencies, exports, hasExport
         name: null
     })}{${n}${n}`;
     const wrapperEnd = `${t}${t}})${n}${t}}${s}${n}}));`;
-    magicString.prepend(intro +
+    magicString
+        .prepend(intro +
         getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, namespaceToStringTag) +
-        getHoistedExportsBlock(exports, t, snippets));
-    magicString.append(`${outro}${n}${n}` +
+        getHoistedExportsBlock(exports, t, snippets))
+        .append(`${outro}${n}${n}` +
         getSyntheticExportsBlock(exports, t, snippets) +
-        getMissingExportsBlock(exports, t, snippets));
-    return magicString.indent(`${t}${t}${t}`).append(wrapperEnd).prepend(wrapperStart);
+        getMissingExportsBlock(exports, t, snippets))
+        .indent(`${t}${t}${t}`)
+        .append(wrapperEnd)
+        .prepend(wrapperStart);
 }
 function analyzeDependencies(dependencies, exports, t, { _, cnst, getObject, getPropertyAccess, n }) {
     const importBindings = [];
@@ -13786,7 +13809,7 @@ function safeAccess(name, globalVar, { _, getPropertyAccess }) {
         .map(part => (propertyPath += getPropertyAccess(part)))
         .join(`${_}&&${_}`);
 }
-function umd(magicString, { accessedGlobals, dependencies, exports, hasExports, id, indent: t, intro, namedExportsMode, outro, snippets, warn }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, namespaceToStringTag, globals, noConflict, strict }) {
+function umd(magicString, { accessedGlobals, dependencies, exports, 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';
@@ -13796,9 +13819,9 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
             message: 'You must supply "output.name" for UMD bundles that have exports so that the exports are accessible in environments without a module loader.'
         });
     }
-    warnOnBuiltins(warn, dependencies);
-    const amdDeps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.id)}'`);
-    const cjsDeps = dependencies.map(m => `require('${m.id}')`);
+    warnOnBuiltins(onwarn, dependencies);
+    const amdDeps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.importPath)}'`);
+    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);
@@ -13875,193 +13898,352 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
     if (namespaceMarkers) {
         namespaceMarkers = n + n + namespaceMarkers;
     }
-    magicString.append(`${exportBlock}${namespaceMarkers}${outro}`);
-    return magicString.trim().indent(t).append(wrapperOutro).prepend(wrapperIntro);
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .trim()
+        .indent(t)
+        .append(wrapperOutro)
+        .prepend(wrapperIntro);
 }
 
 const finalisers = { amd, cjs, es, iife, system, umd };
 
-class Source {
-    constructor(filename, content) {
-        this.isOriginal = true;
-        this.filename = filename;
-        this.content = content;
+const createHash = () => createHash$1('sha256');
+
+// Four random characters from the private use area to minimize risk of conflicts
+const hashPlaceholderLeft = '\uf7f9\ue4d3';
+const hashPlaceholderRight = '\ue3cc\uf1fe';
+const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
+// This is the size of a sha256
+const maxHashSize = 64;
+const defaultHashSize = 8;
+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.`));
+        }
+        const placeholder = `${hashPlaceholderLeft}${String(++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.`));
+        }
+        nextIndex++;
+        return placeholder;
+    };
+};
+const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}\\d{1,${maxHashSize - hashPlaceholderOverhead}}${hashPlaceholderRight}`, 'g');
+const replacePlaceholders = (code, hashesByPlaceholder) => code.replace(REPLACER_REGEX, placeholder => hashesByPlaceholder.get(placeholder) || placeholder);
+const replaceSinglePlaceholder = (code, placeholder, value) => code.replace(REPLACER_REGEX, match => (match === placeholder ? value : match));
+const replacePlaceholdersWithDefaultAndGetContainedPlaceholders = (code, placeholders) => {
+    const containedPlaceholders = new Set();
+    const transformedCode = code.replace(REPLACER_REGEX, placeholder => {
+        if (placeholders.has(placeholder)) {
+            containedPlaceholders.add(placeholder);
+            return `${hashPlaceholderLeft}${'0'.repeat(placeholder.length - hashPlaceholderOverhead)}${hashPlaceholderRight}`;
+        }
+        return placeholder;
+    });
+    return { containedPlaceholders, transformedCode };
+};
+
+function renderNamePattern(pattern, patternName, replacements) {
+    if (isPathFragment(pattern))
+        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths.`));
+    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.`));
+        }
+        const replacement = replacements[type](size && 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 replacement;
+    });
+}
+function makeUnique(name, existingNames) {
+    const existingNamesLowercase = new Set(Object.keys(existingNames).map(key => key.toLowerCase()));
+    if (!existingNamesLowercase.has(name.toLocaleLowerCase()))
+        return name;
+    const ext = extname(name);
+    name = name.substring(0, name.length - ext.length);
+    let uniqueName, uniqueIndex = 1;
+    while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
+        ;
+    return uniqueName;
+}
+
+function generateAssetFileName(name, source, outputOptions, bundle) {
+    const emittedName = outputOptions.sanitizeFileName(name || 'asset');
+    return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
+        ? outputOptions.assetFileNames({ name, source, type: 'asset' })
+        : outputOptions.assetFileNames, 'output.assetFileNames', {
+        ext: () => extname(emittedName).substring(1),
+        extname: () => extname(emittedName),
+        hash: size => createHash()
+            .update(source)
+            .digest('hex')
+            .substring(0, size || defaultHashSize),
+        name: () => emittedName.substring(0, emittedName.length - extname(emittedName).length)
+    }), bundle);
+}
+function reserveFileNameInBundle(fileName, bundle, warn) {
+    if (fileName in bundle) {
+        warn(errFileNameConflict(fileName));
     }
-    traceSegment(line, column, name) {
-        return { column, line, name, source: this };
+    bundle[fileName] = FILE_PLACEHOLDER;
+}
+const FILE_PLACEHOLDER = {
+    type: 'placeholder'
+};
+function hasValidType(emittedFile) {
+    return Boolean(emittedFile &&
+        (emittedFile.type === 'asset' ||
+            emittedFile.type === 'chunk'));
+}
+function hasValidName(emittedFile) {
+    const validatedName = emittedFile.fileName || emittedFile.name;
+    return !validatedName || (typeof validatedName === 'string' && !isPathFragment(validatedName));
+}
+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 source;
 }
-class Link {
-    constructor(map, sources) {
-        this.sources = sources;
-        this.names = map.names;
-        this.mappings = map.mappings;
+function getAssetFileName(file, referenceId) {
+    if (typeof file.fileName !== 'string') {
+        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
     }
-    traceMappings() {
-        const sources = [];
-        const sourceIndexMap = new Map();
-        const sourcesContent = [];
-        const names = [];
-        const nameIndexMap = new Map();
-        const mappings = [];
-        for (const line of this.mappings) {
-            const tracedLine = [];
-            for (const segment of line) {
-                if (segment.length === 1)
-                    continue;
-                const source = this.sources[segment[1]];
-                if (!source)
-                    continue;
-                const traced = source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : '');
-                if (traced) {
-                    const { column, line, name, source: { content, filename } } = traced;
-                    let sourceIndex = sourceIndexMap.get(filename);
-                    if (sourceIndex === undefined) {
-                        sourceIndex = sources.length;
-                        sources.push(filename);
-                        sourceIndexMap.set(filename, sourceIndex);
-                        sourcesContent[sourceIndex] = content;
-                    }
-                    else if (sourcesContent[sourceIndex] == null) {
-                        sourcesContent[sourceIndex] = content;
-                    }
-                    else if (content != null && sourcesContent[sourceIndex] !== content) {
-                        return error({
-                            message: `Multiple conflicting contents for sourcemap source ${filename}`
-                        });
-                    }
-                    const tracedSegment = [segment[0], sourceIndex, line, column];
-                    if (name) {
-                        let nameIndex = nameIndexMap.get(name);
-                        if (nameIndex === undefined) {
-                            nameIndex = names.length;
-                            names.push(name);
-                            nameIndexMap.set(name, nameIndex);
-                        }
-                        tracedSegment[4] = nameIndex;
-                    }
-                    tracedLine.push(tracedSegment);
-                }
-            }
-            mappings.push(tracedLine);
-        }
-        return { mappings, names, sources, sourcesContent };
+    return file.fileName;
+}
+function getChunkFileName(file, facadeChunkByModule) {
+    if (file.fileName) {
+        return file.fileName;
     }
-    traceSegment(line, column, name) {
-        const segments = this.mappings[line];
-        if (!segments)
-            return null;
-        // binary search through segments for the given column
-        let searchStart = 0;
-        let searchEnd = segments.length - 1;
-        while (searchStart <= searchEnd) {
-            const m = (searchStart + searchEnd) >> 1;
-            const segment = segments[m];
-            // If a sourcemap does not have sufficient resolution to contain a
-            // necessary mapping, e.g. because it only contains line information, we
-            // use the best approximation we could find
-            if (segment[0] === column || searchStart === searchEnd) {
-                if (segment.length == 1)
-                    return null;
-                const source = this.sources[segment[1]];
-                if (!source)
-                    return null;
-                return source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : name);
+    if (facadeChunkByModule) {
+        const chunk = facadeChunkByModule.get(file.module);
+        return chunk.id || chunk.getFileName();
+    }
+    return error(errChunkNotGeneratedForFileName(file.fileName || file.name));
+}
+class FileEmitter {
+    constructor(graph, options, baseFileEmitter) {
+        this.graph = graph;
+        this.options = options;
+        this.bundle = null;
+        this.facadeChunkByModule = null;
+        this.outputOptions = null;
+        this.emitFile = (emittedFile) => {
+            if (!hasValidType(emittedFile)) {
+                return error(errFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
             }
-            if (segment[0] > column) {
-                searchEnd = m - 1;
+            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}".`));
+            }
+            if (emittedFile.type === 'chunk') {
+                return this.emitChunk(emittedFile);
+            }
+            return this.emitAsset(emittedFile);
+        };
+        this.finaliseAssets = () => {
+            for (const [referenceId, emittedFile] of this.filesByReferenceId) {
+                if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
+                    return error(errNoAssetSourceSet(emittedFile.name || referenceId));
+            }
+        };
+        this.getFileName = (fileReferenceId) => {
+            const emittedFile = this.filesByReferenceId.get(fileReferenceId);
+            if (!emittedFile)
+                return error(errFileReferenceIdNotFoundForFilename(fileReferenceId));
+            if (emittedFile.type === 'chunk') {
+                return getChunkFileName(emittedFile, this.facadeChunkByModule);
+            }
+            return getAssetFileName(emittedFile, fileReferenceId);
+        };
+        this.setAssetSource = (referenceId, requestedSource) => {
+            const consumedFile = this.filesByReferenceId.get(referenceId);
+            if (!consumedFile)
+                return error(errAssetReferenceIdNotFoundForSetSource(referenceId));
+            if (consumedFile.type !== 'asset') {
+                return error(errFailedValidation(`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));
+            }
+            const source = getValidSource(requestedSource, consumedFile, referenceId);
+            if (this.bundle) {
+                this.finalizeAsset(consumedFile, source, referenceId, this.bundle);
             }
             else {
-                searchStart = m + 1;
+                consumedFile.source = source;
+            }
+        };
+        this.setChunkInformation = (facadeChunkByModule) => {
+            this.facadeChunkByModule = facadeChunkByModule;
+        };
+        this.setOutputBundle = (outputBundle, outputOptions) => {
+            this.outputOptions = outputOptions;
+            this.bundle = outputBundle;
+            for (const emittedFile of this.filesByReferenceId.values()) {
+                if (emittedFile.fileName) {
+                    reserveFileNameInBundle(emittedFile.fileName, this.bundle, this.options.onwarn);
+                }
+            }
+            for (const [referenceId, consumedFile] of this.filesByReferenceId) {
+                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, this.bundle);
+                }
+            }
+        };
+        this.filesByReferenceId = baseFileEmitter
+            ? new Map(baseFileEmitter.filesByReferenceId)
+            : new Map();
+    }
+    assignReferenceId(file, idBase) {
+        let referenceId;
+        do {
+            referenceId = createHash()
+                .update(referenceId || idBase)
+                .digest('hex')
+                .substring(0, 8);
+        } while (this.filesByReferenceId.has(referenceId));
+        this.filesByReferenceId.set(referenceId, file);
+        return referenceId;
+    }
+    emitAsset(emittedAsset) {
+        const source = typeof emittedAsset.source !== 'undefined'
+            ? getValidSource(emittedAsset.source, emittedAsset, null)
+            : undefined;
+        const consumedAsset = {
+            fileName: emittedAsset.fileName,
+            name: emittedAsset.name,
+            source,
+            type: 'asset'
+        };
+        const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || emittedAsset.type);
+        if (this.bundle) {
+            if (emittedAsset.fileName) {
+                reserveFileNameInBundle(emittedAsset.fileName, this.bundle, this.options.onwarn);
+            }
+            if (source !== undefined) {
+                this.finalizeAsset(consumedAsset, source, referenceId, this.bundle);
             }
         }
-        return null;
+        return referenceId;
     }
-}
-function getLinkMap(warn) {
-    return function linkMap(source, map) {
-        if (map.mappings) {
-            return new Link(map, [source]);
+    emitChunk(emittedChunk) {
+        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
+            return error(errInvalidRollupPhaseForChunkEmission());
         }
-        warn({
-            code: 'SOURCEMAP_BROKEN',
-            message: `Sourcemap is likely to be incorrect: a plugin (${map.plugin}) was used to transform ` +
-                "files, but didn't generate a sourcemap for the transformation. Consult the plugin " +
-                'documentation for help',
-            plugin: map.plugin,
-            url: `https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect`
+        if (typeof emittedChunk.id !== 'string') {
+            return error(errFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+        }
+        const consumedChunk = {
+            fileName: emittedChunk.fileName,
+            module: null,
+            name: emittedChunk.name || emittedChunk.id,
+            type: 'chunk'
+        };
+        this.graph.moduleLoader
+            .emitChunk(emittedChunk)
+            .then(module => (consumedChunk.module = module))
+            .catch(() => {
+            // Avoid unhandled Promise rejection as the error will be thrown later
+            // once module loading has finished
         });
-        return new Link({
-            mappings: [],
-            names: []
-        }, [source]);
-    };
-}
-function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, linkMap) {
-    let source;
-    if (!originalSourcemap) {
-        source = new Source(id, originalCode);
+        return this.assignReferenceId(consumedChunk, emittedChunk.id);
     }
-    else {
-        const sources = originalSourcemap.sources;
-        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]));
-        source = new Link(originalSourcemap, baseSources);
+    finalizeAsset(consumedFile, source, referenceId, bundle) {
+        const fileName = consumedFile.fileName ||
+            findExistingAssetFileNameWithSource(bundle, source) ||
+            generateAssetFileName(consumedFile.name, source, this.outputOptions, bundle);
+        // We must not modify the original assets to avoid interaction between outputs
+        const assetWithFileName = { ...consumedFile, fileName, source };
+        this.filesByReferenceId.set(referenceId, assetWithFileName);
+        bundle[fileName] = {
+            fileName,
+            name: consumedFile.name,
+            source,
+            type: 'asset'
+        };
     }
-    return sourcemapChain.reduce(linkMap, source);
 }
-function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, warn) {
-    const linkMap = getLinkMap(warn);
-    const moduleSources = modules
-        .filter(module => !module.excludeFromSourcemap)
-        .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
-    const link = new Link(map, moduleSources);
-    const source = bundleSourcemapChain.reduce(linkMap, link);
-    let { sources, sourcesContent, names, mappings } = source.traceMappings();
-    if (file) {
-        const directory = dirname(file);
-        sources = sources.map((source) => relative$1(directory, source));
-        file = basename(file);
+function findExistingAssetFileNameWithSource(bundle, source) {
+    for (const [fileName, outputFile] of Object.entries(bundle)) {
+        if (outputFile.type === 'asset' && areSourcesEqual(source, outputFile.source))
+            return fileName;
     }
-    sourcesContent = (excludeContent ? null : sourcesContent);
-    return new SourceMap({ file, mappings, names, sources, sourcesContent });
+    return null;
 }
-function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn) {
-    if (!sourcemapChain.length) {
-        return originalSourcemap;
+function areSourcesEqual(sourceA, sourceB) {
+    if (typeof sourceA === 'string') {
+        return sourceA === sourceB;
     }
-    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(warn));
-    const map = source.traceMappings();
-    return { version: 3, ...map };
-}
-
-const createHash = () => createHash$1('sha256');
-
-const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
-    amd: deconflictImportsOther,
+    if (typeof sourceB === 'string') {
+        return false;
+    }
+    if ('equals' in sourceA) {
+        return sourceA.equals(sourceB);
+    }
+    if (sourceA.length !== sourceB.length) {
+        return false;
+    }
+    for (let index = 0; index < sourceA.length; index++) {
+        if (sourceA[index] !== sourceB[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const concatSep = (out, next) => (next ? `${out}\n${next}` : out);
+const concatDblSep = (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)
+        ]);
+        if (intro)
+            intro += '\n\n';
+        if (outro)
+            outro = `\n\n${outro}`;
+        if (banner)
+            banner += '\n';
+        if (footer)
+            footer = '\n' + footer;
+        return { banner, footer, intro, outro };
+    }
+    catch (err) {
+        return error(errAddonNotGenerated(err.message, err.hook, err.plugin));
+    }
+}
+
+const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
+    amd: deconflictImportsOther,
     cjs: deconflictImportsOther,
     es: deconflictImportsEsmOrSystem,
     iife: deconflictImportsOther,
     system: deconflictImportsEsmOrSystem,
     umd: deconflictImportsOther
 };
-function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
+function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
     const reversedModules = modules.slice().reverse();
     for (const module of reversedModules) {
         module.scope.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
     }
     deconflictTopLevelVariables(usedNames, reversedModules, includedNamespaces);
-    DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](usedNames, imports, dependenciesToBeDeconflicted, interop, preserveModules, externalLiveBindings, chunkByModule, syntheticExports);
+    DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](usedNames, imports, dependenciesToBeDeconflicted, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports);
     for (const module of reversedModules) {
         module.scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
     }
 }
-function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconflicted, _interop, preserveModules, _externalLiveBindings, chunkByModule, syntheticExports) {
+function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconflicted, _interop, preserveModules, _externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports) {
     // This is needed for namespace reexports
     for (const dependency of dependenciesToBeDeconflicted.dependencies) {
-        if (preserveModules || dependency instanceof ExternalModule) {
+        if (preserveModules || dependency instanceof ExternalChunk) {
             dependency.variableName = getSafeName(dependency.suggestedVariableName, usedNames);
         }
     }
@@ -14069,7 +14251,9 @@ function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconf
         const module = variable.module;
         const name = variable.name;
         if (variable.isNamespace && (preserveModules || module instanceof ExternalModule)) {
-            variable.setRenderNames(null, (module instanceof ExternalModule ? module : chunkByModule.get(module)).variableName);
+            variable.setRenderNames(null, (module instanceof ExternalModule
+                ? externalChunkByModule.get(module)
+                : chunkByModule.get(module)).variableName);
         }
         else if (module instanceof ExternalModule && name === 'default') {
             variable.setRenderNames(null, getSafeName([...module.exportedVariables].some(([exportedVariable, exportedName]) => exportedName === '*' && exportedVariable.included)
@@ -14084,12 +14268,12 @@ function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconf
         variable.setRenderNames(null, getSafeName(variable.name, usedNames));
     }
 }
-function deconflictImportsOther(usedNames, imports, { deconflictedDefault, deconflictedNamespace, dependencies }, interop, preserveModules, externalLiveBindings, chunkByModule) {
-    for (const chunkOrExternalModule of dependencies) {
-        chunkOrExternalModule.variableName = getSafeName(chunkOrExternalModule.suggestedVariableName, usedNames);
+function deconflictImportsOther(usedNames, imports, { deconflictedDefault, deconflictedNamespace, dependencies }, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule) {
+    for (const chunk of dependencies) {
+        chunk.variableName = getSafeName(chunk.suggestedVariableName, usedNames);
     }
-    for (const externalModuleOrChunk of deconflictedNamespace) {
-        externalModuleOrChunk.namespaceVariableName = getSafeName(`${externalModuleOrChunk.suggestedVariableName}__namespace`, usedNames);
+    for (const chunk of deconflictedNamespace) {
+        chunk.namespaceVariableName = getSafeName(`${chunk.suggestedVariableName}__namespace`, usedNames);
     }
     for (const externalModule of deconflictedDefault) {
         if (deconflictedNamespace.has(externalModule) &&
@@ -14103,12 +14287,13 @@ function deconflictImportsOther(usedNames, imports, { deconflictedDefault, decon
     for (const variable of imports) {
         const module = variable.module;
         if (module instanceof ExternalModule) {
+            const chunk = externalChunkByModule.get(module);
             const name = variable.name;
             if (name === 'default') {
                 const moduleInterop = String(interop(module.id));
                 const variableName = defaultInteropHelpersByInteropType[moduleInterop]
-                    ? module.defaultVariableName
-                    : module.variableName;
+                    ? chunk.defaultVariableName
+                    : chunk.variableName;
                 if (isDefaultAProperty(moduleInterop, externalLiveBindings)) {
                     variable.setRenderNames(variableName, 'default');
                 }
@@ -14118,12 +14303,12 @@ function deconflictImportsOther(usedNames, imports, { deconflictedDefault, decon
             }
             else if (name === '*') {
                 variable.setRenderNames(null, namespaceInteropHelpersByInteropType[String(interop(module.id))]
-                    ? module.namespaceVariableName
-                    : module.variableName);
+                    ? chunk.namespaceVariableName
+                    : chunk.variableName);
             }
             else {
                 // if the second parameter is `null`, it uses its "name" for the property name
-                variable.setRenderNames(module.variableName, null);
+                variable.setRenderNames(chunk.variableName, null);
             }
         }
         else {
@@ -14157,15 +14342,6 @@ function deconflictTopLevelVariables(usedNames, modules, includedNamespaces) {
     }
 }
 
-const needsEscapeRegEx = /[\\'\r\n\u2028\u2029]/;
-const quoteNewlineRegEx = /(['\r\n\u2028\u2029])/g;
-const backSlashRegEx = /\\/g;
-function escapeId(id) {
-    if (!id.match(needsEscapeRegEx))
-        return id;
-    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
-}
-
 function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
     let nameIndex = 0;
     for (const variable of exports) {
@@ -14257,14 +14433,14 @@ function getIndentString(modules, options) {
     return '\t';
 }
 
-function getStaticDependencies(chunk, orderedModules, chunkByModule) {
+function getStaticDependencies(chunk, orderedModules, chunkByModule, externalChunkByModule) {
     const staticDependencyBlocks = [];
     const handledDependencies = new Set();
     for (let modulePos = orderedModules.length - 1; modulePos >= 0; modulePos--) {
         const module = orderedModules[modulePos];
         if (!handledDependencies.has(module)) {
             const staticDependencies = [];
-            addStaticDependencies(module, staticDependencies, handledDependencies, chunk, chunkByModule);
+            addStaticDependencies(module, staticDependencies, handledDependencies, chunk, chunkByModule, externalChunkByModule);
             staticDependencyBlocks.unshift(staticDependencies);
         }
     }
@@ -14276,11 +14452,11 @@ function getStaticDependencies(chunk, orderedModules, chunkByModule) {
     }
     return dependencies;
 }
-function addStaticDependencies(module, staticDependencies, handledModules, chunk, chunkByModule) {
+function addStaticDependencies(module, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule) {
     const dependencies = module.getDependenciesToBeIncluded();
     for (const dependency of dependencies) {
         if (dependency instanceof ExternalModule) {
-            staticDependencies.push(dependency);
+            staticDependencies.push(externalChunkByModule.get(dependency));
             continue;
         }
         const dependencyChunk = chunkByModule.get(dependency);
@@ -14290,91 +14466,29 @@ function addStaticDependencies(module, staticDependencies, handledModules, chunk
         }
         if (!handledModules.has(dependency)) {
             handledModules.add(dependency);
-            addStaticDependencies(dependency, staticDependencies, handledModules, chunk, chunkByModule);
+            addStaticDependencies(dependency, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule);
         }
     }
 }
 
-function decodedSourcemap(map) {
-    if (!map)
-        return null;
-    if (typeof map === 'string') {
-        map = JSON.parse(map);
-    }
-    if (map.mappings === '') {
-        return {
-            mappings: [],
-            names: [],
-            sources: [],
-            version: 3
-        };
-    }
-    const mappings = typeof map.mappings === 'string' ? decode(map.mappings) : map.mappings;
-    return { ...map, mappings };
-}
-
-function renderChunk({ code, options, outputPluginDriver, renderChunk, sourcemapChain }) {
-    const renderChunkReducer = (code, result, plugin) => {
-        if (result == null)
-            return code;
-        if (typeof result === 'string')
-            result = {
-                code: result,
-                map: undefined
-            };
-        // strict null check allows 'null' maps to not be pushed to the chain, while 'undefined' gets the missing map warning
-        if (result.map !== null) {
-            const map = decodedSourcemap(result.map);
-            sourcemapChain.push(map || { missing: true, plugin: plugin.name });
-        }
-        return result.code;
-    };
-    return outputPluginDriver.hookReduceArg0('renderChunk', [code, renderChunk, options], renderChunkReducer);
-}
-
-function renderNamePattern(pattern, patternName, replacements) {
-    if (isPathFragment(pattern))
-        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths.`));
-    return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
-        if (!replacements.hasOwnProperty(type)) {
-            return error(errFailedValidation(`"[${type}]" is not a valid placeholder in "${patternName}" pattern.`));
-        }
-        const replacement = replacements[type]();
-        if (isPathFragment(replacement))
-            return error(errFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
-        return replacement;
-    });
-}
-function makeUnique(name, existingNames) {
-    const existingNamesLowercase = new Set(Object.keys(existingNames).map(key => key.toLowerCase()));
-    if (!existingNamesLowercase.has(name.toLocaleLowerCase()))
-        return name;
-    const ext = extname(name);
-    name = name.substring(0, name.length - ext.length);
-    let uniqueName, uniqueIndex = 1;
-    while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
-        ;
-    return uniqueName;
-}
-
 const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
-function getGlobalName(module, globals, hasExports, warn) {
-    const globalName = typeof globals === 'function' ? globals(module.id) : globals[module.id];
+function getGlobalName(chunk, globals, hasExports, warn) {
+    const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
     if (globalName) {
         return globalName;
     }
     if (hasExports) {
         warn({
             code: 'MISSING_GLOBAL_NAME',
-            guess: module.variableName,
-            message: `No name was provided for external module '${module.id}' in output.globals – guessing '${module.variableName}'`,
-            source: module.id
+            guess: chunk.variableName,
+            message: `No name was provided for external module '${chunk.id}' in output.globals – guessing '${chunk.variableName}'`,
+            source: chunk.id
         });
-        return module.variableName;
+        return chunk.variableName;
     }
 }
 class Chunk {
-    constructor(orderedModules, inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, manualChunkAlias) {
+    constructor(orderedModules, inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, manualChunkAlias, getPlaceholder, bundle, inputBase, snippets) {
         this.orderedModules = orderedModules;
         this.inputOptions = inputOptions;
         this.outputOptions = outputOptions;
@@ -14382,19 +14496,22 @@ class Chunk {
         this.pluginDriver = pluginDriver;
         this.modulesById = modulesById;
         this.chunkByModule = chunkByModule;
+        this.externalChunkByModule = externalChunkByModule;
         this.facadeChunkByModule = facadeChunkByModule;
         this.includedNamespaces = includedNamespaces;
         this.manualChunkAlias = manualChunkAlias;
+        this.getPlaceholder = getPlaceholder;
+        this.bundle = bundle;
+        this.inputBase = inputBase;
+        this.snippets = snippets;
         this.entryModules = [];
         this.exportMode = 'named';
         this.facadeModule = null;
         this.id = null;
         this.namespaceVariableName = '';
-        this.needsExportsShim = false;
         this.variableName = '';
         this.accessedGlobalsByScope = new Map();
         this.dependencies = new Set();
-        this.dynamicDependencies = new Set();
         this.dynamicEntryModules = [];
         this.dynamicName = null;
         this.exportNamesByVariable = new Map();
@@ -14404,23 +14521,23 @@ class Chunk {
         this.implicitEntryModules = [];
         this.implicitlyLoadedBefore = new Set();
         this.imports = new Set();
+        this.includedDynamicImports = null;
         this.includedReexportsByModule = new Map();
-        this.indentString = undefined;
-        // This may only be updated in the constructor
+        // This may be updated in the constructor
         this.isEmpty = true;
         this.name = null;
+        this.needsExportsShim = false;
+        this.preRenderedChunkInfo = null;
+        this.preliminaryFileName = null;
+        this.renderedChunkInfo = null;
         this.renderedDependencies = null;
-        this.renderedExports = null;
-        this.renderedHash = undefined;
-        this.renderedModuleSources = new Map();
         this.renderedModules = Object.create(null);
-        this.renderedSource = null;
         this.sortedExportNames = null;
         this.strictFacade = false;
-        this.usedModules = undefined;
         this.execIndex = orderedModules.length > 0 ? orderedModules[0].execIndex : Infinity;
         const chunkModules = new Set(orderedModules);
         for (const module of orderedModules) {
+            chunkByModule.set(module, this);
             if (module.namespace.included) {
                 includedNamespaces.add(module);
             }
@@ -14446,14 +14563,16 @@ class Chunk {
         }
         this.suggestedVariableName = makeLegal(this.generateVariableName());
     }
-    static generateFacade(inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, facadedModule, facadeName) {
-        const chunk = new Chunk([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, facadeChunkByModule, includedNamespaces, null);
+    static generateFacade(inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, facadedModule, facadeName, getPlaceholder, bundle, inputBase, snippets) {
+        const chunk = new Chunk([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, null, getPlaceholder, bundle, inputBase, snippets);
         chunk.assignFacadeName(facadeName, facadedModule);
         if (!facadeChunkByModule.has(facadedModule)) {
             facadeChunkByModule.set(facadedModule, chunk);
         }
         for (const dependency of facadedModule.getDependenciesToBeIncluded()) {
-            chunk.dependencies.add(dependency instanceof Module ? chunkByModule.get(dependency) : dependency);
+            chunk.dependencies.add(dependency instanceof Module
+                ? chunkByModule.get(dependency)
+                : externalChunkByModule.get(dependency));
         }
         if (!chunk.dependencies.has(chunkByModule.get(facadedModule)) &&
             facadedModule.info.moduleSideEffects &&
@@ -14554,7 +14673,7 @@ class Chunk {
                 }
             }
             for (const facadeName of requiredFacades) {
-                facades.push(Chunk.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName));
+                facades.push(Chunk.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName, this.getPlaceholder, this.bundle, this.inputBase, this.snippets));
             }
         }
         for (const module of this.dynamicEntryModules) {
@@ -14581,89 +14700,24 @@ class Chunk {
         }
         return facades;
     }
-    generateId(addons, options, existingNames, includeHash) {
-        if (this.fileName !== null) {
-            return this.fileName;
-        }
-        const [pattern, patternName] = this.facadeModule && this.facadeModule.isUserDefinedEntryPoint
-            ? [options.entryFileNames, 'output.entryFileNames']
-            : [options.chunkFileNames, 'output.chunkFileNames'];
-        return makeUnique(renderNamePattern(typeof pattern === 'function' ? pattern(this.getChunkInfo()) : pattern, patternName, {
-            format: () => options.format,
-            hash: () => includeHash
-                ? this.computeContentHashWithDependencies(addons, options, existingNames)
-                : '[hash]',
-            name: () => this.getChunkName()
-        }), existingNames);
-    }
-    generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames, unsetOptions) {
-        const [{ id }] = this.orderedModules;
-        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(sanitizedId)) {
-            const currentDir = dirname(sanitizedId);
-            const extension = extname(sanitizedId);
-            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
-                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
-                ext: () => extension.substring(1),
-                extname: () => extension,
-                format: () => options.format,
-                name: () => this.getChunkName()
-            });
-            const currentPath = `${currentDir}/${fileName}`;
-            const { preserveModulesRoot } = options;
-            if (preserveModulesRoot && currentPath.startsWith(preserveModulesRoot)) {
-                path = currentPath.slice(preserveModulesRoot.length).replace(/^[\\/]/, '');
-            }
-            else {
-                path = relative(preserveModulesRelativeDir, currentPath);
-            }
-        }
-        else {
-            const extension = extname(sanitizedId);
-            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
-                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
-                ext: () => extension.substring(1),
-                extname: () => extension,
-                format: () => options.format,
-                name: () => getAliasName(sanitizedId)
-            });
-            path = `_virtual/${fileName}`;
-        }
-        return makeUnique(normalize(path), existingNames);
-    }
-    getChunkInfo() {
-        const facadeModule = this.facadeModule;
-        const getChunkName = this.getChunkName.bind(this);
+    generateOutputChunk(code, map, hashesByPlaceholder) {
+        const renderedChunkInfo = this.getRenderedChunkInfo();
+        const finalize = (code) => replacePlaceholders(code, hashesByPlaceholder);
         return {
-            exports: this.getExportNames(),
-            facadeModuleId: facadeModule && facadeModule.id,
-            isDynamicEntry: this.dynamicEntryModules.length > 0,
-            isEntry: facadeModule !== null && facadeModule.info.isEntry,
-            isImplicitEntry: this.implicitEntryModules.length > 0,
-            modules: this.renderedModules,
-            get name() {
-                return getChunkName();
-            },
-            type: 'chunk'
+            ...renderedChunkInfo,
+            code,
+            dynamicImports: renderedChunkInfo.dynamicImports.map(finalize),
+            fileName: finalize(renderedChunkInfo.fileName),
+            implicitlyLoadedBefore: renderedChunkInfo.implicitlyLoadedBefore.map(finalize),
+            importedBindings: Object.fromEntries(Object.entries(renderedChunkInfo.importedBindings).map(([fileName, bindings]) => [
+                finalize(fileName),
+                bindings
+            ])),
+            imports: renderedChunkInfo.imports.map(finalize),
+            map,
+            referencedFiles: renderedChunkInfo.referencedFiles.map(finalize)
         };
     }
-    getChunkInfoWithFileNames() {
-        return Object.assign(this.getChunkInfo(), {
-            code: undefined,
-            dynamicImports: Array.from(this.dynamicDependencies, getId),
-            fileName: this.id,
-            implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, getId),
-            importedBindings: this.getImportedBindingsPerDependency(),
-            imports: Array.from(this.dependencies, getId),
-            map: undefined,
-            referencedFiles: this.getReferencedFiles()
-        });
-    }
     getChunkName() {
         var _a;
         return ((_a = this.name) !== null && _a !== void 0 ? _a : (this.name = this.outputOptions.sanitizeFileName(this.getFallbackChunkName())));
@@ -14672,25 +14726,63 @@ class Chunk {
         var _a;
         return ((_a = this.sortedExportNames) !== null && _a !== void 0 ? _a : (this.sortedExportNames = Array.from(this.exportsByName.keys()).sort()));
     }
-    getRenderedHash() {
-        if (this.renderedHash)
-            return this.renderedHash;
-        const hash = createHash();
-        const hashAugmentation = this.pluginDriver.hookReduceValueSync('augmentChunkHash', '', [this.getChunkInfo()], (augmentation, pluginHash) => {
-            if (pluginHash) {
-                augmentation += pluginHash;
+    getFileName() {
+        var _a;
+        return ((_a = this.preliminaryFileName) === null || _a === void 0 ? void 0 : _a.fileName) || this.getPreliminaryFileName().fileName;
+    }
+    getImportPath(importer) {
+        return escapeId(getImportPath(importer, this.getFileName(), this.outputOptions.format === 'amd', true));
+    }
+    getPreliminaryFileName() {
+        if (this.preliminaryFileName) {
+            return this.preliminaryFileName;
+        }
+        let fileName;
+        let hashPlaceholder = null;
+        const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
+        if (file) {
+            fileName = basename(file);
+        }
+        else if (preserveModules) {
+            fileName = this.generateIdPreserveModules();
+        }
+        else if (this.fileName !== null) {
+            fileName = this.fileName;
+        }
+        else {
+            const [pattern, patternName] = this.facadeModule && this.facadeModule.isUserDefinedEntryPoint
+                ? [entryFileNames, 'output.entryFileNames']
+                : [chunkFileNames, 'output.chunkFileNames'];
+            fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
+                format: () => format,
+                hash: size => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size)),
+                name: () => this.getChunkName()
+            });
+            if (!hashPlaceholder) {
+                fileName = makeUnique(fileName, this.bundle);
             }
-            return augmentation;
+        }
+        if (!hashPlaceholder) {
+            this.bundle[fileName] = FILE_PLACEHOLDER;
+        }
+        // Caching is essential to not conflict with the file name reservation above
+        return (this.preliminaryFileName = { fileName, hashPlaceholder });
+    }
+    getRenderedChunkInfo() {
+        if (this.renderedChunkInfo) {
+            return this.renderedChunkInfo;
+        }
+        const resolveFileName = (dependency) => dependency.getFileName();
+        return (this.renderedChunkInfo = {
+            ...this.getPreRenderedChunkInfo(),
+            dynamicImports: this.getDynamicDependencies().map(resolveFileName),
+            fileName: this.getFileName(),
+            implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, resolveFileName),
+            importedBindings: getImportedBindingsPerDependency(this.getRenderedDependencies(), resolveFileName),
+            imports: Array.from(this.dependencies, resolveFileName),
+            modules: this.renderedModules,
+            referencedFiles: this.getReferencedFiles()
         });
-        hash.update(hashAugmentation);
-        hash.update(this.renderedSource.toString());
-        hash.update(this.getExportNames()
-            .map(exportName => {
-            const variable = this.exportsByName.get(exportName);
-            return `${relativeId(variable.module.id).replace(/\\/g, '/')}:${variable.name}:${exportName}`;
-        })
-            .join(','));
-        return (this.renderedHash = hash.digest('hex'));
     }
     getVariableExportName(variable) {
         if (this.outputOptions.preserveModules && variable instanceof NamespaceVariable) {
@@ -14699,225 +14791,67 @@ class Chunk {
         return this.exportNamesByVariable.get(variable)[0];
     }
     link() {
-        this.dependencies = getStaticDependencies(this, this.orderedModules, this.chunkByModule);
+        this.dependencies = getStaticDependencies(this, this.orderedModules, this.chunkByModule, this.externalChunkByModule);
         for (const module of this.orderedModules) {
-            this.addDependenciesToChunk(module.dynamicDependencies, this.dynamicDependencies);
-            this.addDependenciesToChunk(module.implicitlyLoadedBefore, this.implicitlyLoadedBefore);
+            this.addImplicitlyLoadedBeforeFromModule(module);
             this.setUpChunkImportsAndExportsForModule(module);
         }
     }
-    // prerender allows chunk hashes and names to be generated before finalizing
-    preRender(options, inputBase, snippets) {
-        const { _, getPropertyAccess, n } = snippets;
-        const magicString = new Bundle$1({ separator: `${n}${n}` });
-        this.usedModules = [];
-        this.indentString = getIndentString(this.orderedModules, options);
-        const renderOptions = {
-            dynamicImportFunction: options.dynamicImportFunction,
-            exportNamesByVariable: this.exportNamesByVariable,
-            format: options.format,
-            freeze: options.freeze,
-            indent: this.indentString,
-            namespaceToStringTag: options.namespaceToStringTag,
-            outputPluginDriver: this.pluginDriver,
-            snippets
-        };
-        // for static and dynamic entry points, inline the execution list to avoid loading latency
-        if (options.hoistTransitiveImports &&
-            !this.outputOptions.preserveModules &&
-            this.facadeModule !== null) {
-            for (const dep of this.dependencies) {
+    async render() {
+        const { dependencies, exportMode, facadeModule, inputOptions: { onwarn }, outputOptions, pluginDriver, snippets } = this;
+        const { format, hoistTransitiveImports, preserveModules } = outputOptions;
+        // for static and dynamic entry points, add transitive dependencies to this
+        // chunk's dependencies to avoid loading latency
+        if (hoistTransitiveImports && !preserveModules && facadeModule !== null) {
+            for (const dep of dependencies) {
                 if (dep instanceof Chunk)
                     this.inlineChunkDependencies(dep);
             }
         }
-        this.prepareModulesForRendering(snippets);
-        this.setIdentifierRenderResolutions(options);
-        let hoistedSource = '';
-        const renderedModules = this.renderedModules;
-        for (const module of this.orderedModules) {
-            let renderedLength = 0;
-            if (module.isIncluded() || this.includedNamespaces.has(module)) {
-                const source = module.render(renderOptions).trim();
-                renderedLength = source.length();
-                if (renderedLength) {
-                    if (options.compact && source.lastLine().includes('//'))
-                        source.append('\n');
-                    this.renderedModuleSources.set(module, source);
-                    magicString.addSource(source);
-                    this.usedModules.push(module);
-                }
-                const namespace = module.namespace;
-                if (this.includedNamespaces.has(module) && !this.outputOptions.preserveModules) {
-                    const rendered = namespace.renderBlock(renderOptions);
-                    if (namespace.renderFirst())
-                        hoistedSource += n + rendered;
-                    else
-                        magicString.addSource(new MagicString(rendered));
-                }
-            }
-            const { renderedExports, removedExports } = module.getRenderedExports();
-            const { renderedModuleSources } = this;
-            renderedModules[module.id] = {
-                get code() {
-                    var _a, _b;
-                    return (_b = (_a = renderedModuleSources.get(module)) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : null;
-                },
-                originalLength: module.originalCode.length,
-                removedExports,
-                renderedExports,
-                renderedLength
-            };
-        }
-        if (hoistedSource)
-            magicString.prepend(hoistedSource + n + n);
-        if (this.needsExportsShim) {
-            magicString.prepend(`${n}${snippets.cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
-        }
-        if (options.compact) {
-            this.renderedSource = magicString;
-        }
-        else {
-            this.renderedSource = magicString.trim();
-        }
-        this.renderedHash = undefined;
-        if (this.isEmpty && this.getExportNames().length === 0 && this.dependencies.size === 0) {
-            const chunkName = this.getChunkName();
-            this.inputOptions.onwarn({
-                chunkName,
-                code: 'EMPTY_BUNDLE',
-                message: `Generated an empty chunk: "${chunkName}"`
-            });
-        }
-        this.setExternalRenderPaths(options, inputBase);
-        this.renderedDependencies = this.getChunkDependencyDeclarations(options, getPropertyAccess);
-        this.renderedExports =
-            this.exportMode === 'none'
-                ? []
-                : this.getChunkExportDeclarations(options.format, getPropertyAccess);
-    }
-    async render(options, addons, outputChunk, snippets) {
+        const preliminaryFileName = this.getPreliminaryFileName();
+        const { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait } = this.renderModules(preliminaryFileName.fileName);
         timeStart('render format', 2);
-        const format = options.format;
-        const finalise = finalisers[format];
-        if (options.dynamicImportFunction && format !== 'es') {
-            this.inputOptions.onwarn(errInvalidOption('output.dynamicImportFunction', 'outputdynamicImportFunction', 'this option is ignored for formats other than "es"'));
-        }
-        // populate ids in the rendered declarations only here
-        // as chunk ids known only after prerender
-        for (const dependency of this.dependencies) {
-            const renderedDependency = this.renderedDependencies.get(dependency);
-            if (dependency instanceof ExternalModule) {
-                const originalId = dependency.renderPath;
-                renderedDependency.id = escapeId(dependency.renormalizeRenderPath
-                    ? getImportPath(this.id, originalId, false, false)
-                    : originalId);
-            }
-            else {
-                renderedDependency.namedExportsMode = dependency.exportMode !== 'default';
-                renderedDependency.id = escapeId(getImportPath(this.id, dependency.id, false, true));
-            }
-        }
-        this.finaliseDynamicImports(options, snippets);
-        this.finaliseImportMetas(format, snippets);
-        const hasExports = this.renderedExports.length !== 0 ||
-            [...this.renderedDependencies.values()].some(dep => (dep.reexports && dep.reexports.length !== 0));
-        let topLevelAwaitModule = null;
-        const accessedGlobals = new Set();
-        for (const module of this.orderedModules) {
-            if (module.usesTopLevelAwait) {
-                topLevelAwaitModule = module.id;
-            }
-            const accessedGlobalVariables = this.accessedGlobalsByScope.get(module.scope);
-            if (accessedGlobalVariables) {
-                for (const name of accessedGlobalVariables) {
-                    accessedGlobals.add(name);
-                }
-            }
-        }
-        if (topLevelAwaitModule !== null && format !== 'es' && format !== 'system') {
-            return error({
-                code: 'INVALID_TLA_FORMAT',
-                id: topLevelAwaitModule,
-                message: `Module format ${format} does not support top-level await. Use the "es" or "system" output formats rather.`
-            });
-        }
-        /* istanbul ignore next */
-        if (!this.id) {
-            throw new Error('Internal Error: expecting chunk id');
-        }
-        const magicString = finalise(this.renderedSource, {
+        const renderedDependencies = [...this.getRenderedDependencies().values()];
+        const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
+        const hasExports = renderedExports.length !== 0 ||
+            renderedDependencies.some(dep => (dep.reexports && dep.reexports.length !== 0));
+        // TODO Lukas Note: Mention in docs, that users/plugins are responsible to do their own caching
+        // TODO Lukas adapt plugin hook graphs and order in docs
+        const { intro, outro, banner, footer } = await createAddons(outputOptions, pluginDriver, this.getRenderedChunkInfo());
+        finalisers[format](renderedSource, {
             accessedGlobals,
-            dependencies: [...this.renderedDependencies.values()],
-            exports: this.renderedExports,
+            dependencies: renderedDependencies,
+            exports: renderedExports,
             hasExports,
-            id: this.id,
-            indent: this.indentString,
-            intro: addons.intro,
-            isEntryFacade: this.outputOptions.preserveModules ||
-                (this.facadeModule !== null && this.facadeModule.info.isEntry),
-            isModuleFacade: this.facadeModule !== null,
-            namedExportsMode: this.exportMode !== 'default',
-            outro: addons.outro,
+            id: preliminaryFileName.fileName,
+            indent,
+            intro,
+            isEntryFacade: preserveModules || (facadeModule !== null && facadeModule.info.isEntry),
+            isModuleFacade: facadeModule !== null,
+            namedExportsMode: exportMode !== 'default',
+            onwarn,
+            outro,
             snippets,
-            usesTopLevelAwait: topLevelAwaitModule !== null,
-            warn: this.inputOptions.onwarn
-        }, options);
-        if (addons.banner)
-            magicString.prepend(addons.banner);
-        if (addons.footer)
-            magicString.append(addons.footer);
-        const prevCode = magicString.toString();
+            usesTopLevelAwait
+        }, outputOptions);
+        if (banner)
+            magicString.prepend(banner);
+        if (footer)
+            magicString.append(footer);
         timeEnd('render format', 2);
-        let map = null;
-        const chunkSourcemapChain = [];
-        let code = await renderChunk({
-            code: prevCode,
-            options,
-            outputPluginDriver: this.pluginDriver,
-            renderChunk: outputChunk,
-            sourcemapChain: chunkSourcemapChain
-        });
-        if (options.sourcemap) {
-            timeStart('sourcemap', 2);
-            let file;
-            if (options.file)
-                file = resolve(options.sourcemapFile || options.file);
-            else if (options.dir)
-                file = resolve(options.dir, this.id);
-            else
-                file = resolve(this.id);
-            const decodedMap = magicString.generateDecodedMap({});
-            map = collapseSourcemaps(file, decodedMap, this.usedModules, chunkSourcemapChain, options.sourcemapExcludeSources, this.inputOptions.onwarn);
-            map.sources = map.sources
-                .map(sourcePath => {
-                const { sourcemapPathTransform } = options;
-                if (sourcemapPathTransform) {
-                    const newSourcePath = sourcemapPathTransform(sourcePath, `${file}.map`);
-                    if (typeof newSourcePath !== 'string') {
-                        error(errFailedValidation(`sourcemapPathTransform function must return a string.`));
-                    }
-                    return newSourcePath;
-                }
-                return sourcePath;
-            })
-                .map(normalize);
-            timeEnd('sourcemap', 2);
-        }
-        if (!options.compact && code[code.length - 1] !== '\n')
-            code += '\n';
-        return { code, map };
+        return {
+            chunk: this,
+            magicString,
+            preliminaryFileName,
+            usedModules
+        };
     }
-    addDependenciesToChunk(moduleDependencies, chunkDependencies) {
-        for (const module of moduleDependencies) {
-            if (module instanceof Module) {
-                const chunk = this.chunkByModule.get(module);
-                if (chunk && chunk !== this) {
-                    chunkDependencies.add(chunk);
-                }
-            }
-            else {
-                chunkDependencies.add(module);
+    addImplicitlyLoadedBeforeFromModule(baseModule) {
+        const { implicitlyLoadedBefore } = this;
+        for (const module of baseModule.implicitlyLoadedBefore) {
+            const chunk = this.chunkByModule.get(module);
+            if (chunk && chunk !== this) {
+                implicitlyLoadedBefore.add(chunk);
             }
         }
     }
@@ -14955,27 +14889,6 @@ class Chunk {
             } while (alternativeReexportModule);
         }
     }
-    computeContentHashWithDependencies(addons, options, existingNames) {
-        const hash = createHash();
-        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}`);
-            }
-            else {
-                hash.update(current.getRenderedHash());
-                hash.update(current.generateId(addons, options, existingNames, false));
-            }
-            if (current instanceof ExternalModule)
-                continue;
-            for (const dependency of [...current.dependencies, ...current.dynamicDependencies]) {
-                dependenciesForHashing.add(dependency);
-            }
-        }
-        return hash.digest('hex').substr(0, 8);
-    }
     ensureReexportsAreAvailableForModule(module) {
         const includedReexports = [];
         const map = module.getExportNamesByVariable();
@@ -15003,38 +14916,49 @@ class Chunk {
             this.includedReexportsByModule.set(module, includedReexports);
         }
     }
-    finaliseDynamicImports(options, snippets) {
-        const stripKnownJsExtensions = options.format === 'amd';
-        for (const [module, code] of this.renderedModuleSources) {
-            for (const { node, resolution } of module.dynamicImports) {
-                const chunk = this.chunkByModule.get(resolution);
-                const facadeChunk = this.facadeChunkByModule.get(resolution);
-                if (!resolution || !node.included || chunk === this) {
-                    continue;
-                }
-                const renderedResolution = resolution instanceof Module
-                    ? `'${escapeId(getImportPath(this.id, (facadeChunk || chunk).id, stripKnownJsExtensions, true))}'`
-                    : resolution instanceof ExternalModule
-                        ? `'${escapeId(resolution.renormalizeRenderPath
-                            ? getImportPath(this.id, resolution.renderPath, stripKnownJsExtensions, false)
-                            : resolution.renderPath)}'`
-                        : resolution;
-                node.renderFinalResolution(code, renderedResolution, resolution instanceof Module &&
-                    !(facadeChunk === null || facadeChunk === void 0 ? void 0 : facadeChunk.strictFacade) &&
-                    chunk.exportNamesByVariable.get(resolution.namespace)[0], snippets);
-            }
-        }
-    }
-    finaliseImportMetas(format, snippets) {
-        for (const [module, code] of this.renderedModuleSources) {
-            for (const importMeta of module.importMetas) {
-                importMeta.renderFinalMechanism(code, this.id, format, snippets, this.pluginDriver);
-            }
-        }
-    }
-    generateVariableName() {
-        if (this.manualChunkAlias) {
-            return this.manualChunkAlias;
+    generateIdPreserveModules() {
+        const [{ id }] = this.orderedModules;
+        const { entryFileNames, format, preserveModulesRoot, sanitizeFileName } = this.outputOptions;
+        const sanitizedId = sanitizeFileName(id.split(QUERY_HASH_REGEX, 1)[0]);
+        let path;
+        const patternOpt = this.unsetOptions.has('entryFileNames')
+            ? '[name][assetExtname].js'
+            : entryFileNames;
+        const pattern = typeof patternOpt === 'function' ? patternOpt(this.getPreRenderedChunkInfo()) : patternOpt;
+        if (isAbsolute(sanitizedId)) {
+            const currentDir = dirname(sanitizedId);
+            const extension = extname(sanitizedId);
+            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
+                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
+                ext: () => extension.substring(1),
+                extname: () => extension,
+                format: () => format,
+                name: () => this.getChunkName()
+            });
+            const currentPath = `${currentDir}/${fileName}`;
+            if (preserveModulesRoot && currentPath.startsWith(preserveModulesRoot)) {
+                path = currentPath.slice(preserveModulesRoot.length).replace(/^[\\/]/, '');
+            }
+            else {
+                path = relative(this.inputBase, currentPath);
+            }
+        }
+        else {
+            const extension = extname(sanitizedId);
+            const fileName = renderNamePattern(pattern, 'output.entryFileNames', {
+                assetExtname: () => (NON_ASSET_EXTENSIONS.includes(extension) ? '' : extension),
+                ext: () => extension.substring(1),
+                extname: () => extension,
+                format: () => format,
+                name: () => getAliasName(sanitizedId)
+            });
+            path = `_virtual/${fileName}`;
+        }
+        return makeUnique(normalize(path), this.bundle);
+    }
+    generateVariableName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
         }
         const moduleForNaming = this.entryModules[0] ||
             this.implicitEntryModules[0] ||
@@ -15045,31 +14969,7 @@ class Chunk {
         }
         return 'chunk';
     }
-    getChunkDependencyDeclarations(options, getPropertyAccess) {
-        const importSpecifiers = this.getImportSpecifiers(getPropertyAccess);
-        const reexportSpecifiers = this.getReexportSpecifiers();
-        const dependencyDeclaration = new Map();
-        for (const dep of this.dependencies) {
-            const imports = importSpecifiers.get(dep) || null;
-            const reexports = reexportSpecifiers.get(dep) || null;
-            const namedExportsMode = dep instanceof ExternalModule || dep.exportMode !== 'default';
-            dependencyDeclaration.set(dep, {
-                defaultVariableName: dep.defaultVariableName,
-                globalName: (dep instanceof ExternalModule &&
-                    (options.format === 'umd' || options.format === 'iife') &&
-                    getGlobalName(dep, options.globals, (imports || reexports) !== null, this.inputOptions.onwarn)),
-                id: undefined,
-                imports,
-                isChunk: dep instanceof Chunk,
-                name: dep.variableName,
-                namedExportsMode,
-                namespaceVariableName: dep.namespaceVariableName,
-                reexports
-            });
-        }
-        return dependencyDeclaration;
-    }
-    getChunkExportDeclarations(format, getPropertyAccess) {
+    getChunkExportDeclarations(format) {
         const exports = [];
         for (const exportName of this.getExportNames()) {
             if (exportName[0] === '*')
@@ -15082,7 +14982,7 @@ class Chunk {
             }
             let expression = null;
             let hoisted = false;
-            let local = variable.getName(getPropertyAccess);
+            let local = variable.getName(this.snippets.getPropertyAccess);
             if (variable instanceof LocalVariable) {
                 for (const declaration of variable.declarations) {
                     if (declaration.parent instanceof FunctionDeclaration ||
@@ -15116,16 +15016,17 @@ class Chunk {
             if (addNonNamespacesAndInteropHelpers || variable.isNamespace) {
                 const module = variable.module;
                 if (module instanceof ExternalModule) {
-                    dependencies.add(module);
+                    const chunk = this.externalChunkByModule.get(module);
+                    dependencies.add(chunk);
                     if (addNonNamespacesAndInteropHelpers) {
                         if (variable.name === 'default') {
                             if (defaultInteropHelpersByInteropType[String(interop(module.id))]) {
-                                deconflictedDefault.add(module);
+                                deconflictedDefault.add(chunk);
                             }
                         }
                         else if (variable.name === '*') {
                             if (namespaceInteropHelpersByInteropType[String(interop(module.id))]) {
-                                deconflictedNamespace.add(module);
+                                deconflictedNamespace.add(chunk);
                             }
                         }
                     }
@@ -15150,6 +15051,15 @@ class Chunk {
         }
         return { deconflictedDefault, deconflictedNamespace, dependencies };
     }
+    getDynamicDependencies() {
+        return this.getIncludedDynamicImports()
+            .map(resolvedDynamicImport => resolvedDynamicImport.facadeChunk ||
+            resolvedDynamicImport.chunk ||
+            resolvedDynamicImport.externalChunk ||
+            resolvedDynamicImport.resolution)
+            .filter((resolution) => resolution !== this &&
+            (resolution instanceof Chunk || resolution instanceof ExternalChunk));
+    }
     getFallbackChunkName() {
         if (this.manualChunkAlias) {
             return this.manualChunkAlias;
@@ -15162,7 +15072,7 @@ class Chunk {
         }
         return getAliasName(this.orderedModules[this.orderedModules.length - 1].id);
     }
-    getImportSpecifiers(getPropertyAccess) {
+    getImportSpecifiers() {
         const { interop } = this.outputOptions;
         const importsByDependency = new Map();
         for (const variable of this.imports) {
@@ -15170,7 +15080,7 @@ class Chunk {
             let dependency;
             let imported;
             if (module instanceof ExternalModule) {
-                dependency = module;
+                dependency = this.externalChunkByModule.get(module);
                 imported = variable.name;
                 if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
                     return error(errUnexpectedNamedImport(module.id, imported, false));
@@ -15182,28 +15092,57 @@ class Chunk {
             }
             getOrCreate(importsByDependency, dependency, () => []).push({
                 imported,
-                local: variable.getName(getPropertyAccess)
+                local: variable.getName(this.snippets.getPropertyAccess)
             });
         }
         return importsByDependency;
     }
-    getImportedBindingsPerDependency() {
-        const importSpecifiers = {};
-        for (const [dependency, declaration] of this.renderedDependencies) {
-            const specifiers = new Set();
-            if (declaration.imports) {
-                for (const { imported } of declaration.imports) {
-                    specifiers.add(imported);
-                }
-            }
-            if (declaration.reexports) {
-                for (const { imported } of declaration.reexports) {
-                    specifiers.add(imported);
+    getIncludedDynamicImports() {
+        if (this.includedDynamicImports) {
+            return this.includedDynamicImports;
+        }
+        const includedDynamicImports = [];
+        for (const module of this.orderedModules) {
+            for (const { node, resolution } of module.dynamicImports) {
+                if (!node.included) {
+                    continue;
                 }
+                includedDynamicImports.push(resolution instanceof Module
+                    ? {
+                        chunk: this.chunkByModule.get(resolution),
+                        externalChunk: null,
+                        facadeChunk: this.facadeChunkByModule.get(resolution),
+                        node,
+                        resolution
+                    }
+                    : resolution instanceof ExternalModule
+                        ? {
+                            chunk: null,
+                            externalChunk: this.externalChunkByModule.get(resolution),
+                            facadeChunk: null,
+                            node,
+                            resolution
+                        }
+                        : { chunk: null, externalChunk: null, facadeChunk: null, node, resolution });
             }
-            importSpecifiers[dependency.id] = [...specifiers];
         }
-        return importSpecifiers;
+        return (this.includedDynamicImports = includedDynamicImports);
+    }
+    getPreRenderedChunkInfo() {
+        if (this.preRenderedChunkInfo) {
+            return this.preRenderedChunkInfo;
+        }
+        const { facadeModule } = this;
+        return (this.preRenderedChunkInfo = {
+            exports: this.getExportNames(),
+            facadeModuleId: facadeModule && facadeModule.id,
+            isDynamicEntry: this.dynamicEntryModules.length > 0,
+            isEntry: !!(facadeModule === null || facadeModule === void 0 ? void 0 : facadeModule.info.isEntry),
+            isImplicitEntry: this.implicitEntryModules.length > 0,
+            moduleIds: this.orderedModules.map(({ id }) => id),
+            name: this.getChunkName(),
+            type: 'chunk'
+        });
     }
     getReexportSpecifiers() {
         const { externalLiveBindings, interop } = this.outputOptions;
@@ -15218,7 +15157,7 @@ class Chunk {
                     this.inputOptions.onwarn(errUnexpectedNamespaceReexport(id));
                 }
                 needsLiveBinding = externalLiveBindings;
-                dependency = this.modulesById.get(id);
+                dependency = this.externalChunkByModule.get(this.modulesById.get(id));
                 imported = exportName = '*';
             }
             else {
@@ -15234,7 +15173,7 @@ class Chunk {
                     needsLiveBinding = variable.isReassigned;
                 }
                 else {
-                    dependency = module;
+                    dependency = this.externalChunkByModule.get(module);
                     imported = variable.name;
                     if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
                         return error(errUnexpectedNamedImport(module.id, imported, true));
@@ -15253,16 +15192,45 @@ class Chunk {
         return reexportSpecifiers;
     }
     getReferencedFiles() {
-        const referencedFiles = [];
+        const referencedFiles = new Set();
         for (const module of this.orderedModules) {
             for (const meta of module.importMetas) {
                 const fileName = meta.getReferencedFileName(this.pluginDriver);
                 if (fileName) {
-                    referencedFiles.push(fileName);
+                    referencedFiles.add(fileName);
                 }
             }
         }
-        return referencedFiles;
+        return [...referencedFiles];
+    }
+    getRenderedDependencies() {
+        if (this.renderedDependencies) {
+            return this.renderedDependencies;
+        }
+        const importSpecifiers = this.getImportSpecifiers();
+        const reexportSpecifiers = this.getReexportSpecifiers();
+        const renderedDependencies = new Map();
+        const fileName = this.getFileName();
+        for (const dep of this.dependencies) {
+            const imports = importSpecifiers.get(dep) || null;
+            const reexports = reexportSpecifiers.get(dep) || null;
+            const namedExportsMode = dep instanceof ExternalChunk || dep.exportMode !== 'default';
+            const importPath = dep.getImportPath(fileName);
+            renderedDependencies.set(dep, {
+                defaultVariableName: dep.defaultVariableName,
+                globalName: dep instanceof ExternalChunk &&
+                    (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
+                    getGlobalName(dep, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onwarn),
+                importPath,
+                imports,
+                isChunk: dep instanceof Chunk,
+                name: dep.variableName,
+                namedExportsMode,
+                namespaceVariableName: dep.namespaceVariableName,
+                reexports
+            });
+        }
+        return (this.renderedDependencies = renderedDependencies);
     }
     inlineChunkDependencies(chunk) {
         for (const dep of chunk.dependencies) {
@@ -15274,42 +15242,111 @@ class Chunk {
             }
         }
     }
-    prepareModulesForRendering(snippets) {
-        var _a;
-        const accessedGlobalsByScope = this.accessedGlobalsByScope;
-        for (const module of this.orderedModules) {
-            for (const { node, resolution } of module.dynamicImports) {
-                if (node.included) {
-                    if (resolution instanceof Module) {
-                        const chunk = this.chunkByModule.get(resolution);
-                        if (chunk === this) {
-                            node.setInternalResolution(resolution.namespace);
-                        }
-                        else {
-                            node.setExternalResolution(((_a = this.facadeChunkByModule.get(resolution)) === null || _a === void 0 ? void 0 : _a.exportMode) || chunk.exportMode, resolution, this.outputOptions, snippets, this.pluginDriver, accessedGlobalsByScope);
-                        }
-                    }
-                    else {
-                        node.setExternalResolution('external', resolution, this.outputOptions, snippets, this.pluginDriver, accessedGlobalsByScope);
+    // 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 { compact, dynamicImportFunction, format, freeze, namespaceToStringTag, preserveModules } = outputOptions;
+        const { _, n } = snippets;
+        this.setDynamicImportResolutions(fileName);
+        this.setImportMetaResolutions(fileName);
+        this.setIdentifierRenderResolutions();
+        const magicString = new Bundle$1({ separator: `${n}${n}` });
+        const indent = getIndentString(orderedModules, outputOptions);
+        const usedModules = [];
+        let hoistedSource = '';
+        const accessedGlobals = new Set();
+        const renderedModuleSources = new Map();
+        const renderOptions = {
+            dynamicImportFunction,
+            exportNamesByVariable,
+            format,
+            freeze,
+            indent,
+            namespaceToStringTag,
+            pluginDriver,
+            snippets
+        };
+        let usesTopLevelAwait = false;
+        for (const module of orderedModules) {
+            let renderedLength = 0;
+            let source;
+            if (module.isIncluded() || includedNamespaces.has(module)) {
+                const rendered = module.render(renderOptions);
+                ({ source } = rendered);
+                usesTopLevelAwait || (usesTopLevelAwait = rendered.usesTopLevelAwait);
+                renderedLength = source.length();
+                if (renderedLength) {
+                    if (compact && source.lastLine().includes('//'))
+                        source.append('\n');
+                    renderedModuleSources.set(module, source);
+                    magicString.addSource(source);
+                    usedModules.push(module);
+                }
+                const namespace = module.namespace;
+                if (includedNamespaces.has(module) && !preserveModules) {
+                    const rendered = namespace.renderBlock(renderOptions);
+                    if (namespace.renderFirst())
+                        hoistedSource += n + rendered;
+                    else
+                        magicString.addSource(new MagicString(rendered));
+                }
+                const accessedGlobalVariables = this.accessedGlobalsByScope.get(module.scope);
+                if (accessedGlobalVariables) {
+                    for (const name of accessedGlobalVariables) {
+                        accessedGlobals.add(name);
                     }
                 }
             }
-            for (const importMeta of module.importMetas) {
-                importMeta.addAccessedGlobals(this.outputOptions.format, accessedGlobalsByScope);
-            }
-            if (this.includedNamespaces.has(module) && !this.outputOptions.preserveModules) {
-                module.namespace.prepare(accessedGlobalsByScope);
-            }
+            const { renderedExports, removedExports } = module.getRenderedExports();
+            renderedModules[module.id] = {
+                get code() {
+                    var _a;
+                    return (_a = source === null || source === void 0 ? void 0 : source.toString()) !== null && _a !== void 0 ? _a : null;
+                },
+                originalLength: module.originalCode.length,
+                removedExports,
+                renderedExports,
+                renderedLength
+            };
+        }
+        if (hoistedSource)
+            magicString.prepend(hoistedSource + n + n);
+        if (this.needsExportsShim) {
+            magicString.prepend(`${n}${snippets.cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
+        }
+        const renderedSource = compact ? magicString : magicString.trim();
+        if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
+            const chunkName = this.getChunkName();
+            onwarn({
+                chunkName,
+                code: 'EMPTY_BUNDLE',
+                message: `Generated an empty chunk: "${chunkName}"`
+            });
         }
+        return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
     }
-    setExternalRenderPaths(options, inputBase) {
-        for (const dependency of [...this.dependencies, ...this.dynamicDependencies]) {
-            if (dependency instanceof ExternalModule) {
-                dependency.setRenderPath(options, inputBase);
+    setDynamicImportResolutions(fileName) {
+        const { accessedGlobalsByScope, outputOptions, pluginDriver, snippets } = this;
+        for (const resolvedDynamicImport of this.getIncludedDynamicImports()) {
+            if (resolvedDynamicImport.chunk) {
+                const { chunk, facadeChunk, node, resolution } = resolvedDynamicImport;
+                if (chunk === this) {
+                    node.setInternalResolution(resolution.namespace);
+                }
+                else {
+                    node.setExternalResolution((facadeChunk || chunk).exportMode, resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, `'${(facadeChunk || chunk).getImportPath(fileName)}'`, !(facadeChunk === null || facadeChunk === void 0 ? void 0 : facadeChunk.strictFacade) && chunk.exportNamesByVariable.get(resolution.namespace)[0]);
+                }
+            }
+            else {
+                const { resolution } = resolvedDynamicImport;
+                resolvedDynamicImport.node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolution instanceof ExternalModule
+                    ? `'${this.externalChunkByModule.get(resolution).getImportPath(fileName)}'`
+                    : resolution || '', false);
             }
         }
     }
-    setIdentifierRenderResolutions({ format, interop, namespaceToStringTag }) {
+    setIdentifierRenderResolutions() {
+        const { format, interop, namespaceToStringTag } = this.outputOptions;
         const syntheticExports = new Set();
         for (const exportName of this.getExportNames()) {
             const exportVariable = this.exportsByName.get(exportName);
@@ -15354,7 +15391,18 @@ class Chunk {
                     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, 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, this.outputOptions.preserveModules, this.outputOptions.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) {
+            for (const importMeta of module.importMetas) {
+                importMeta.setResolution(format, accessedGlobalsByScope, fileName);
+            }
+            if (includedNamespaces.has(module) && !preserveModules) {
+                module.namespace.prepare(accessedGlobalsByScope);
+            }
+        }
     }
     setUpChunkImportsAndExportsForModule(module) {
         const moduleImports = new Set(module.includedImports);
@@ -15405,546 +15453,646 @@ function getChunkNameFromModule(module) {
     var _a, _b, _c, _d;
     return ((_d = (_b = (_a = module.chunkNames.find(({ isUserDefined }) => isUserDefined)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = module.chunkNames[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : getAliasName(module.id));
 }
-const QUERY_HASH_REGEX = /[?#]/;
-
-function generateAssetFileName(name, source, outputOptions, bundle) {
-    const emittedName = outputOptions.sanitizeFileName(name || 'asset');
-    return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
-        ? outputOptions.assetFileNames({ name, source, type: 'asset' })
-        : outputOptions.assetFileNames, 'output.assetFileNames', {
-        ext: () => extname(emittedName).substring(1),
-        extname: () => extname(emittedName),
-        hash() {
-            return createHash()
-                .update(emittedName)
-                .update(':')
-                .update(source)
-                .digest('hex')
-                .substring(0, 8);
-        },
-        name: () => emittedName.substring(0, emittedName.length - extname(emittedName).length)
-    }), bundle);
-}
-function reserveFileNameInBundle(fileName, bundle, warn) {
-    if (fileName in bundle) {
-        warn(errFileNameConflict(fileName));
+function getImportedBindingsPerDependency(renderedDependencies, resolveFileName) {
+    const importedBindingsPerDependency = {};
+    for (const [dependency, declaration] of renderedDependencies) {
+        const specifiers = new Set();
+        if (declaration.imports) {
+            for (const { imported } of declaration.imports) {
+                specifiers.add(imported);
+            }
+        }
+        if (declaration.reexports) {
+            for (const { imported } of declaration.reexports) {
+                specifiers.add(imported);
+            }
+        }
+        importedBindingsPerDependency[resolveFileName(dependency)] = [...specifiers];
     }
-    bundle[fileName] = FILE_PLACEHOLDER;
-}
-const FILE_PLACEHOLDER = {
-    type: 'placeholder'
-};
-function hasValidType(emittedFile) {
-    return Boolean(emittedFile &&
-        (emittedFile.type === 'asset' ||
-            emittedFile.type === 'chunk'));
+    return importedBindingsPerDependency;
 }
-function hasValidName(emittedFile) {
-    const validatedName = emittedFile.fileName || emittedFile.name;
-    return !validatedName || (typeof validatedName === 'string' && !isPathFragment(validatedName));
-}
-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.`));
+const QUERY_HASH_REGEX = /[?#]/;
+
+function getChunkAssignments(entryModules, manualChunkAliasByEntry) {
+    const chunkDefinitions = [];
+    const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
+    const manualChunkModulesByAlias = Object.create(null);
+    for (const [entry, alias] of manualChunkAliasByEntry) {
+        const chunkModules = (manualChunkModulesByAlias[alias] =
+            manualChunkModulesByAlias[alias] || []);
+        addStaticDependenciesToManualChunk(entry, chunkModules, modulesInManualChunks);
     }
-    return source;
-}
-function getAssetFileName(file, referenceId) {
-    if (typeof file.fileName !== 'string') {
-        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
+    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
+        chunkDefinitions.push({ alias, modules });
     }
-    return file.fileName;
-}
-function getChunkFileName(file, facadeChunkByModule) {
-    var _a;
-    const fileName = file.fileName || (file.module && ((_a = facadeChunkByModule === null || facadeChunkByModule === void 0 ? void 0 : facadeChunkByModule.get(file.module)) === null || _a === void 0 ? void 0 : _a.id));
-    if (!fileName)
-        return error(errChunkNotGeneratedForFileName(file.fileName || file.name));
-    return fileName;
-}
-class FileEmitter {
-    constructor(graph, options, baseFileEmitter) {
-        this.graph = graph;
-        this.options = options;
-        this.bundle = null;
-        this.facadeChunkByModule = null;
-        this.outputOptions = null;
-        this.assertAssetsFinalized = () => {
-            for (const [referenceId, emittedFile] of this.filesByReferenceId) {
-                if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
-                    return error(errNoAssetSourceSet(emittedFile.name || referenceId));
+    const assignedEntryPointsByModule = new Map();
+    const { dependentEntryPointsByModule, dynamicEntryModules } = analyzeModuleGraph(entryModules);
+    const dynamicallyDependentEntryPointsByDynamicEntry = getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules);
+    const staticEntries = new Set(entryModules);
+    function assignEntryToStaticDependencies(entry, dynamicDependentEntryPoints) {
+        const modulesToHandle = new Set([entry]);
+        for (const module of modulesToHandle) {
+            const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
+            if (dynamicDependentEntryPoints &&
+                areEntryPointsContainedOrDynamicallyDependent(dynamicDependentEntryPoints, dependentEntryPointsByModule.get(module))) {
+                continue;
             }
-        };
-        this.emitFile = (emittedFile) => {
-            if (!hasValidType(emittedFile)) {
-                return error(errFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
+            else {
+                assignedEntryPoints.add(entry);
             }
-            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}".`));
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                    modulesToHandle.add(dependency);
+                }
             }
-            if (emittedFile.type === 'chunk') {
-                return this.emitChunk(emittedFile);
+        }
+    }
+    function areEntryPointsContainedOrDynamicallyDependent(entryPoints, containedIn) {
+        const entriesToCheck = new Set(entryPoints);
+        for (const entry of entriesToCheck) {
+            if (!containedIn.has(entry)) {
+                if (staticEntries.has(entry))
+                    return false;
+                const dynamicallyDependentEntryPoints = dynamicallyDependentEntryPointsByDynamicEntry.get(entry);
+                for (const dependentEntry of dynamicallyDependentEntryPoints) {
+                    entriesToCheck.add(dependentEntry);
+                }
             }
-            return this.emitAsset(emittedFile);
-        };
-        this.getFileName = (fileReferenceId) => {
-            const emittedFile = this.filesByReferenceId.get(fileReferenceId);
-            if (!emittedFile)
-                return error(errFileReferenceIdNotFoundForFilename(fileReferenceId));
-            if (emittedFile.type === 'chunk') {
-                return getChunkFileName(emittedFile, this.facadeChunkByModule);
-            }
-            return getAssetFileName(emittedFile, fileReferenceId);
-        };
-        this.setAssetSource = (referenceId, requestedSource) => {
-            const consumedFile = this.filesByReferenceId.get(referenceId);
-            if (!consumedFile)
-                return error(errAssetReferenceIdNotFoundForSetSource(referenceId));
-            if (consumedFile.type !== 'asset') {
-                return error(errFailedValidation(`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));
-            }
-            const source = getValidSource(requestedSource, consumedFile, referenceId);
-            if (this.bundle) {
-                this.finalizeAsset(consumedFile, source, referenceId, this.bundle);
-            }
-            else {
-                consumedFile.source = source;
+        }
+        return true;
+    }
+    for (const entry of entryModules) {
+        if (!modulesInManualChunks.has(entry)) {
+            assignEntryToStaticDependencies(entry, null);
+        }
+    }
+    for (const entry of dynamicEntryModules) {
+        if (!modulesInManualChunks.has(entry)) {
+            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
+        }
+    }
+    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule));
+    return chunkDefinitions;
+}
+function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        modulesInManualChunks.add(module);
+        manualChunkModules.push(module);
+        for (const dependency of module.dependencies) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
             }
-        };
-        this.setOutputBundle = (outputBundle, outputOptions, facadeChunkByModule) => {
-            this.outputOptions = outputOptions;
-            this.bundle = outputBundle;
-            this.facadeChunkByModule = facadeChunkByModule;
-            for (const emittedFile of this.filesByReferenceId.values()) {
-                if (emittedFile.fileName) {
-                    reserveFileNameInBundle(emittedFile.fileName, this.bundle, this.options.onwarn);
+        }
+    }
+}
+function analyzeModuleGraph(entryModules) {
+    const dynamicEntryModules = new Set();
+    const dependentEntryPointsByModule = new Map();
+    const entriesToHandle = new Set(entryModules);
+    for (const currentEntry of entriesToHandle) {
+        const modulesToHandle = new Set([currentEntry]);
+        for (const module of modulesToHandle) {
+            getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    modulesToHandle.add(dependency);
                 }
             }
-            for (const [referenceId, consumedFile] of this.filesByReferenceId) {
-                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
-                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, this.bundle);
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
+                    dynamicEntryModules.add(resolution);
+                    entriesToHandle.add(resolution);
                 }
             }
-        };
-        this.filesByReferenceId = baseFileEmitter
-            ? new Map(baseFileEmitter.filesByReferenceId)
-            : new Map();
-    }
-    assignReferenceId(file, idBase) {
-        let referenceId;
-        do {
-            referenceId = createHash()
-                .update(referenceId || idBase)
-                .digest('hex')
-                .substring(0, 8);
-        } while (this.filesByReferenceId.has(referenceId));
-        this.filesByReferenceId.set(referenceId, file);
-        return referenceId;
-    }
-    emitAsset(emittedAsset) {
-        const source = typeof emittedAsset.source !== 'undefined'
-            ? getValidSource(emittedAsset.source, emittedAsset, null)
-            : undefined;
-        const consumedAsset = {
-            fileName: emittedAsset.fileName,
-            name: emittedAsset.name,
-            source,
-            type: 'asset'
-        };
-        const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || emittedAsset.type);
-        if (this.bundle) {
-            if (emittedAsset.fileName) {
-                reserveFileNameInBundle(emittedAsset.fileName, this.bundle, this.options.onwarn);
+            for (const dependency of module.implicitlyLoadedBefore) {
+                dynamicEntryModules.add(dependency);
+                entriesToHandle.add(dependency);
             }
-            if (source !== undefined) {
-                this.finalizeAsset(consumedAsset, source, referenceId, this.bundle);
+        }
+    }
+    return { dependentEntryPointsByModule, dynamicEntryModules };
+}
+function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
+    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
+    for (const dynamicEntry of dynamicEntryModules) {
+        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
+        for (const importer of [
+            ...dynamicEntry.includedDynamicImporters,
+            ...dynamicEntry.implicitlyLoadedAfter
+        ]) {
+            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
+                dynamicDependentEntryPoints.add(entryPoint);
             }
         }
-        return referenceId;
     }
-    emitChunk(emittedChunk) {
-        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
-            return error(errInvalidRollupPhaseForChunkEmission());
+    return dynamicallyDependentEntryPointsByDynamicEntry;
+}
+function createChunks(allEntryPoints, assignedEntryPointsByModule) {
+    const chunkModules = Object.create(null);
+    for (const [module, assignedEntryPoints] of assignedEntryPointsByModule) {
+        let chunkSignature = '';
+        for (const entry of allEntryPoints) {
+            chunkSignature += assignedEntryPoints.has(entry) ? 'X' : '_';
         }
-        if (typeof emittedChunk.id !== 'string') {
-            return error(errFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+        const chunk = chunkModules[chunkSignature];
+        if (chunk) {
+            chunk.push(module);
+        }
+        else {
+            chunkModules[chunkSignature] = [module];
         }
-        const consumedChunk = {
-            fileName: emittedChunk.fileName,
-            module: null,
-            name: emittedChunk.name || emittedChunk.id,
-            type: 'chunk'
-        };
-        this.graph.moduleLoader
-            .emitChunk(emittedChunk)
-            .then(module => (consumedChunk.module = module))
-            .catch(() => {
-            // Avoid unhandled Promise rejection as the error will be thrown later
-            // once module loading has finished
-        });
-        return this.assignReferenceId(consumedChunk, emittedChunk.id);
-    }
-    finalizeAsset(consumedFile, source, referenceId, bundle) {
-        const fileName = consumedFile.fileName ||
-            findExistingAssetFileNameWithSource(bundle, source) ||
-            generateAssetFileName(consumedFile.name, source, this.outputOptions, bundle);
-        // We must not modify the original assets to avoid interaction between outputs
-        const assetWithFileName = { ...consumedFile, fileName, source };
-        this.filesByReferenceId.set(referenceId, assetWithFileName);
-        const { options } = this;
-        bundle[fileName] = {
-            fileName,
-            get isAsset() {
-                warnDeprecation('Accessing "isAsset" on files in the bundle is deprecated, please use "type === \'asset\'" instead', true, options);
-                return true;
-            },
-            name: consumedFile.name,
-            source,
-            type: 'asset'
-        };
     }
+    return Object.values(chunkModules).map(modules => ({
+        alias: null,
+        modules
+    }));
 }
-function findExistingAssetFileNameWithSource(bundle, source) {
-    for (const [fileName, outputFile] of Object.entries(bundle)) {
-        if (outputFile.type === 'asset' && areSourcesEqual(source, outputFile.source))
-            return fileName;
-    }
-    return null;
+
+// ported from https://github.com/substack/node-commondir
+function commondir(files) {
+    if (files.length === 0)
+        return '/';
+    if (files.length === 1)
+        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++)
+            ;
+        return commonSegments.slice(0, i);
+    }, files[0].split(/\/+|\\+/));
+    // Windows correctly handles paths with forward-slashes
+    return commonSegments.length > 1 ? commonSegments.join('/') : '/';
 }
-function areSourcesEqual(sourceA, sourceB) {
-    if (typeof sourceA === 'string') {
-        return sourceA === sourceB;
-    }
-    if (typeof sourceB === 'string') {
-        return false;
+
+const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
+function sortByExecutionOrder(units) {
+    units.sort(compareExecIndex);
+}
+function analyseModuleExecution(entryModules) {
+    let nextExecIndex = 0;
+    const cyclePaths = [];
+    const analysedModules = new Set();
+    const dynamicImports = new Set();
+    const parents = new Map();
+    const orderedModules = [];
+    const analyseModule = (module) => {
+        if (module instanceof Module) {
+            for (const dependency of module.dependencies) {
+                if (parents.has(dependency)) {
+                    if (!analysedModules.has(dependency)) {
+                        cyclePaths.push(getCyclePath(dependency, module, parents));
+                    }
+                    continue;
+                }
+                parents.set(dependency, module);
+                analyseModule(dependency);
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                dynamicImports.add(dependency);
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module) {
+                    dynamicImports.add(resolution);
+                }
+            }
+            orderedModules.push(module);
+        }
+        module.execIndex = nextExecIndex++;
+        analysedModules.add(module);
+    };
+    for (const curEntry of entryModules) {
+        if (!parents.has(curEntry)) {
+            parents.set(curEntry, null);
+            analyseModule(curEntry);
+        }
     }
-    if ('equals' in sourceA) {
-        return sourceA.equals(sourceB);
+    for (const curEntry of dynamicImports) {
+        if (!parents.has(curEntry)) {
+            parents.set(curEntry, null);
+            analyseModule(curEntry);
+        }
     }
-    if (sourceA.length !== sourceB.length) {
-        return false;
+    return { cyclePaths, orderedModules };
+}
+function getCyclePath(module, parent, parents) {
+    const cycleSymbol = Symbol(module.id);
+    const path = [relativeId(module.id)];
+    let nextModule = parent;
+    module.cycles.add(cycleSymbol);
+    while (nextModule !== module) {
+        nextModule.cycles.add(cycleSymbol);
+        path.push(relativeId(nextModule.id));
+        nextModule = parents.get(nextModule);
     }
-    for (let index = 0; index < sourceA.length; index++) {
-        if (sourceA[index] !== sourceB[index]) {
-            return false;
+    path.push(path[0]);
+    path.reverse();
+    return path;
+}
+
+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 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(`,${_}`)})`}${_}=>${_}`;
         }
-    }
-    return true;
+        : getNonArrowFunctionIntro;
+    const getDirectReturnFunction = (params, { functionReturn, lineBreakIndent, name }) => [
+        `${getFunctionIntro(params, {
+            isAsync: false,
+            name
+        })}${arrowFunctions
+            ? lineBreakIndent
+                ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}`
+                : ''
+            : `{${lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _}${functionReturn ? 'return ' : ''}`}`,
+        arrowFunctions
+            ? `${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);
+    return {
+        _,
+        cnst,
+        getDirectReturnFunction,
+        getDirectReturnIifeLeft: (params, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
+            const [left, right] = getDirectReturnFunction(params, {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: null
+            });
+            return `${wrapIfNeeded(`${left}${wrapIfNeeded(returned, arrowFunctions && needsArrowReturnParens)}${right}`, arrowFunctions || needsWrappedFunction)}(`;
+        },
+        getFunctionIntro,
+        getNonArrowFunctionIntro,
+        getObject(fields, { lineBreakIndent }) {
+            const prefix = lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _;
+            return `{${fields
+                .map(([key, value]) => {
+                if (key === null)
+                    return `${prefix}${value}`;
+                const needsQuotes = !isValidPropName(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)}]`,
+        n,
+        s
+    };
 }
+const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
+const validPropName = /^(?!\d)[\w$]+$/;
 
-const concatSep = (out, next) => (next ? `${out}\n${next}` : out);
-const concatDblSep = (out, next) => (next ? `${out}\n\n${next}` : out);
-async function createAddons(options, outputPluginDriver) {
-    try {
-        let [banner, footer, intro, outro] = await Promise.all([
-            outputPluginDriver.hookReduceValue('banner', options.banner(), [], concatSep),
-            outputPluginDriver.hookReduceValue('footer', options.footer(), [], concatSep),
-            outputPluginDriver.hookReduceValue('intro', options.intro(), [], concatDblSep),
-            outputPluginDriver.hookReduceValue('outro', options.outro(), [], concatDblSep)
-        ]);
-        if (intro)
-            intro += '\n\n';
-        if (outro)
-            outro = `\n\n${outro}`;
-        if (banner.length)
-            banner += '\n';
-        if (footer.length)
-            footer = '\n' + footer;
-        return { banner, footer, intro, outro };
+class Source {
+    constructor(filename, content) {
+        this.isOriginal = true;
+        this.filename = filename;
+        this.content = content;
     }
-    catch (err) {
-        return error({
-            code: 'ADDON_ERROR',
-            message: `Could not retrieve ${err.hook}. Check configuration of plugin ${err.plugin}.
-\tError Message: ${err.message}`
-        });
+    traceSegment(line, column, name) {
+        return { column, line, name, source: this };
     }
 }
-
-function getChunkAssignments(entryModules, manualChunkAliasByEntry) {
-    const chunkDefinitions = [];
-    const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
-    const manualChunkModulesByAlias = Object.create(null);
-    for (const [entry, alias] of manualChunkAliasByEntry) {
-        const chunkModules = (manualChunkModulesByAlias[alias] =
-            manualChunkModulesByAlias[alias] || []);
-        addStaticDependenciesToManualChunk(entry, chunkModules, modulesInManualChunks);
-    }
-    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
-        chunkDefinitions.push({ alias, modules });
+class Link {
+    constructor(map, sources) {
+        this.sources = sources;
+        this.names = map.names;
+        this.mappings = map.mappings;
     }
-    const assignedEntryPointsByModule = new Map();
-    const { dependentEntryPointsByModule, dynamicEntryModules } = analyzeModuleGraph(entryModules);
-    const dynamicallyDependentEntryPointsByDynamicEntry = getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules);
-    const staticEntries = new Set(entryModules);
-    function assignEntryToStaticDependencies(entry, dynamicDependentEntryPoints) {
-        const modulesToHandle = new Set([entry]);
-        for (const module of modulesToHandle) {
-            const assignedEntryPoints = getOrCreate(assignedEntryPointsByModule, module, () => new Set());
-            if (dynamicDependentEntryPoints &&
-                areEntryPointsContainedOrDynamicallyDependent(dynamicDependentEntryPoints, dependentEntryPointsByModule.get(module))) {
-                continue;
-            }
-            else {
-                assignedEntryPoints.add(entry);
-            }
-            for (const dependency of module.getDependenciesToBeIncluded()) {
-                if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                    modulesToHandle.add(dependency);
+    traceMappings() {
+        const sources = [];
+        const sourceIndexMap = new Map();
+        const sourcesContent = [];
+        const names = [];
+        const nameIndexMap = new Map();
+        const mappings = [];
+        for (const line of this.mappings) {
+            const tracedLine = [];
+            for (const segment of line) {
+                if (segment.length === 1)
+                    continue;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    continue;
+                const traced = source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : '');
+                if (traced) {
+                    const { column, line, name, source: { content, filename } } = traced;
+                    let sourceIndex = sourceIndexMap.get(filename);
+                    if (sourceIndex === undefined) {
+                        sourceIndex = sources.length;
+                        sources.push(filename);
+                        sourceIndexMap.set(filename, sourceIndex);
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (sourcesContent[sourceIndex] == null) {
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (content != null && sourcesContent[sourceIndex] !== content) {
+                        return error({
+                            message: `Multiple conflicting contents for sourcemap source ${filename}`
+                        });
+                    }
+                    const tracedSegment = [segment[0], sourceIndex, line, column];
+                    if (name) {
+                        let nameIndex = nameIndexMap.get(name);
+                        if (nameIndex === undefined) {
+                            nameIndex = names.length;
+                            names.push(name);
+                            nameIndexMap.set(name, nameIndex);
+                        }
+                        tracedSegment[4] = nameIndex;
+                    }
+                    tracedLine.push(tracedSegment);
                 }
             }
+            mappings.push(tracedLine);
         }
+        return { mappings, names, sources, sourcesContent };
     }
-    function areEntryPointsContainedOrDynamicallyDependent(entryPoints, containedIn) {
-        const entriesToCheck = new Set(entryPoints);
-        for (const entry of entriesToCheck) {
-            if (!containedIn.has(entry)) {
-                if (staticEntries.has(entry))
-                    return false;
-                const dynamicallyDependentEntryPoints = dynamicallyDependentEntryPointsByDynamicEntry.get(entry);
-                for (const dependentEntry of dynamicallyDependentEntryPoints) {
-                    entriesToCheck.add(dependentEntry);
-                }
+    traceSegment(line, column, name) {
+        const segments = this.mappings[line];
+        if (!segments)
+            return null;
+        // binary search through segments for the given column
+        let searchStart = 0;
+        let searchEnd = segments.length - 1;
+        while (searchStart <= searchEnd) {
+            const m = (searchStart + searchEnd) >> 1;
+            const segment = segments[m];
+            // If a sourcemap does not have sufficient resolution to contain a
+            // necessary mapping, e.g. because it only contains line information, we
+            // use the best approximation we could find
+            if (segment[0] === column || searchStart === searchEnd) {
+                if (segment.length == 1)
+                    return null;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    return null;
+                return source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : name);
+            }
+            if (segment[0] > column) {
+                searchEnd = m - 1;
+            }
+            else {
+                searchStart = m + 1;
             }
         }
-        return true;
+        return null;
     }
-    for (const entry of entryModules) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, null);
+}
+function getLinkMap(warn) {
+    return function linkMap(source, map) {
+        if (map.mappings) {
+            return new Link(map, [source]);
         }
+        warn({
+            code: 'SOURCEMAP_BROKEN',
+            message: `Sourcemap is likely to be incorrect: a plugin (${map.plugin}) was used to transform ` +
+                "files, but didn't generate a sourcemap for the transformation. Consult the plugin " +
+                'documentation for help',
+            plugin: map.plugin,
+            url: `https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect`
+        });
+        return new Link({
+            mappings: [],
+            names: []
+        }, [source]);
+    };
+}
+function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, linkMap) {
+    let source;
+    if (!originalSourcemap) {
+        source = new Source(id, originalCode);
     }
-    for (const entry of dynamicEntryModules) {
-        if (!modulesInManualChunks.has(entry)) {
-            assignEntryToStaticDependencies(entry, dynamicallyDependentEntryPointsByDynamicEntry.get(entry));
-        }
+    else {
+        const sources = originalSourcemap.sources;
+        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]));
+        source = new Link(originalSourcemap, baseSources);
     }
-    chunkDefinitions.push(...createChunks([...entryModules, ...dynamicEntryModules], assignedEntryPointsByModule));
-    return chunkDefinitions;
+    return sourcemapChain.reduce(linkMap, source);
 }
-function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
-    const modulesToHandle = new Set([entry]);
-    for (const module of modulesToHandle) {
-        modulesInManualChunks.add(module);
-        manualChunkModules.push(module);
-        for (const dependency of module.dependencies) {
-            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
-                modulesToHandle.add(dependency);
-            }
-        }
+function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, warn) {
+    const linkMap = getLinkMap(warn);
+    const moduleSources = modules
+        .filter(module => !module.excludeFromSourcemap)
+        .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
+    const link = new Link(map, moduleSources);
+    const source = bundleSourcemapChain.reduce(linkMap, link);
+    let { sources, sourcesContent, names, mappings } = source.traceMappings();
+    if (file) {
+        const directory = dirname(file);
+        sources = sources.map((source) => relative$1(directory, source));
+        file = basename(file);
     }
+    sourcesContent = (excludeContent ? null : sourcesContent);
+    return new SourceMap({ file, mappings, names, sources, sourcesContent });
 }
-function analyzeModuleGraph(entryModules) {
-    const dynamicEntryModules = new Set();
-    const dependentEntryPointsByModule = new Map();
-    const entriesToHandle = new Set(entryModules);
-    for (const currentEntry of entriesToHandle) {
-        const modulesToHandle = new Set([currentEntry]);
-        for (const module of modulesToHandle) {
-            getOrCreate(dependentEntryPointsByModule, module, () => new Set()).add(currentEntry);
-            for (const dependency of module.getDependenciesToBeIncluded()) {
-                if (!(dependency instanceof ExternalModule)) {
-                    modulesToHandle.add(dependency);
-                }
-            }
-            for (const { resolution } of module.dynamicImports) {
-                if (resolution instanceof Module && resolution.includedDynamicImporters.length > 0) {
-                    dynamicEntryModules.add(resolution);
-                    entriesToHandle.add(resolution);
-                }
-            }
-            for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicEntryModules.add(dependency);
-                entriesToHandle.add(dependency);
-            }
-        }
+function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, warn) {
+    if (!sourcemapChain.length) {
+        return originalSourcemap;
+    }
+    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(warn));
+    const map = source.traceMappings();
+    return { version: 3, ...map };
+}
+
+function decodedSourcemap(map) {
+    if (!map)
+        return null;
+    if (typeof map === 'string') {
+        map = JSON.parse(map);
+    }
+    if (map.mappings === '') {
+        return {
+            mappings: [],
+            names: [],
+            sources: [],
+            version: 3
+        };
     }
-    return { dependentEntryPointsByModule, dynamicEntryModules };
+    const mappings = typeof map.mappings === 'string' ? decode(map.mappings) : map.mappings;
+    return { ...map, mappings };
 }
-function getDynamicDependentEntryPoints(dependentEntryPointsByModule, dynamicEntryModules) {
-    const dynamicallyDependentEntryPointsByDynamicEntry = new Map();
-    for (const dynamicEntry of dynamicEntryModules) {
-        const dynamicDependentEntryPoints = getOrCreate(dynamicallyDependentEntryPointsByDynamicEntry, dynamicEntry, () => new Set());
-        for (const importer of [
-            ...dynamicEntry.includedDynamicImporters,
-            ...dynamicEntry.implicitlyLoadedAfter
-        ]) {
-            for (const entryPoint of dependentEntryPointsByModule.get(importer)) {
-                dynamicDependentEntryPoints.add(entryPoint);
-            }
-        }
-    }
-    return dynamicallyDependentEntryPointsByDynamicEntry;
+
+async function renderChunks(chunks, outputBundle, pluginDriver, outputOptions, onwarn) {
+    reserveEntryChunksInBundle(chunks);
+    const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
+    const chunkGraph = getChunkGraph(chunks);
+    const { nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders);
 }
-function createChunks(allEntryPoints, assignedEntryPointsByModule) {
-    const chunkModules = Object.create(null);
-    for (const [module, assignedEntryPoints] of assignedEntryPointsByModule) {
-        let chunkSignature = '';
-        for (const entry of allEntryPoints) {
-            chunkSignature += assignedEntryPoints.has(entry) ? 'X' : '_';
-        }
-        const chunk = chunkModules[chunkSignature];
-        if (chunk) {
-            chunk.push(module);
-        }
-        else {
-            chunkModules[chunkSignature] = [module];
+function reserveEntryChunksInBundle(chunks) {
+    for (const chunk of chunks) {
+        if (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint) {
+            // reserves name in bundle as side effect if it does not contain a hash
+            chunk.getPreliminaryFileName();
         }
     }
-    return Object.values(chunkModules).map(modules => ({
-        alias: null,
-        modules
-    }));
-}
-
-// ported from https://github.com/substack/node-commondir
-function commondir(files) {
-    if (files.length === 0)
-        return '/';
-    if (files.length === 1)
-        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++)
-            ;
-        return commonSegments.slice(0, i);
-    }, files[0].split(/\/+|\\+/));
-    // Windows correctly handles paths with forward-slashes
-    return commonSegments.length > 1 ? commonSegments.join('/') : '/';
 }
-
-const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
-function sortByExecutionOrder(units) {
-    units.sort(compareExecIndex);
+function getChunkGraph(chunks) {
+    return Object.fromEntries(chunks.map(chunk => {
+        const renderedChunkInfo = chunk.getRenderedChunkInfo();
+        return [renderedChunkInfo.fileName, renderedChunkInfo];
+    }));
 }
-function analyseModuleExecution(entryModules) {
-    let nextExecIndex = 0;
-    const cyclePaths = [];
-    const analysedModules = new Set();
-    const dynamicImports = new Set();
-    const parents = new Map();
-    const orderedModules = [];
-    const analyseModule = (module) => {
-        if (module instanceof Module) {
-            for (const dependency of module.dependencies) {
-                if (parents.has(dependency)) {
-                    if (!analysedModules.has(dependency)) {
-                        cyclePaths.push(getCyclePath(dependency, module, parents));
-                    }
-                    continue;
+async function transformChunk(magicString, fileName, usedModules, chunkGraph, options, outputPluginDriver, onwarn) {
+    let map = null;
+    const sourcemapChain = [];
+    let code = await outputPluginDriver.hookReduceArg0('renderChunk', [magicString.toString(), chunkGraph[fileName], options, { chunks: chunkGraph }], (code, result, plugin) => {
+        if (result == null)
+            return code;
+        if (typeof result === 'string')
+            result = {
+                code: result,
+                map: undefined
+            };
+        // strict null check allows 'null' maps to not be pushed to the chain, while 'undefined' gets the missing map warning
+        if (result.map !== null) {
+            const map = decodedSourcemap(result.map);
+            sourcemapChain.push(map || { missing: true, plugin: plugin.name });
+        }
+        return result.code;
+    });
+    const { compact, sourcemap, sourcemapPathTransform } = options;
+    if (!compact && code[code.length - 1] !== '\n')
+        code += '\n';
+    if (sourcemap) {
+        timeStart('sourcemap', 2);
+        let file;
+        if (options.file)
+            file = resolve(options.sourcemapFile || options.file);
+        else if (options.dir)
+            file = resolve(options.dir, fileName);
+        else
+            file = resolve(fileName);
+        const decodedMap = magicString.generateDecodedMap({});
+        map = collapseSourcemaps(file, decodedMap, usedModules, sourcemapChain, options.sourcemapExcludeSources, onwarn);
+        map.sources = map.sources
+            .map(sourcePath => {
+            if (sourcemapPathTransform) {
+                const newSourcePath = sourcemapPathTransform(sourcePath, `${file}.map`);
+                if (typeof newSourcePath !== 'string') {
+                    error(errFailedValidation(`sourcemapPathTransform function must return a string.`));
                 }
-                parents.set(dependency, module);
-                analyseModule(dependency);
+                return newSourcePath;
             }
-            for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicImports.add(dependency);
-            }
-            for (const { resolution } of module.dynamicImports) {
-                if (resolution instanceof Module) {
-                    dynamicImports.add(resolution);
+            return sourcePath;
+        })
+            .map(normalize);
+        timeEnd('sourcemap', 2);
+    }
+    return {
+        code,
+        map
+    };
+}
+async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn) {
+    const nonHashedChunksWithPlaceholders = [];
+    const renderedChunksByPlaceholder = new Map();
+    const hashDependenciesByPlaceholder = new Map();
+    const placeholders = new Set();
+    for (const { preliminaryFileName: { hashPlaceholder } } of renderedChunks) {
+        if (hashPlaceholder)
+            placeholders.add(hashPlaceholder);
+    }
+    await Promise.all(renderedChunks.map(async ({ chunk, preliminaryFileName: { fileName, hashPlaceholder }, magicString, usedModules }) => {
+        const transformedChunk = {
+            chunk,
+            fileName,
+            ...(await transformChunk(magicString, fileName, usedModules, chunkGraph, outputOptions, pluginDriver, onwarn))
+        };
+        const { code } = transformedChunk;
+        if (hashPlaceholder) {
+            const hash = createHash();
+            // To create a reproducible content-only hash, all placeholders are
+            // replaced with the same value before hashing
+            const { containedPlaceholders, transformedCode } = replacePlaceholdersWithDefaultAndGetContainedPlaceholders(code, placeholders);
+            hash.update(transformedCode);
+            const hashAugmentation = pluginDriver.hookReduceValueSync('augmentChunkHash', '', [chunk.getRenderedChunkInfo()], (augmentation, pluginHash) => {
+                if (pluginHash) {
+                    augmentation += pluginHash;
                 }
+                return augmentation;
+            });
+            if (hashAugmentation) {
+                hash.update(hashAugmentation);
             }
-            orderedModules.push(module);
-        }
-        module.execIndex = nextExecIndex++;
-        analysedModules.add(module);
-    };
-    for (const curEntry of entryModules) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
+            renderedChunksByPlaceholder.set(hashPlaceholder, transformedChunk);
+            hashDependenciesByPlaceholder.set(hashPlaceholder, {
+                containedPlaceholders,
+                contentHash: hash.digest('hex')
+            });
         }
-    }
-    for (const curEntry of dynamicImports) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
+        else {
+            nonHashedChunksWithPlaceholders.push(transformedChunk);
         }
-    }
-    return { cyclePaths, orderedModules };
+    }));
+    return {
+        hashDependenciesByPlaceholder,
+        nonHashedChunksWithPlaceholders,
+        renderedChunksByPlaceholder
+    };
 }
-function getCyclePath(module, parent, parents) {
-    const cycleSymbol = Symbol(module.id);
-    const path = [relativeId(module.id)];
-    let nextModule = parent;
-    module.cycles.add(cycleSymbol);
-    while (nextModule !== module) {
-        nextModule.cycles.add(cycleSymbol);
-        path.push(relativeId(nextModule.id));
-        nextModule = parents.get(nextModule);
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle) {
+    const hashesByPlaceholder = new Map();
+    for (const [placeholder, { fileName }] of renderedChunksByPlaceholder) {
+        let hash = createHash();
+        const hashDependencyPlaceholders = new Set([placeholder]);
+        for (const dependencyPlaceholder of hashDependencyPlaceholders) {
+            const { containedPlaceholders, contentHash } = hashDependenciesByPlaceholder.get(dependencyPlaceholder);
+            hash.update(contentHash);
+            for (const containedPlaceholder of containedPlaceholders) {
+                // When looping over a map, setting an entry only causes a new iteration if the key is new
+                hashDependencyPlaceholders.add(containedPlaceholder);
+            }
+        }
+        let finalFileName;
+        let finalHash;
+        do {
+            // In case of a hash collision, create a hash of the hash
+            if (finalHash) {
+                hash = createHash();
+                hash.update(finalHash);
+            }
+            finalHash = hash.digest('hex').slice(0, placeholder.length);
+            finalFileName = replaceSinglePlaceholder(fileName, placeholder, finalHash);
+        } while (outputBundle[finalFileName]);
+        outputBundle[finalFileName] = FILE_PLACEHOLDER;
+        hashesByPlaceholder.set(placeholder, finalHash.slice(0, placeholder.length));
     }
-    path.push(path[0]);
-    path.reverse();
-    return path;
+    return hashesByPlaceholder;
 }
-
-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 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(`,${_}`)})`}${_}=>${_}`;
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders) {
+    for (const { chunk, code, fileName, map } of renderedChunksByPlaceholder.values()) {
+        const updatedCode = replacePlaceholders(code, hashesByPlaceholder);
+        const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
+        if (map) {
+            map.file = replacePlaceholders(map.file, hashesByPlaceholder);
         }
-        : getNonArrowFunctionIntro;
-    const getDirectReturnFunction = (params, { functionReturn, lineBreakIndent, name }) => [
-        `${getFunctionIntro(params, {
-            isAsync: false,
-            name
-        })}${arrowFunctions
-            ? lineBreakIndent
-                ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}`
-                : ''
-            : `{${lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _}${functionReturn ? 'return ' : ''}`}`,
-        arrowFunctions
-            ? `${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);
-    return {
-        _,
-        cnst,
-        getDirectReturnFunction,
-        getDirectReturnIifeLeft: (params, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
-            const [left, right] = getDirectReturnFunction(params, {
-                functionReturn: true,
-                lineBreakIndent: null,
-                name: null
-            });
-            return `${wrapIfNeeded(`${left}${wrapIfNeeded(returned, arrowFunctions && needsArrowReturnParens)}${right}`, arrowFunctions || needsWrappedFunction)}(`;
-        },
-        getFunctionIntro,
-        getNonArrowFunctionIntro,
-        getObject(fields, { lineBreakIndent }) {
-            const prefix = lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _;
-            return `{${fields
-                .map(([key, value]) => {
-                if (key === null)
-                    return `${prefix}${value}`;
-                const needsQuotes = !isValidPropName(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)}]`,
-        n,
-        s
-    };
+        outputBundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
+    }
+    for (const { chunk, code, fileName, map } of nonHashedChunksWithPlaceholders) {
+        const updatedCode = hashesByPlaceholder.size
+            ? replacePlaceholders(code, hashesByPlaceholder)
+            : code;
+        outputBundle[fileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
+    }
 }
-const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
-const validPropName = /^(?!\d)[\w$]+$/;
 
 class Bundle {
     constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
@@ -15959,24 +16107,24 @@ class Bundle {
     async generate(isWrite) {
         timeStart('GENERATE', 1);
         const outputBundle = Object.create(null);
-        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions, this.facadeChunkByModule);
+        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions);
+        // TODO Lukas rethink time measuring points
         try {
             await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
             timeStart('generate chunks', 2);
-            const chunks = await this.generateChunks();
+            const getHashPlaceholder = getHashPlaceholderGenerator();
+            const chunks = await this.generateChunks(outputBundle, getHashPlaceholder);
             if (chunks.length > 1) {
                 validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onwarn);
             }
-            const inputBase = commondir(getAbsoluteEntryModulePaths(chunks));
+            this.pluginDriver.setChunkInformation(this.facadeChunkByModule);
             timeEnd('generate chunks', 2);
-            timeStart('render modules', 2);
-            // We need to create addons before prerender because at the moment, there
-            // can be no async code between prerender and render due to internal state
-            const addons = await createAddons(this.outputOptions, this.pluginDriver);
-            const snippets = getGenerateCodeSnippets(this.outputOptions);
-            this.prerenderChunks(chunks, inputBase, snippets);
-            timeEnd('render modules', 2);
-            await this.addFinalizedChunksToBundle(chunks, inputBase, addons, outputBundle, snippets);
+            timeStart('render chunks', 2);
+            for (const chunk of chunks) {
+                chunk.generateExports();
+            }
+            await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onwarn);
+            timeEnd('render chunks', 2);
         }
         catch (err) {
             await this.pluginDriver.hookParallel('renderError', [err]);
@@ -15991,16 +16139,6 @@ class Bundle {
         timeEnd('GENERATE', 1);
         return outputBundle;
     }
-    async addFinalizedChunksToBundle(chunks, inputBase, addons, outputBundle, snippets) {
-        this.assignChunkIds(chunks, inputBase, addons, outputBundle);
-        for (const chunk of chunks) {
-            outputBundle[chunk.id] = chunk.getChunkInfoWithFileNames();
-        }
-        await Promise.all(chunks.map(async (chunk) => {
-            const outputChunk = outputBundle[chunk.id];
-            Object.assign(outputChunk, await chunk.render(this.outputOptions, addons, outputChunk, snippets));
-        }));
-    }
     async addManualChunks(manualChunks) {
         const manualChunkAliasByEntry = new Map();
         const chunkEntries = await Promise.all(Object.entries(manualChunks).map(async ([alias, files]) => ({
@@ -16014,29 +16152,6 @@ class Bundle {
         }
         return manualChunkAliasByEntry;
     }
-    assignChunkIds(chunks, inputBase, addons, bundle) {
-        const entryChunks = [];
-        const otherChunks = [];
-        for (const chunk of chunks) {
-            (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint
-                ? entryChunks
-                : otherChunks).push(chunk);
-        }
-        // make sure entry chunk names take precedence with regard to deconflicting
-        const chunksForNaming = entryChunks.concat(otherChunks);
-        for (const chunk of chunksForNaming) {
-            if (this.outputOptions.file) {
-                chunk.id = basename(this.outputOptions.file);
-            }
-            else if (this.outputOptions.preserveModules) {
-                chunk.id = chunk.generateIdPreserveModules(inputBase, this.outputOptions, bundle, this.unsetOptions);
-            }
-            else {
-                chunk.id = chunk.generateId(addons, this.outputOptions, bundle, true);
-            }
-            bundle[chunk.id] = FILE_PLACEHOLDER;
-        }
-    }
     assignManualChunks(getManualChunk) {
         const manualChunkAliasesWithEntry = [];
         const manualChunksApi = {
@@ -16060,10 +16175,6 @@ class Bundle {
     }
     finaliseAssets(outputBundle) {
         for (const file of Object.values(outputBundle)) {
-            if (!file.type) {
-                warnDeprecation('A plugin is directly adding properties to the bundle object in the "generateBundle" hook. This is deprecated and will be removed in a future Rollup version, please use "this.emitFile" instead.', true, this.inputOptions);
-                file.type = 'asset';
-            }
             if (this.outputOptions.validate && 'code' in file) {
                 try {
                     this.graph.contextParse(file.code, {
@@ -16078,27 +16189,25 @@ class Bundle {
         }
         this.pluginDriver.finaliseAssets();
     }
-    async generateChunks() {
-        const { manualChunks } = this.outputOptions;
+    async generateChunks(bundle, getHashPlaceholder) {
+        const { inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
         const manualChunkAliasByEntry = typeof manualChunks === 'object'
             ? await this.addManualChunks(manualChunks)
             : this.assignManualChunks(manualChunks);
+        const snippets = getGenerateCodeSnippets(this.outputOptions);
+        const includedModules = getIncludedModules(this.graph.modulesById);
+        const inputBase = commondir(getAbsoluteEntryModulePaths(includedModules, preserveModules));
+        const externalChunkByModule = getExternalChunkByModule(this.graph.modulesById, this.outputOptions, inputBase);
         const chunks = [];
         const chunkByModule = new Map();
-        for (const { alias, modules } of this.outputOptions.inlineDynamicImports
-            ? [{ alias: null, modules: getIncludedModules(this.graph.modulesById) }]
-            : this.outputOptions.preserveModules
-                ? getIncludedModules(this.graph.modulesById).map(module => ({
-                    alias: null,
-                    modules: [module]
-                }))
+        for (const { alias, modules } of inlineDynamicImports
+            ? [{ alias: null, modules: includedModules }]
+            : preserveModules
+                ? includedModules.map(module => ({ alias: null, modules: [module] }))
                 : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry)) {
             sortByExecutionOrder(modules);
-            const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias);
+            const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
             chunks.push(chunk);
-            for (const module of modules) {
-                chunkByModule.set(module, chunk);
-            }
         }
         for (const chunk of chunks) {
             chunk.link();
@@ -16109,25 +16218,6 @@ class Bundle {
         }
         return [...chunks, ...facades];
     }
-    prerenderChunks(chunks, inputBase, snippets) {
-        for (const chunk of chunks) {
-            chunk.generateExports();
-        }
-        for (const chunk of chunks) {
-            chunk.preRender(this.outputOptions, inputBase, snippets);
-        }
-    }
-}
-function getAbsoluteEntryModulePaths(chunks) {
-    const absoluteEntryModulePaths = [];
-    for (const chunk of chunks) {
-        for (const entryModule of chunk.entryModules) {
-            if (isAbsolute(entryModule.id)) {
-                absoluteEntryModulePaths.push(entryModule.id);
-            }
-        }
-    }
-    return absoluteEntryModulePaths;
 }
 function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
     if (outputOptions.format === 'umd' || outputOptions.format === 'iife')
@@ -16140,8 +16230,32 @@ function validateOptionsForMultiChunkOutput(outputOptions, onWarn) {
         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'));
 }
 function getIncludedModules(modulesById) {
-    return [...modulesById.values()].filter((module) => module instanceof Module &&
-        (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0));
+    const includedModules = [];
+    for (const module of modulesById.values()) {
+        if (module instanceof Module &&
+            (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0)) {
+            includedModules.push(module);
+        }
+    }
+    return includedModules;
+}
+function getAbsoluteEntryModulePaths(includedModules, preserveModules) {
+    const absoluteEntryModulePaths = [];
+    for (const module of includedModules) {
+        if ((module.info.isEntry || preserveModules) && isAbsolute(module.id)) {
+            absoluteEntryModulePaths.push(module.id);
+        }
+    }
+    return absoluteEntryModulePaths;
+}
+function getExternalChunkByModule(modulesById, outputOptions, inputBase) {
+    const externalChunkByModule = new Map();
+    for (const module of modulesById.values()) {
+        if (module instanceof ExternalModule) {
+            externalChunkByModule.set(module, new ExternalChunk(module, outputOptions, inputBase));
+        }
+    }
+    return externalChunkByModule;
 }
 function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
     const existingAlias = manualChunkAliasByEntry.get(module);
@@ -21783,7 +21897,7 @@ async function findFile(file, preserveSymlinks) {
                 return file;
         }
     }
-    catch (_a) {
+    catch {
         // suppress
     }
 }
@@ -21806,21 +21920,6 @@ function throwPluginError(err, plugin, { hook, id } = {}) {
     }
     return error(err);
 }
-const deprecatedHooks = [
-    { active: true, deprecated: 'resolveAssetUrl', replacement: 'resolveFileUrl' }
-];
-function warnDeprecatedHooks(plugins, options) {
-    for (const { active, deprecated, replacement } of deprecatedHooks) {
-        for (const plugin of plugins) {
-            if (deprecated in plugin) {
-                warnDeprecation({
-                    message: `The "${deprecated}" hook used by plugin ${plugin.name} is deprecated. The "${replacement}" hook should be used instead.`,
-                    plugin: plugin.name
-                }, active, options);
-            }
-        }
-    }
-}
 
 function createPluginCache(cache) {
     return {
@@ -21962,14 +22061,6 @@ async function transform(source, module, pluginDriver, warn) {
                 cache: customTransformCache
                     ? pluginContext.cache
                     : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
-                emitAsset(name, source) {
-                    emittedFiles.push({ name, source, type: 'asset' });
-                    return pluginContext.emitAsset(name, source);
-                },
-                emitChunk(id, options) {
-                    emittedFiles.push({ id, name: options && options.name, type: 'chunk' });
-                    return pluginContext.emitChunk(id, options);
-                },
                 emitFile(emittedFile) {
                     emittedFiles.push(emittedFile);
                     return pluginDriver.emitFile(emittedFile);
@@ -22479,19 +22570,6 @@ class GlobalScope extends Scope$1 {
     }
 }
 
-function getDeprecatedContextHandler(handler, handlerName, newHandlerName, pluginName, activeDeprecation, options) {
-    let deprecationWarningShown = false;
-    return ((...args) => {
-        if (!deprecationWarningShown) {
-            deprecationWarningShown = true;
-            warnDeprecation({
-                message: `The "this.${handlerName}" plugin context function used by plugin ${pluginName} is deprecated. The "this.${newHandlerName}" plugin context function should be used instead.`,
-                plugin: pluginName
-            }, activeDeprecation, options);
-        }
-        return handler(...args);
-    });
-}
 function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, existingPluginNames) {
     let cacheable = true;
     if (typeof plugin.cacheKey !== 'string') {
@@ -22523,19 +22601,14 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             graph.watchFiles[id] = true;
         },
         cache: cacheInstance,
-        emitAsset: getDeprecatedContextHandler((name, source) => fileEmitter.emitFile({ name, source, type: 'asset' }), 'emitAsset', 'emitFile', plugin.name, true, options),
-        emitChunk: getDeprecatedContextHandler((id, options) => fileEmitter.emitFile({ id, name: options && options.name, type: 'chunk' }), 'emitChunk', 'emitFile', plugin.name, true, options),
         emitFile: fileEmitter.emitFile.bind(fileEmitter),
         error(err) {
             return throwPluginError(err, plugin.name);
         },
-        getAssetFileName: getDeprecatedContextHandler(fileEmitter.getFileName, 'getAssetFileName', 'getFileName', plugin.name, true, options),
-        getChunkFileName: getDeprecatedContextHandler(fileEmitter.getFileName, 'getChunkFileName', 'getFileName', plugin.name, true, options),
         getFileName: fileEmitter.getFileName,
         getModuleIds: () => graph.modulesById.keys(),
         getModuleInfo: graph.getModuleInfo,
         getWatchFiles: () => Object.keys(graph.watchFiles),
-        isExternal: getDeprecatedContextHandler((id, parentId, isResolved = false) => options.external(id, parentId, isResolved), 'isExternal', 'resolve', plugin.name, true, options),
         load(resolvedId) {
             return graph.moduleLoader.preloadModule(resolvedId);
         },
@@ -22549,7 +22622,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
                 warnDeprecation({
                     message: `Accessing "this.moduleIds" on the plugin context by plugin ${plugin.name} is deprecated. The "this.getModuleIds" plugin context function should be used instead.`,
                     plugin: plugin.name
-                }, false, options);
+                }, true, options);
                 yield* moduleIds;
             }
             const moduleIds = graph.modulesById.keys();
@@ -22559,9 +22632,6 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
         resolve(source, importer, { custom, isEntry, skipSelf } = BLANK) {
             return graph.moduleLoader.resolveId(source, importer, custom, isEntry, skipSelf ? [{ importer, plugin, source }] : null);
         },
-        resolveId: getDeprecatedContextHandler((source, importer) => graph.moduleLoader
-            .resolveId(source, importer, BLANK, undefined)
-            .then(resolveId => resolveId && resolveId.id), 'resolveId', 'resolve', plugin.name, true, options),
         setAssetSource: fileEmitter.setAssetSource,
         warn(warning) {
             if (typeof warning === 'string')
@@ -22602,12 +22672,12 @@ class PluginDriver {
         this.graph = graph;
         this.options = options;
         this.unfulfilledActions = new Set();
-        warnDeprecatedHooks(userPlugins, options);
         this.pluginCache = pluginCache;
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
         this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
         this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
-        this.finaliseAssets = this.fileEmitter.assertAssetsFinalized.bind(this.fileEmitter);
+        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 = userPlugins.concat(basePluginDriver ? basePluginDriver.plugins : []);
         const existingPluginNames = new Set();
@@ -23167,7 +23237,7 @@ function normalizeInputOptions(config) {
         preserveSymlinks: config.preserveSymlinks || false,
         shimMissingExports: config.shimMissingExports || false,
         strictDeprecations,
-        treeshake: getTreeshake(config, onwarn, strictDeprecations)
+        treeshake: getTreeshake(config)
     };
     warnUnknownOptions(config, [...Object.keys(options), 'watch'], 'input options', options.onwarn, /^(output)$/);
     return { options, unsetOptions };
@@ -23223,7 +23293,7 @@ const getIdMatcher = (option) => {
 const getInlineDynamicImports$1 = (config, warn, strictDeprecations) => {
     const configInlineDynamicImports = config.inlineDynamicImports;
     if (configInlineDynamicImports) {
-        warnDeprecationWithOptions('The "inlineDynamicImports" option is deprecated. Use the "output.inlineDynamicImports" option instead.', false, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "inlineDynamicImports" option is deprecated. Use the "output.inlineDynamicImports" option instead.', true, warn, strictDeprecations);
     }
     return configInlineDynamicImports;
 };
@@ -23234,7 +23304,7 @@ const getInput = (config) => {
 const getManualChunks$1 = (config, warn, strictDeprecations) => {
     const configManualChunks = config.manualChunks;
     if (configManualChunks) {
-        warnDeprecationWithOptions('The "manualChunks" option is deprecated. Use the "output.manualChunks" option instead.', false, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "manualChunks" option is deprecated. Use the "output.manualChunks" option instead.', true, warn, strictDeprecations);
     }
     return configManualChunks;
 };
@@ -23271,25 +23341,20 @@ const getPreserveEntrySignatures = (config, unsetOptions) => {
 const getPreserveModules$1 = (config, warn, strictDeprecations) => {
     const configPreserveModules = config.preserveModules;
     if (configPreserveModules) {
-        warnDeprecationWithOptions('The "preserveModules" option is deprecated. Use the "output.preserveModules" option instead.', false, warn, strictDeprecations);
+        warnDeprecationWithOptions('The "preserveModules" option is deprecated. Use the "output.preserveModules" option instead.', true, warn, strictDeprecations);
     }
     return configPreserveModules;
 };
-const getTreeshake = (config, warn, strictDeprecations) => {
+const getTreeshake = (config) => {
     const configTreeshake = config.treeshake;
     if (configTreeshake === false) {
         return false;
     }
     const configWithPreset = getOptionWithPreset(config.treeshake, treeshakePresets, 'treeshake', 'false, true, ');
-    if (typeof configWithPreset.pureExternalModules !== 'undefined') {
-        warnDeprecationWithOptions(`The "treeshake.pureExternalModules" option is deprecated. The "treeshake.moduleSideEffects" option should be used instead. "treeshake.pureExternalModules: true" is equivalent to "treeshake.moduleSideEffects: 'no-external'"`, true, warn, strictDeprecations);
-    }
     return {
         annotations: configWithPreset.annotations !== false,
         correctVarValueBeforeDeclaration: configWithPreset.correctVarValueBeforeDeclaration === true,
-        moduleSideEffects: typeof configTreeshake === 'object' && configTreeshake.pureExternalModules
-            ? getHasModuleSideEffects(configTreeshake.moduleSideEffects, configTreeshake.pureExternalModules)
-            : getHasModuleSideEffects(configWithPreset.moduleSideEffects, undefined),
+        moduleSideEffects: getHasModuleSideEffects(configWithPreset.moduleSideEffects),
         propertyReadSideEffects: configWithPreset.propertyReadSideEffects === 'always'
             ? 'always'
             : configWithPreset.propertyReadSideEffects !== false,
@@ -23297,7 +23362,7 @@ const getTreeshake = (config, warn, strictDeprecations) => {
         unknownGlobalSideEffects: configWithPreset.unknownGlobalSideEffects !== false
     };
 };
-const getHasModuleSideEffects = (moduleSideEffectsOption, pureExternalModules) => {
+const getHasModuleSideEffects = (moduleSideEffectsOption) => {
     if (typeof moduleSideEffectsOption === 'boolean') {
         return () => moduleSideEffectsOption;
     }
@@ -23314,8 +23379,7 @@ const getHasModuleSideEffects = (moduleSideEffectsOption, pureExternalModules) =
     if (moduleSideEffectsOption) {
         error(errInvalidOption('treeshake.moduleSideEffects', 'treeshake', 'please use one of false, "no-external", a function or an array'));
     }
-    const isPureExternalModule = getIdMatcher(pureExternalModules);
-    return (id, external) => !(external && isPureExternalModule(id));
+    return () => true;
 };
 
 // https://datatracker.ietf.org/doc/html/rfc2396
@@ -23349,7 +23413,7 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         chunkFileNames: (_b = config.chunkFileNames) !== null && _b !== void 0 ? _b : '[name]-[hash].js',
         compact,
         dir: getDir(config, file),
-        dynamicImportFunction: getDynamicImportFunction(config, inputOptions),
+        dynamicImportFunction: getDynamicImportFunction(config, inputOptions, format),
         entryFileNames: getEntryFileNames(config, unsetOptions),
         esModule: (_c = config.esModule) !== null && _c !== void 0 ? _c : true,
         exports: getExports(config, unsetOptions),
@@ -23454,7 +23518,7 @@ const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
 const getPreferConst = (config, inputOptions) => {
     const configPreferConst = config.preferConst;
     if (configPreferConst != null) {
-        warnDeprecation(`The "output.preferConst" option is deprecated. Use the "output.generatedCode.constBindings" option instead.`, false, inputOptions);
+        warnDeprecation(`The "output.preferConst" option is deprecated. Use the "output.generatedCode.constBindings" option instead.`, true, inputOptions);
     }
     return !!configPreferConst;
 };
@@ -23509,10 +23573,13 @@ const getDir = (config, file) => {
     }
     return dir;
 };
-const getDynamicImportFunction = (config, inputOptions) => {
+const getDynamicImportFunction = (config, inputOptions, format) => {
     const configDynamicImportFunction = config.dynamicImportFunction;
     if (configDynamicImportFunction) {
-        warnDeprecation(`The "output.dynamicImportFunction" option is deprecated. Use the "renderDynamicImport" plugin hook instead.`, false, inputOptions);
+        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"'));
+        }
     }
     return configDynamicImportFunction;
 };
@@ -23571,7 +23638,7 @@ const getInterop = (config, inputOptions) => {
                 warnDeprecation({
                     message: `The boolean value "${interop}" for the "output.interop" option is deprecated. Use ${interop ? '"auto"' : '"esModule", "default" or "defaultOnly"'} instead.`,
                     url: 'https://rollupjs.org/guide/en/#outputinterop'
-                }, false, inputOptions);
+                }, true, inputOptions);
             }
         }
         return interop;
@@ -23603,7 +23670,7 @@ const getMinifyInternalExports = (config, format, compact) => { var _a; return (
 const getNamespaceToStringTag = (config, generatedCode, inputOptions) => {
     const configNamespaceToStringTag = config.namespaceToStringTag;
     if (configNamespaceToStringTag != null) {
-        warnDeprecation(`The "output.namespaceToStringTag" option is deprecated. Use the "output.generatedCode.symbols" option instead.`, false, inputOptions);
+        warnDeprecation(`The "output.namespaceToStringTag" option is deprecated. Use the "output.generatedCode.symbols" option instead.`, true, inputOptions);
         return configNamespaceToStringTag;
     }
     return generatedCode.symbols || false;