rollup 2.78.1 → 2.79.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.78.1
-	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
+	Rollup.js v2.79.1
+	Thu, 22 Sep 2022 04:55:29 GMT - commit 69ff4181e701a0fe0026d0ba147f31bc86beffa8
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.78.1";
+var version$1 = "2.79.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -13446,11 +13446,18 @@ function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, na
     return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, namespaceToStringTag)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
 }
 
+function addJsExtension(name) {
+    return name.endsWith('.js') ? name : name + '.js';
+}
+
 // AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
 // The assumption is that this makes sense for all relative ids:
 // https://requirejs.org/docs/api.html#jsfiles
-function removeExtensionFromRelativeAmdId(id) {
-    return id[0] === '.' ? removeJsExtension(id) : id;
+function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
+    if (id[0] !== '.') {
+        return id;
+    }
+    return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
 }
 
 const builtins = {
@@ -13489,7 +13496,7 @@ 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)}'`);
+    const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.id, amd.forceJsExtensionForImports)}'`);
     const args = dependencies.map(m => m.name);
     const { n, getNonArrowFunctionIntro, _ } = snippets;
     if (namedExportsMode && hasExports) {
@@ -13933,7 +13940,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         });
     }
     warnOnBuiltins(warn, dependencies);
-    const amdDeps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.id)}'`);
+    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.id, amd.forceJsExtensionForImports)}'`);
     const cjsDeps = dependencies.map(m => `require('${m.id}')`);
     const trimmedImports = trimEmptyImports(dependencies);
     const globalDeps = trimmedImports.map(module => globalProp(module.globalName, globalVar, getPropertyAccess));
@@ -14468,6 +14475,34 @@ function renderChunk({ code, options, outputPluginDriver, renderChunk, sourcemap
     return outputPluginDriver.hookReduceArg0('renderChunk', [code, renderChunk, options], renderChunkReducer);
 }
 
+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.`));
@@ -14481,14 +14516,13 @@ function renderNamePattern(pattern, patternName, replacements) {
         return replacement;
     });
 }
-function makeUnique(name, existingNames) {
-    const existingNamesLowercase = new Set(Object.keys(existingNames).map(key => key.toLowerCase()));
-    if (!existingNamesLowercase.has(name.toLocaleLowerCase()))
+function makeUnique(name, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
+    if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
         return name;
     const ext = require$$0.extname(name);
     name = name.substring(0, name.length - ext.length);
     let uniqueName, uniqueIndex = 1;
-    while (existingNamesLowercase.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
+    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + ext).toLowerCase()))
         ;
     return uniqueName;
 }
@@ -14717,7 +14751,7 @@ class Chunk {
         }
         return facades;
     }
-    generateId(addons, options, existingNames, includeHash) {
+    generateId(addons, options, bundle, includeHash) {
         if (this.fileName !== null) {
             return this.fileName;
         }
@@ -14727,12 +14761,12 @@ class Chunk {
         return makeUnique(renderNamePattern(typeof pattern === 'function' ? pattern(this.getChunkInfo()) : pattern, patternName, {
             format: () => options.format,
             hash: () => includeHash
-                ? this.computeContentHashWithDependencies(addons, options, existingNames)
+                ? this.computeContentHashWithDependencies(addons, options, bundle)
                 : '[hash]',
             name: () => this.getChunkName()
-        }), existingNames);
+        }), bundle);
     }
-    generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames, unsetOptions) {
+    generateIdPreserveModules(preserveModulesRelativeDir, options, bundle, unsetOptions) {
         const [{ id }] = this.orderedModules;
         const sanitizedId = this.outputOptions.sanitizeFileName(id.split(QUERY_HASH_REGEX, 1)[0]);
         let path;
@@ -14770,7 +14804,7 @@ class Chunk {
             });
             path = `_virtual/${fileName}`;
         }
-        return makeUnique(normalize(path), existingNames);
+        return makeUnique(normalize(path), bundle);
     }
     getChunkInfo() {
         const facadeModule = this.facadeModule;
@@ -15091,7 +15125,7 @@ class Chunk {
             } while (alternativeReexportModule);
         }
     }
-    computeContentHashWithDependencies(addons, options, existingNames) {
+    computeContentHashWithDependencies(addons, options, bundle) {
         const hash = createHash();
         hash.update([addons.intro, addons.outro, addons.banner, addons.footer].join(':'));
         hash.update(options.format);
@@ -15102,7 +15136,7 @@ class Chunk {
             }
             else {
                 hash.update(current.getRenderedHash());
-                hash.update(current.generateId(addons, options, existingNames, false));
+                hash.update(current.generateId(addons, options, bundle, false));
             }
             if (current instanceof ExternalModule)
                 continue;
@@ -15140,7 +15174,7 @@ class Chunk {
         }
     }
     finaliseDynamicImports(options, snippets) {
-        const stripKnownJsExtensions = options.format === 'amd';
+        const stripKnownJsExtensions = options.format === 'amd' && !options.amd.forceJsExtensionForImports;
         for (const [module, code] of this.renderedModuleSources) {
             for (const { node, resolution } of module.dynamicImports) {
                 const chunk = this.chunkByModule.get(resolution);
@@ -15543,235 +15577,6 @@ function getChunkNameFromModule(module) {
 }
 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: () => require$$0.extname(emittedName).substring(1),
-        extname: () => require$$0.extname(emittedName),
-        hash() {
-            return createHash()
-                .update(emittedName)
-                .update(':')
-                .update(source)
-                .digest('hex')
-                .substring(0, 8);
-        },
-        name: () => emittedName.substring(0, emittedName.length - require$$0.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) {
-    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));
-            }
-        };
-        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.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.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);
-                }
-            }
-            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);
-        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'
-        };
-    }
-}
-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) {
@@ -16094,7 +15899,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, this.facadeChunkByModule);
         try {
             await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
@@ -16125,15 +15931,15 @@ class Bundle {
         ]);
         this.finaliseAssets(outputBundle);
         timeEnd('GENERATE', 1);
-        return outputBundle;
+        return outputBundleBase;
     }
-    async addFinalizedChunksToBundle(chunks, inputBase, addons, outputBundle, snippets) {
-        this.assignChunkIds(chunks, inputBase, addons, outputBundle);
+    async addFinalizedChunksToBundle(chunks, inputBase, addons, bundle, snippets) {
+        this.assignChunkIds(chunks, inputBase, addons, bundle);
         for (const chunk of chunks) {
-            outputBundle[chunk.id] = chunk.getChunkInfoWithFileNames();
+            bundle[chunk.id] = chunk.getChunkInfoWithFileNames();
         }
         await Promise.all(chunks.map(async (chunk) => {
-            const outputChunk = outputBundle[chunk.id];
+            const outputChunk = bundle[chunk.id];
             Object.assign(outputChunk, await chunk.render(this.outputOptions, addons, outputChunk, snippets));
         }));
     }
@@ -22583,6 +22389,238 @@ 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: () => require$$0.extname(emittedName).substring(1),
+        extname: () => require$$0.extname(emittedName),
+        hash() {
+            return createHash()
+                .update(emittedName)
+                .update(':')
+                .update(source)
+                .digest('hex')
+                .substring(0, 8);
+        },
+        name: () => emittedName.substring(0, emittedName.length - require$$0.extname(emittedName).length)
+    }), bundle);
+}
+function reserveFileNameInBundle(fileName, bundle, warn) {
+    const lowercaseFileName = fileName.toLowerCase();
+    if (bundle[lowercaseBundleKeys].has(lowercaseFileName)) {
+        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) {
+    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));
+            }
+        };
+        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.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.setOutputBundle = (bundle, outputOptions, facadeChunkByModule) => {
+            this.outputOptions = outputOptions;
+            this.bundle = bundle;
+            this.facadeChunkByModule = facadeChunkByModule;
+            for (const { fileName } of this.filesByReferenceId.values()) {
+                if (fileName) {
+                    reserveFileNameInBundle(fileName, bundle, this.options.onwarn);
+                }
+            }
+            for (const [referenceId, consumedFile] of this.filesByReferenceId) {
+                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                    this.finalizeAsset(consumedFile, consumedFile.source, referenceId, 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);
+        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'
+        };
+    }
+}
+// TODO This can lead to a performance problem when many assets are emitted.
+//  Instead, we should only deduplicate string assets and use their sources as
+//  object keys for better performance.
+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;
+}
+
 function getDeprecatedContextHandler(handler, handlerName, newHandlerName, pluginName, activeDeprecation, options) {
     let deprecationWarningShown = false;
     return ((...args) => {
@@ -23561,6 +23599,7 @@ const getAmd = (config) => {
         autoId: false,
         basePath: '',
         define: 'define',
+        forceJsExtensionForImports: false,
         ...config.amd
     };
     if ((mergedOption.autoId || mergedOption.basePath) && mergedOption.id) {
@@ -23574,13 +23613,15 @@ const getAmd = (config) => {
         normalized = {
             autoId: true,
             basePath: mergedOption.basePath,
-            define: mergedOption.define
+            define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports
         };
     }
     else {
         normalized = {
             autoId: false,
             define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports,
             id: mergedOption.id
         };
     }
@@ -23827,13 +23868,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;