rollup 3.0.0-6 → 3.0.0-7

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.0.0-5
-	Tue, 06 Sep 2022 05:29:28 GMT - commit 1d085668121abe6be83c28c212a02c181c16d2b8
+	Rollup.js v3.0.0-6
+	Fri, 23 Sep 2022 04:45:13 GMT - commit 8015be75da6c0861998eb093fb040d0b17679b20
 
 	https://github.com/rollup/rollup
 
@@ -15,7 +15,7 @@ import { createHash as createHash$1 } from 'node:crypto';
 import { promises } from 'node:fs';
 import { EventEmitter } from 'node:events';
 
-var version$1 = "3.0.0-5";
+var version$1 = "3.0.0-6";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -14065,293 +14065,6 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultEx
 
 const finalisers = { amd, cjs, es, iife, system, umd };
 
-const createHash = () => createHash$1('sha256');
-
-// Four random characters from the private use area to minimize risk of conflicts
-const hashPlaceholderLeft = '!~{';
-const hashPlaceholderRight = '}~';
-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}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
-        if (placeholder.length > hashSize) {
-            return error(errFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
-        }
-        return placeholder;
-    };
-};
-const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{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. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
-    return pattern.replace(/\[(\w+)(:\d+)?]/g, (_match, type, size) => {
-        if (!replacements.hasOwnProperty(type) || (size && type !== 'hash')) {
-            return error(errFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
-        }
-        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));
-    }
-    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;
-}
-function getAssetFileName(file, referenceId) {
-    if (typeof file.fileName !== 'string') {
-        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
-    }
-    return file.fileName;
-}
-function getChunkFileName(file, facadeChunkByModule) {
-    if (file.fileName) {
-        return file.fileName;
-    }
-    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 (!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 {
-                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 referenceId;
-    }
-    emitChunk(emittedChunk) {
-        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
-            return error(errInvalidRollupPhaseForChunkEmission());
-        }
-        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 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);
-        bundle[fileName] = {
-            fileName,
-            name: consumedFile.name,
-            source,
-            type: 'asset'
-        };
-    }
-}
-function findExistingAssetFileNameWithSource(bundle, source) {
-    for (const [fileName, outputFile] of Object.entries(bundle)) {
-        if (outputFile.type === 'asset' && areSourcesEqual(source, outputFile.source))
-            return fileName;
-    }
-    return null;
-}
-function areSourcesEqual(sourceA, sourceB) {
-    if (typeof sourceA === 'string') {
-        return sourceA === sourceB;
-    }
-    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) {
@@ -14624,6 +14337,93 @@ function addStaticDependencies(module, staticDependencies, handledModules, chunk
     }
 }
 
+// Four random characters from the private use area to minimize risk of conflicts
+const hashPlaceholderLeft = '!~{';
+const hashPlaceholderRight = '}~';
+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}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
+        if (placeholder.length > hashSize) {
+            return error(errFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
+        }
+        return placeholder;
+    };
+};
+const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{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 };
+};
+
+const lowercaseBundleKeys = Symbol('bundleKeys');
+const FILE_PLACEHOLDER = {
+    type: 'placeholder'
+};
+const getOutputBundle = (outputBundleBase) => {
+    const reservedLowercaseBundleKeys = new Set();
+    return new Proxy(outputBundleBase, {
+        deleteProperty(target, key) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.delete(key.toLowerCase());
+            }
+            return Reflect.deleteProperty(target, key);
+        },
+        get(target, key) {
+            if (key === lowercaseBundleKeys) {
+                return reservedLowercaseBundleKeys;
+            }
+            return Reflect.get(target, key);
+        },
+        set(target, key, value) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.add(key.toLowerCase());
+            }
+            return Reflect.set(target, key, value);
+        }
+    });
+};
+
+function renderNamePattern(pattern, patternName, replacements) {
+    if (isPathFragment(pattern))
+        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
+    return 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, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
+    if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
+        return name;
+    const ext = extname(name);
+    name = name.substring(0, name.length - ext.length);
+    let uniqueName, uniqueIndex = 1;
+    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
+        ;
+    return uniqueName;
+}
+
 const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.mts', '.cjs', '.cts'];
 function getGlobalName(chunk, globals, hasExports, warn) {
     const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
@@ -16033,6 +15833,8 @@ function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain,
     return { version: 3, ...map };
 }
 
+const createHash = () => createHash$1('sha256');
+
 function decodedSourcemap(map) {
     if (!map)
         return null;
@@ -16051,7 +15853,7 @@ function decodedSourcemap(map) {
     return { ...map, mappings };
 }
 
-async function renderChunks(chunks, outputBundle, pluginDriver, outputOptions, onwarn) {
+async function renderChunks(chunks, bundle, pluginDriver, outputOptions, onwarn) {
     timeStart('render chunks', 2);
     reserveEntryChunksInBundle(chunks);
     const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
@@ -16059,8 +15861,8 @@ async function renderChunks(chunks, outputBundle, pluginDriver, outputOptions, o
     timeStart('transform chunks', 2);
     const chunkGraph = getChunkGraph(chunks);
     const { nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, onwarn);
-    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle);
-    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, bundle);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
     timeEnd('transform chunks', 2);
 }
 function reserveEntryChunksInBundle(chunks) {
@@ -16175,7 +15977,7 @@ async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGrap
         renderedChunksByPlaceholder
     };
 }
-function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, outputBundle) {
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, bundle) {
     const hashesByPlaceholder = new Map();
     for (const [placeholder, { fileName }] of renderedChunksByPlaceholder) {
         let hash = createHash();
@@ -16198,13 +16000,13 @@ function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlac
             }
             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));
+        } while (bundle[lowercaseBundleKeys].has(finalFileName.toLowerCase()));
+        bundle[finalFileName] = FILE_PLACEHOLDER;
+        hashesByPlaceholder.set(placeholder, finalHash);
     }
     return hashesByPlaceholder;
 }
-function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, outputBundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
     for (const { chunk, code, fileName, map } of renderedChunksByPlaceholder.values()) {
         let updatedCode = replacePlaceholders(code, hashesByPlaceholder);
         const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
@@ -16212,7 +16014,7 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, out
             map.file = replacePlaceholders(map.file, hashesByPlaceholder);
             updatedCode += emitSourceMapAndGetComment(finalFileName, map, pluginDriver, options);
         }
-        outputBundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
+        bundle[finalFileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
     for (const { chunk, code, fileName, map } of nonHashedChunksWithPlaceholders) {
         let updatedCode = hashesByPlaceholder.size
@@ -16221,7 +16023,7 @@ function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, out
         if (map) {
             updatedCode += emitSourceMapAndGetComment(fileName, map, pluginDriver, options);
         }
-        outputBundle[fileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
+        bundle[fileName] = chunk.generateOutputChunk(updatedCode, map, hashesByPlaceholder);
     }
 }
 function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, sourcemapBaseUrl }) {
@@ -16251,7 +16053,8 @@ class Bundle {
     }
     async generate(isWrite) {
         timeStart('GENERATE', 1);
-        const outputBundle = Object.create(null);
+        const outputBundleBase = Object.create(null);
+        const outputBundle = getOutputBundle(outputBundleBase);
         this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions);
         try {
             timeStart('initialize render', 2);
@@ -16283,7 +16086,7 @@ class Bundle {
         this.finaliseAssets(outputBundle);
         timeEnd('generate bundle', 2);
         timeEnd('GENERATE', 1);
-        return outputBundle;
+        return outputBundleBase;
     }
     async addManualChunks(manualChunks) {
         const manualChunkAliasByEntry = new Map();
@@ -16319,17 +16122,19 @@ class Bundle {
         }
         return manualChunkAliasByEntry;
     }
-    finaliseAssets(outputBundle) {
-        for (const file of Object.values(outputBundle)) {
-            if (this.outputOptions.validate && 'code' in file) {
-                try {
-                    this.graph.contextParse(file.code, {
-                        allowHashBang: true,
-                        ecmaVersion: 'latest'
-                    });
-                }
-                catch (err) {
-                    this.inputOptions.onwarn(errChunkInvalid(file, err));
+    finaliseAssets(bundle) {
+        if (this.outputOptions.validate) {
+            for (const file of Object.values(bundle)) {
+                if ('code' in file) {
+                    try {
+                        this.graph.contextParse(file.code, {
+                            allowHashBang: true,
+                            ecmaVersion: 'latest'
+                        });
+                    }
+                    catch (err) {
+                        this.inputOptions.onwarn(errChunkInvalid(file, err));
+                    }
                 }
             }
         }
@@ -22653,6 +22458,209 @@ class GlobalScope extends Scope$1 {
     }
 }
 
+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 (bundle[lowercaseBundleKeys].has(fileName.toLowerCase())) {
+        warn(errFileNameConflict(fileName));
+    }
+    else {
+        bundle[fileName] = FILE_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;
+}
+function getAssetFileName(file, referenceId) {
+    if (typeof file.fileName !== 'string') {
+        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
+    }
+    return file.fileName;
+}
+function getChunkFileName(file, facadeChunkByModule) {
+    if (file.fileName) {
+        return file.fileName;
+    }
+    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.facadeChunkByModule = null;
+        this.nextIdBase = 1;
+        this.output = null;
+        this.emitFile = (emittedFile) => {
+            if (!hasValidType(emittedFile)) {
+                return error(errFailedValidation(`Emitted files must be of type "asset" or "chunk", received "${emittedFile && emittedFile.type}".`));
+            }
+            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.output) {
+                this.finalizeAsset(consumedFile, source, referenceId, this.output);
+            }
+            else {
+                consumedFile.source = source;
+            }
+        };
+        this.setChunkInformation = (facadeChunkByModule) => {
+            this.facadeChunkByModule = facadeChunkByModule;
+        };
+        this.setOutputBundle = (bundle, outputOptions) => {
+            const fileNamesBySource = new Map();
+            const output = (this.output = { bundle, fileNamesBySource, outputOptions });
+            for (const emittedFile of this.filesByReferenceId.values()) {
+                if (emittedFile.fileName) {
+                    reserveFileNameInBundle(emittedFile.fileName, output, this.options.onwarn);
+                    if (emittedFile.type === 'asset' && typeof emittedFile.source === 'string') {
+                        fileNamesBySource.set(emittedFile.source, emittedFile.fileName);
+                    }
+                }
+            }
+            for (const [referenceId, consumedFile] of this.filesByReferenceId) {
+                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, output);
+                }
+            }
+        };
+        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 || String(this.nextIdBase++));
+        if (this.output) {
+            if (emittedAsset.fileName) {
+                reserveFileNameInBundle(emittedAsset.fileName, this.output, this.options.onwarn);
+            }
+            if (source !== undefined) {
+                this.finalizeAsset(consumedAsset, source, referenceId, this.output);
+            }
+        }
+        return referenceId;
+    }
+    emitChunk(emittedChunk) {
+        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
+            return error(errInvalidRollupPhaseForChunkEmission());
+        }
+        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 this.assignReferenceId(consumedChunk, emittedChunk.id);
+    }
+    finalizeAsset(consumedFile, source, referenceId, { bundle, fileNamesBySource, outputOptions }) {
+        const fileName = consumedFile.fileName ||
+            (typeof source === 'string' && fileNamesBySource.get(source)) ||
+            generateAssetFileName(consumedFile.name, source, outputOptions, bundle);
+        // We must not modify the original assets to avoid interaction between outputs
+        const assetWithFileName = { ...consumedFile, fileName, source };
+        this.filesByReferenceId.set(referenceId, assetWithFileName);
+        if (typeof source === 'string') {
+            fileNamesBySource.set(source, fileName);
+        }
+        bundle[fileName] = {
+            fileName,
+            name: consumedFile.name,
+            source,
+            type: 'asset'
+        };
+    }
+}
+
 function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, existingPluginNames) {
     let cacheable = true;
     if (typeof plugin.cacheKey !== 'string') {
@@ -23935,13 +23943,7 @@ function getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, out
 }
 function createOutput(outputBundle) {
     return {
-        output: Object.values(outputBundle).filter(outputFile => Object.keys(outputFile).length > 0).sort((outputFileA, outputFileB) => {
-            const fileTypeA = getSortingFileType(outputFileA);
-            const fileTypeB = getSortingFileType(outputFileB);
-            if (fileTypeA === fileTypeB)
-                return 0;
-            return fileTypeA < fileTypeB ? -1 : 1;
-        })
+        output: Object.values(outputBundle).filter(outputFile => Object.keys(outputFile).length > 0).sort((outputFileA, outputFileB) => getSortingFileType(outputFileA) - getSortingFileType(outputFileB))
     };
 }
 var SortingFileType;