condenser 0.0.5 → 0.0.7

data/lib/condenser/processors/node_modules/rollup/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v1.17.0
-	Mon, 15 Jul 2019 04:31:04 GMT - commit 5d1541a577b06d9004a3533bde672761e5798482
+	Rollup.js v1.20.2
+	Sun, 25 Aug 2019 05:31:46 GMT - commit b1747e49d9659799a8c128d3052e5e5703362c37
 
 
 	https://github.com/rollup/rollup
@@ -12,18 +12,46 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var util = _interopDefault(require('util'));
+var index = require('./shared/index.js');
+var util = require('util');
 var path = require('path');
-var path__default = _interopDefault(path);
 var fs = require('fs');
 var acorn = require('acorn');
-var acorn__default = _interopDefault(acorn);
 var events = require('events');
-var module$1 = _interopDefault(require('module'));
+require('module');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
 
-var version = "1.17.0";
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
 
 var minimalisticAssert = assert;
 function assert(val, msg) {
@@ -35,11 +63,7 @@ assert.equal = function assertEqual(l, r, msg) {
         throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
 };
 
-function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
-}
-
-var inherits_browser = createCommonjsModule(function (module) {
+var inherits_browser = index.createCommonjsModule(function (module) {
     if (typeof Object.create === 'function') {
         // implementation from standard node.js 'util' module
         module.exports = function inherits(ctor, superCtor) {
@@ -66,7 +90,7 @@ var inherits_browser = createCommonjsModule(function (module) {
     }
 });
 
-var inherits = createCommonjsModule(function (module) {
+var inherits = index.createCommonjsModule(function (module) {
     try {
         var util$1 = util;
         if (typeof util$1.inherits !== 'function')
@@ -1892,6 +1916,7 @@ function removeAnnotations(node, code) {
 }
 
 const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
 function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
     let searchPos, charCodeAfterSlash;
     searchPos = code.indexOf(searchString, start);
@@ -1901,44 +1926,35 @@ function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
             return searchPos;
         charCodeAfterSlash = code.charCodeAt(++start);
         ++start;
-        if (charCodeAfterSlash === 47 /*"/"*/) {
-            start = code.indexOf('\n', start) + 1;
-            if (start === 0)
-                return -1;
-            if (start > searchPos) {
-                searchPos = code.indexOf(searchString, start);
-            }
-        }
-        else if (charCodeAfterSlash === 42 /*"*"*/) {
-            start = code.indexOf('*/', start) + 2;
-            if (start > searchPos) {
-                searchPos = code.indexOf(searchString, start);
-            }
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
         }
     }
 }
-function findFirstLineBreakOutsideComment(code, start = 0) {
-    let lineBreakPos, charCodeAfterSlash;
+// This assumes "code" only contains white-space and comments
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
     lineBreakPos = code.indexOf('\n', start);
     while (true) {
         start = code.indexOf('/', start);
         if (start === -1 || start > lineBreakPos)
             return lineBreakPos;
+        // With our assumption, '/' always starts a comment. Determine comment type:
         charCodeAfterSlash = code.charCodeAt(++start);
         if (charCodeAfterSlash === 47 /*"/"*/)
             return lineBreakPos;
-        ++start;
-        if (charCodeAfterSlash === 42 /*"*"*/) {
-            start = code.indexOf('*/', start) + 2;
-            if (start > lineBreakPos) {
-                lineBreakPos = code.indexOf('\n', start);
-            }
+        start = code.indexOf('*/', start + 2) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
         }
     }
 }
 function renderStatementList(statements, code, start, end, options) {
-    if (statements.length === 0)
-        return;
     let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
     let nextNode = statements[0];
     let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
@@ -2015,6 +2031,17 @@ function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
     });
     return splitUpNodes;
 }
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const lineBreakPos = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (lineBreakPos === -1) {
+            break;
+        }
+        start = start + lineBreakPos + 1;
+        code.remove(start - 1, start);
+    }
+}
 
 const chars$1 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
 const base = 64;
@@ -2615,21 +2642,7 @@ function makeLegal(str) {
     str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
     if (startsWithDigit(str) || blacklisted[str])
         str = `_${str}`;
-    return str;
-}
-
-const absolutePath = /^(?:\/|(?:[A-Za-z]:)?[\\|/])/;
-const relativePath = /^\.?\.\//;
-function isAbsolute(path) {
-    return absolutePath.test(path);
-}
-function isRelative(path) {
-    return relativePath.test(path);
-}
-function normalize(path) {
-    if (path.indexOf('\\') == -1)
-        return path;
-    return path.replace(/\\/g, '/');
+    return str || '_';
 }
 
 class ExternalModule {
@@ -2672,11 +2685,11 @@ class ExternalModule {
                 typeof options.paths === 'function' ? options.paths(this.id) : options.paths[this.id];
         }
         if (!this.renderPath) {
-            if (!isAbsolute(this.id)) {
+            if (!index.isAbsolute(this.id)) {
                 this.renderPath = this.id;
             }
             else {
-                this.renderPath = normalize(path.relative(inputBase, this.id));
+                this.renderPath = index.normalize(path.relative(inputBase, this.id));
                 this.renormalizeRenderPath = true;
             }
         }
@@ -7739,9 +7752,9 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
 function defaultConverter(k, v) {
     return isKeyed(v) ? v.toMap() : v.toList();
 }
-var version$1 = "4.0.0-rc.11";
+var version = "4.0.0-rc.11";
 var Immutable = {
-    version: version$1,
+    version: version,
     Collection: Collection,
     // Note: Iterable is deprecated
     Iterable: Collection,
@@ -8672,6 +8685,15 @@ class ExportDefaultVariable extends LocalVariable {
     getAssignedVariableName() {
         return (this.originalId && this.originalId.name) || null;
     }
+    getBaseVariableName() {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            return super.getBaseVariableName();
+        }
+        else {
+            return original.getBaseVariableName();
+        }
+    }
     getName() {
         const original = this.getOriginalVariable();
         if (original === this) {
@@ -8715,7 +8737,6 @@ class ExportDefaultVariable extends LocalVariable {
         }
     }
 }
-ExportDefaultVariable.prototype.getBaseVariableName = ExportDefaultVariable.prototype.getName;
 
 const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
 const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
@@ -8877,11 +8898,6 @@ class NamespaceVariable extends Variable {
         this.references = [];
         this.context = context;
         this.module = context.module;
-        for (const name of this.context.getExports().concat(this.context.getReexports())) {
-            if (name[0] === '*' && name.length > 1)
-                this.containsExternalNamespace = true;
-            this.memberVariables[name] = this.context.traceExport(name);
-        }
     }
     addReference(identifier) {
         this.references.push(identifier);
@@ -8922,6 +8938,13 @@ class NamespaceVariable extends Variable {
             }
         }
     }
+    initialise() {
+        for (const name of this.context.getExports().concat(this.context.getReexports())) {
+            if (name[0] === '*' && name.length > 1)
+                this.containsExternalNamespace = true;
+            this.memberVariables[name] = this.context.traceExport(name);
+        }
+    }
     renderBlock(options) {
         const _ = options.compact ? '' : ' ';
         const n = options.compact ? '' : '\n';
@@ -8979,7 +9002,7 @@ function getExportBlock(exports, dependencies, namedExportsMode, interop, compac
                     return false;
                 return dep.reexports.some(expt => {
                     if (expt.reexported === 'default') {
-                        local = dep.namedExportsMode ? `${dep.name}.${expt.imported}` : dep.name;
+                        local = dep.namedExportsMode && expt.imported !== '*' ? `${dep.name}.${expt.imported}` : dep.name;
                         return true;
                     }
                     return false;
@@ -8996,13 +9019,20 @@ function getExportBlock(exports, dependencies, namedExportsMode, interop, compac
                 if (specifier.reexported === '*') {
                     if (!compact && exportBlock)
                         exportBlock += '\n';
-                    exportBlock +=
-                        `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
-                            `${t}if${_}(k${_}!==${_}'default')${_}Object.defineProperty(exports,${_}k,${_}{${n}` +
-                            `${t}${t}enumerable:${_}true,${n}` +
-                            `${t}${t}get:${_}function${_}()${_}{${n}` +
-                            `${t}${t}${t}return ${name}[k];${n}` +
-                            `${t}${t}}${n}${t}});${n}});`;
+                    if (specifier.needsLiveBinding) {
+                        exportBlock +=
+                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
+                                `${t}if${_}(k${_}!==${_}'default')${_}Object.defineProperty(exports,${_}k,${_}{${n}` +
+                                `${t}${t}enumerable:${_}true,${n}` +
+                                `${t}${t}get:${_}function${_}()${_}{${n}` +
+                                `${t}${t}${t}return ${name}[k];${n}` +
+                                `${t}${t}}${n}${t}});${n}});`;
+                    }
+                    else {
+                        exportBlock +=
+                            `Object.keys(${name}).forEach(function${_}(k)${_}{${n}` +
+                                `${t}if${_}(k${_}!==${_}'default')${_}exports[k]${_}=${_}${name}[k];${n}});`;
+                    }
                 }
             });
         }
@@ -9077,25 +9107,31 @@ function getInteropBlock(dependencies, options, varOrConst) {
         .join(options.compact ? '' : '\n');
 }
 
-function getInteropNamespace(_, n, t) {
-    return `function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
+function copyPropertyLiveBinding(_, n, t, i) {
+    return (`${i}var d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${i}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${i}${t}enumerable:${_}true,${n}` +
+        `${i}${t}get:${_}function${_}()${_}{${n}` +
+        `${i}${t}${t}return e[k];${n}` +
+        `${i}${t}}${n}` +
+        `${i}});${n}`);
+}
+function copyPropertyStatic(_, n, _t, i) {
+    return `${i}n[k]${_}=e${_}[k];${n}`;
+}
+function getInteropNamespace(_, n, t, liveBindings) {
+    return (`function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
         `${t}if${_}(e${_}&&${_}e.__esModule)${_}{${_}return e;${_}}${_}else${_}{${n}` +
         `${t}${t}var n${_}=${_}{};${n}` +
         `${t}${t}if${_}(e)${_}{${n}` +
         `${t}${t}${t}Object.keys(e).forEach(function${_}(k)${_}{${n}` +
-        `${t}${t}${t}${t}var d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
-        `${t}${t}${t}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
-        `${t}${t}${t}${t}${t}enumerable:${_}true,${n}` +
-        `${t}${t}${t}${t}${t}get:${_}function${_}()${_}{${n}` +
-        `${t}${t}${t}${t}${t}${t}return e[k];${n}` +
-        `${t}${t}${t}${t}${t}}${n}` +
-        `${t}${t}${t}${t}});${n}` +
+        (liveBindings ? copyPropertyLiveBinding : copyPropertyStatic)(_, n, t, t + t + t + t) +
         `${t}${t}${t}});${n}` +
         `${t}${t}}${n}` +
         `${t}${t}n['default']${_}=${_}e;${n}` +
         `${t}${t}return n;${n}` +
         `${t}}${n}` +
-        `}${n}${n}`;
+        `}${n}${n}`);
 }
 
 const builtins$1 = {
@@ -9178,7 +9214,7 @@ function amd(magicString, { accessedGlobals, dependencies, exports, hasExports,
         magicString.prepend(interopBlock + n + n);
     }
     if (accessedGlobals.has(INTEROP_NAMESPACE_VARIABLE)) {
-        magicString.prepend(getInteropNamespace(_, n, t));
+        magicString.prepend(getInteropNamespace(_, n, t, options.externalLiveBindings !== false));
     }
     if (intro)
         magicString.prepend(intro);
@@ -9242,7 +9278,7 @@ function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports,
                 `?${_}${ex}['default']${_}:${_}${ex}${options.compact ? '' : '; '}}${n}${n}`;
     }
     if (accessedGlobals.has(INTEROP_NAMESPACE_VARIABLE)) {
-        intro += getInteropNamespace(_, n, t);
+        intro += getInteropNamespace(_, n, t, options.externalLiveBindings !== false);
     }
     if (importBlock)
         intro += importBlock + n + n;
@@ -9388,23 +9424,8 @@ function getCodeFrame(source, line, column) {
         .join('\n');
 }
 
-function getAliasName(id) {
-    const base = path.basename(id);
-    return base.substr(0, base.length - path.extname(id).length);
-}
-function relativeId(id) {
-    if (typeof process === 'undefined' || !isAbsolute(id))
-        return id;
-    return path.relative(process.cwd(), id);
-}
-function isPlainName(name) {
-    // not starting with "./", "/". "../"
-    return !(name[0] === '/' ||
-        (name[1] === '.' && (name[2] === '/' || (name[2] === '.' && name[3] === '/'))));
-}
-
 function error(base, props) {
-    if (base instanceof Error === false)
+    if (!(base instanceof Error))
         base = Object.assign(new Error(base.message), base);
     if (props)
         Object.assign(base, props);
@@ -9432,35 +9453,38 @@ var Errors;
     Errors["ASSET_SOURCE_ALREADY_SET"] = "ASSET_SOURCE_ALREADY_SET";
     Errors["ASSET_SOURCE_MISSING"] = "ASSET_SOURCE_MISSING";
     Errors["BAD_LOADER"] = "BAD_LOADER";
-    Errors["CHUNK_NOT_FOUND"] = "CHUNK_NOT_FOUND";
+    Errors["CANNOT_EMIT_FROM_OPTIONS_HOOK"] = "CANNOT_EMIT_FROM_OPTIONS_HOOK";
     Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
     Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
-    Errors["INVALID_ASSET_NAME"] = "INVALID_ASSET_NAME";
+    Errors["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+    Errors["FILE_NAME_CONFLICT"] = "FILE_NAME_CONFLICT";
     Errors["INVALID_CHUNK"] = "INVALID_CHUNK";
     Errors["INVALID_EXTERNAL_ID"] = "INVALID_EXTERNAL_ID";
     Errors["INVALID_OPTION"] = "INVALID_OPTION";
     Errors["INVALID_PLUGIN_HOOK"] = "INVALID_PLUGIN_HOOK";
     Errors["INVALID_ROLLUP_PHASE"] = "INVALID_ROLLUP_PHASE";
     Errors["NAMESPACE_CONFLICT"] = "NAMESPACE_CONFLICT";
+    Errors["PLUGIN_ERROR"] = "PLUGIN_ERROR";
     Errors["UNRESOLVED_ENTRY"] = "UNRESOLVED_ENTRY";
     Errors["UNRESOLVED_IMPORT"] = "UNRESOLVED_IMPORT";
+    Errors["VALIDATION_ERROR"] = "VALIDATION_ERROR";
 })(Errors || (Errors = {}));
-function errAssetNotFinalisedForFileName(asset) {
+function errAssetNotFinalisedForFileName(name) {
     return {
         code: Errors.ASSET_NOT_FINALISED,
-        message: `Plugin error - Unable to get file name for asset "${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.`
     };
 }
-function errChunkNotGeneratedForFileName(entry) {
+function errCannotEmitFromOptionsHook() {
     return {
-        code: Errors.CHUNK_NOT_GENERATED,
-        message: `Plugin error - Unable to get file name for chunk "${entry.name}". Ensure that generate is called first.`
+        code: Errors.CANNOT_EMIT_FROM_OPTIONS_HOOK,
+        message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
     };
 }
-function errAssetReferenceIdNotFoundForFilename(assetReferenceId) {
+function errChunkNotGeneratedForFileName(name) {
     return {
-        code: Errors.ASSET_NOT_FOUND,
-        message: `Plugin error - Unable to get file name for unknown asset "${assetReferenceId}".`
+        code: Errors.CHUNK_NOT_GENERATED,
+        message: `Plugin error - Unable to get file name for chunk "${name}". Ensure that generate is called first.`
     };
 }
 function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
@@ -9469,55 +9493,49 @@ function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
         message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
     };
 }
-function errAssetSourceAlreadySet(asset) {
+function errAssetSourceAlreadySet(name) {
     return {
         code: Errors.ASSET_SOURCE_ALREADY_SET,
-        message: `Plugin error - Unable to set the source for asset "${asset.name}", source already set.`
-    };
-}
-function errAssetSourceMissingForSetSource(asset) {
-    return {
-        code: Errors.ASSET_SOURCE_MISSING,
-        message: `Plugin error creating asset "${asset.name}", setAssetSource call without a source.`
+        message: `Unable to set the source for asset "${name}", source already set.`
     };
 }
-function errNoAssetSourceSet(asset) {
+function errNoAssetSourceSet(assetName) {
     return {
         code: Errors.ASSET_SOURCE_MISSING,
-        message: `Plugin error creating asset "${asset.name}" - no asset source set.`
+        message: `Plugin error creating asset "${assetName}" - no asset source set.`
     };
 }
 function errBadLoader(id) {
     return {
         code: Errors.BAD_LOADER,
-        message: `Error loading ${relativeId(id)}: plugin load hook should return a string, a { code, map } object, or nothing/null`
-    };
-}
-function errChunkReferenceIdNotFoundForFilename(chunkReferenceId) {
-    return {
-        code: Errors.CHUNK_NOT_FOUND,
-        message: `Plugin error - Unable to get file name for unknown chunk "${chunkReferenceId}".`
+        message: `Error loading ${index.relativeId(id)}: plugin load hook should return a string, a { code, map } object, or nothing/null`
     };
 }
 function errDeprecation(deprecation) {
     return Object.assign({ code: Errors.DEPRECATED_FEATURE }, (typeof deprecation === 'string' ? { message: deprecation } : deprecation));
 }
-function errInvalidAssetName(name) {
+function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
+    return {
+        code: Errors.FILE_NOT_FOUND,
+        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+    };
+}
+function errFileNameConflict(fileName) {
     return {
-        code: Errors.INVALID_ASSET_NAME,
-        message: `Plugin error creating asset, name "${name}" is not a plain (non relative or absolute URL) string name.`
+        code: Errors.FILE_NAME_CONFLICT,
+        message: `Could not emit file "${fileName}" as it conflicts with an already emitted file.`
     };
 }
 function errCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
     return {
         code: Errors.INVALID_CHUNK,
-        message: `Cannot assign ${relativeId(moduleId)} to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
+        message: `Cannot assign ${index.relativeId(moduleId)} to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
     };
 }
 function errInternalIdCannotBeExternal(source, importer) {
     return {
         code: Errors.INVALID_EXTERNAL_ID,
-        message: `'${source}' is imported as an external by ${relativeId(importer)}, but is already an existing non-external module id.`
+        message: `'${source}' is imported as an external by ${index.relativeId(importer)}, but is already an existing non-external module id.`
     };
 }
 function errInvalidOption(option, explanation) {
@@ -9532,16 +9550,16 @@ function errInvalidRollupPhaseForAddWatchFile() {
         message: `Cannot call addWatchFile after the build has finished.`
     };
 }
-function errInvalidRollupPhaseForEmitChunk() {
+function errInvalidRollupPhaseForChunkEmission() {
     return {
         code: Errors.INVALID_ROLLUP_PHASE,
-        message: `Cannot call emitChunk after module loading has finished.`
+        message: `Cannot emit chunks after module loading has finished.`
     };
 }
 function errNamespaceConflict(name, reexportingModule, additionalExportAllModule) {
     return {
         code: Errors.NAMESPACE_CONFLICT,
-        message: `Conflicting namespaces: ${relativeId(reexportingModule.id)} re-exports '${name}' from both ${relativeId(reexportingModule.exportsAll[name])} and ${relativeId(additionalExportAllModule.exportsAll[name])} (will be ignored)`,
+        message: `Conflicting namespaces: ${index.relativeId(reexportingModule.id)} re-exports '${name}' from both ${index.relativeId(reexportingModule.exportsAll[name])} and ${index.relativeId(additionalExportAllModule.exportsAll[name])} (will be ignored)`,
         name,
         reexporter: reexportingModule.id,
         sources: [reexportingModule.exportsAll[name], additionalExportAllModule.exportsAll[name]]
@@ -9550,30 +9568,36 @@ function errNamespaceConflict(name, reexportingModule, additionalExportAllModule
 function errEntryCannotBeExternal(unresolvedId) {
     return {
         code: Errors.UNRESOLVED_ENTRY,
-        message: `Entry module cannot be external (${relativeId(unresolvedId)}).`
+        message: `Entry module cannot be external (${index.relativeId(unresolvedId)}).`
     };
 }
 function errUnresolvedEntry(unresolvedId) {
     return {
         code: Errors.UNRESOLVED_ENTRY,
-        message: `Could not resolve entry module (${relativeId(unresolvedId)}).`
+        message: `Could not resolve entry module (${index.relativeId(unresolvedId)}).`
     };
 }
 function errUnresolvedImport(source, importer) {
     return {
         code: Errors.UNRESOLVED_IMPORT,
-        message: `Could not resolve '${source}' from ${relativeId(importer)}`
+        message: `Could not resolve '${source}' from ${index.relativeId(importer)}`
     };
 }
 function errUnresolvedImportTreatedAsExternal(source, importer) {
     return {
         code: Errors.UNRESOLVED_IMPORT,
-        importer: relativeId(importer),
-        message: `'${source}' is imported by ${relativeId(importer)}, but could not be resolved – treating it as an external dependency`,
+        importer: index.relativeId(importer),
+        message: `'${source}' is imported by ${index.relativeId(importer)}, but could not be resolved – treating it as an external dependency`,
         source,
         url: 'https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency'
     };
 }
+function errFailedValidation(message) {
+    return {
+        code: Errors.VALIDATION_ERROR,
+        message
+    };
+}
 
 // Generate strings which dereference dotted properties, but use array notation `['prop-deref']`
 // if the property name isn't trivial
@@ -10684,17 +10708,19 @@ class ConditionalExpression extends NodeBase {
             this.usedBranch.include(includeChildrenRecursively);
         }
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
         if (!this.test.included) {
             const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
+            const inclusionStart = (this.consequent.included
+                ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
+                : colonPos) + 1;
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, this.usedBranch.start);
+            }
+            code.remove(this.start, inclusionStart);
             if (this.consequent.included) {
-                const questionmarkPos = findFirstOccurrenceOutsideComment(code.original, '?', this.test.end);
-                code.remove(this.start, questionmarkPos + 1);
                 code.remove(colonPos, this.end);
             }
-            else {
-                code.remove(this.start, colonPos + 1);
-            }
             removeAnnotations(this, code);
             this.usedBranch.render(code, options, {
                 isCalleeOfRenderedParent: renderedParentType
@@ -10946,16 +10972,34 @@ class IfStatement extends NodeBase {
     }
 }
 
+class ImportDeclaration extends NodeBase {
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        this.context.addImport(this);
+    }
+    render(code, _options, { start, end } = BLANK) {
+        code.remove(start, end);
+    }
+}
+ImportDeclaration.prototype.needsBoundaries = true;
+
 class Import extends NodeBase {
     constructor() {
         super(...arguments);
         this.exportMode = 'auto';
     }
-    include() {
+    hasEffects() {
+        return true;
+    }
+    include(includeChildrenRecursively) {
         if (!this.included) {
             this.included = true;
             this.context.includeDynamicImport(this);
         }
+        this.source.include(includeChildrenRecursively);
     }
     initialise() {
         this.context.addDynamicImport(this);
@@ -10964,21 +11008,22 @@ class Import extends NodeBase {
         if (this.inlineNamespace) {
             const _ = options.compact ? '' : ' ';
             const s = options.compact ? '' : ';';
-            code.overwrite(this.parent.start, this.parent.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.inlineNamespace.getName()}${s}${_}})`);
+            code.overwrite(this.start, this.end, `Promise.resolve().then(function${_}()${_}{${_}return ${this.inlineNamespace.getName()}${s}${_}})`);
             return;
         }
         const importMechanism = this.getDynamicImportMechanism(options);
         if (importMechanism) {
-            code.overwrite(this.parent.start, findFirstOccurrenceOutsideComment(code.original, '(', this.parent.callee.end) + 1, importMechanism.left);
-            code.overwrite(this.parent.end - 1, this.parent.end, importMechanism.right);
+            code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, importMechanism.left);
+            code.overwrite(this.end - 1, this.end, importMechanism.right);
         }
+        this.source.render(code, options);
     }
     renderFinalResolution(code, resolution, format) {
         if (this.included) {
             if (format === 'amd' && resolution.startsWith("'.") && resolution.endsWith(".js'")) {
                 resolution = resolution.slice(0, -4) + "'";
             }
-            code.overwrite(this.parent.arguments[0].start, this.parent.arguments[0].end, resolution);
+            code.overwrite(this.source.start, this.source.end, resolution);
         }
     }
     setResolution(exportMode, inlineNamespace) {
@@ -11054,20 +11099,6 @@ class Import extends NodeBase {
     }
 }
 
-class ImportDeclaration extends NodeBase {
-    bind() { }
-    hasEffects() {
-        return false;
-    }
-    initialise() {
-        this.context.addImport(this);
-    }
-    render(code, _options, { start, end } = BLANK) {
-        code.remove(start, end);
-    }
-}
-ImportDeclaration.prototype.needsBoundaries = true;
-
 class LabeledStatement extends NodeBase {
     hasEffects(options) {
         return this.body.hasEffects(options.setIgnoreLabel(this.label.name).setIgnoreBreakStatements());
@@ -11216,11 +11247,14 @@ class LogicalExpression extends NodeBase {
             this.usedBranch.include(includeChildrenRecursively);
         }
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
         if (!this.left.included || !this.right.included) {
             const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
             if (this.right.included) {
                 code.remove(this.start, operatorPos + 2);
+                if (preventASI) {
+                    removeLineBreaks(code, operatorPos + 2, this.right.start);
+                }
             }
             else {
                 code.remove(operatorPos, this.end);
@@ -11461,11 +11495,11 @@ class MemberExpression extends NodeBase {
                 : baseVariable.context.fileName;
             this.context.warn({
                 code: 'MISSING_EXPORT',
-                exporter: relativeId(fileName),
-                importer: relativeId(this.context.fileName),
-                message: `'${exportName}' is not exported by '${relativeId(fileName)}'`,
+                exporter: index.relativeId(fileName),
+                importer: index.relativeId(this.context.fileName),
+                message: `'${exportName}' is not exported by '${index.relativeId(fileName)}'`,
                 missing: exportName,
-                url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module-`
+                url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
             }, path[0].pos);
             return 'undefined';
         }
@@ -11561,7 +11595,7 @@ function createResolveId(preserveSymlinks) {
         }
         // external modules (non-entry modules that start with neither '.' or '/')
         // are skipped at this stage.
-        if (importer !== undefined && !isAbsolute(source) && source[0] !== '.')
+        if (importer !== undefined && !index.isAbsolute(source) && source[0] !== '.')
             return null;
         // `resolve` processes paths from right to left, prepending them until an
         // absolute path is created. Absolute importees therefore shortcircuit the
@@ -11585,7 +11619,11 @@ const importMetaMechanisms = {
 };
 const getRelativeUrlFromDocument = (relativePath) => getResolveUrl(`'${relativePath}', document.currentScript && document.currentScript.src || document.baseURI`);
 const relativeUrlMechanisms = {
-    amd: relativePath => getResolveUrl(`require.toUrl('${relativePath}'), document.baseURI`),
+    amd: relativePath => {
+        if (relativePath[0] !== '.')
+            relativePath = './' + relativePath;
+        return getResolveUrl(`require.toUrl('${relativePath}'), document.baseURI`);
+    },
     cjs: relativePath => `(typeof document === 'undefined' ? ${getResolveUrl(`'file:' + __dirname + '/${relativePath}'`, `(require('u' + 'rl').URL)`)} : ${getRelativeUrlFromDocument(relativePath)})`,
     es: relativePath => getResolveUrl(`'${relativePath}', import.meta.url`),
     iife: relativePath => getRelativeUrlFromDocument(relativePath),
@@ -11609,7 +11647,11 @@ const accessedFileUrlGlobals = {
 
 const ASSET_PREFIX = 'ROLLUP_ASSET_URL_';
 const CHUNK_PREFIX = 'ROLLUP_CHUNK_URL_';
+const FILE_PREFIX = 'ROLLUP_FILE_URL_';
 class MetaProperty extends NodeBase {
+    hasEffects() {
+        return false;
+    }
     hasEffectsWhenAccessedAtPath(path) {
         return path.length > 1;
     }
@@ -11625,7 +11667,9 @@ class MetaProperty extends NodeBase {
                 if (metaProperty === 'url') {
                     this.scope.addAccessedGlobalsByFormat(accessedMetaUrlGlobals);
                 }
-                else if (metaProperty.startsWith(ASSET_PREFIX) || metaProperty.startsWith(CHUNK_PREFIX)) {
+                else if (metaProperty.startsWith(FILE_PREFIX) ||
+                    metaProperty.startsWith(ASSET_PREFIX) ||
+                    metaProperty.startsWith(CHUNK_PREFIX)) {
                     this.scope.addAccessedGlobalsByFormat(accessedFileUrlGlobals);
                 }
             }
@@ -11640,21 +11684,30 @@ class MetaProperty extends NodeBase {
         if (!this.included)
             return;
         const parent = this.parent;
-        const importMetaProperty = this.metaProperty;
-        if (importMetaProperty &&
-            (importMetaProperty.startsWith(ASSET_PREFIX) || importMetaProperty.startsWith(CHUNK_PREFIX))) {
+        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 (importMetaProperty.startsWith(ASSET_PREFIX)) {
-                assetReferenceId = importMetaProperty.substr(ASSET_PREFIX.length);
-                fileName = this.context.getAssetFileName(assetReferenceId);
+            if (metaProperty.startsWith(FILE_PREFIX)) {
+                referenceId = metaProperty.substr(FILE_PREFIX.length);
+                fileName = this.context.getFileName(referenceId);
+            }
+            else if (metaProperty.startsWith(ASSET_PREFIX)) {
+                this.context.warnDeprecation(`Using the "${ASSET_PREFIX}" prefix to reference files is deprecated. Use the "${FILE_PREFIX}" prefix instead.`, false);
+                assetReferenceId = metaProperty.substr(ASSET_PREFIX.length);
+                fileName = this.context.getFileName(assetReferenceId);
             }
             else {
-                chunkReferenceId = importMetaProperty.substr(CHUNK_PREFIX.length);
-                fileName = this.context.getChunkFileName(chunkReferenceId);
+                this.context.warnDeprecation(`Using the "${CHUNK_PREFIX}" prefix to reference files is deprecated. Use the "${FILE_PREFIX}" prefix instead.`, false);
+                chunkReferenceId = metaProperty.substr(CHUNK_PREFIX.length);
+                fileName = this.context.getFileName(chunkReferenceId);
             }
-            const relativePath = normalize(path.relative(path.dirname(chunkId), fileName));
+            const relativePath = index.normalize(path.relative(path.dirname(chunkId), fileName));
             let replacement;
             if (assetReferenceId !== null) {
                 replacement = pluginDriver.hookFirstSync('resolveAssetUrl', [
@@ -11676,6 +11729,7 @@ class MetaProperty extends NodeBase {
                         fileName,
                         format,
                         moduleId: this.context.module.id,
+                        referenceId: referenceId || assetReferenceId || chunkReferenceId,
                         relativePath
                     }
                 ]);
@@ -11684,7 +11738,7 @@ class MetaProperty extends NodeBase {
             return;
         }
         const replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
-            importMetaProperty,
+            metaProperty,
             {
                 chunkId,
                 format,
@@ -12184,7 +12238,7 @@ class ReturnStatement$1 extends NodeBase {
     }
     render(code, options) {
         if (this.argument) {
-            this.argument.render(code, options);
+            this.argument.render(code, options, { preventASI: true });
             if (this.argument.start === this.start + 6 /* 'return'.length */) {
                 code.prependLeft(this.start + 6, ' ');
             }
@@ -12227,7 +12281,7 @@ class SequenceExpression extends NodeBase {
         }
         this.expressions[this.expressions.length - 1].include(includeChildrenRecursively);
     }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
         let includedNodes = 0;
         for (const { node, start, end } of getCommaSeparatedNodesWithBoundaries(this.expressions, code, this.start, this.end)) {
             if (!node.included) {
@@ -12235,6 +12289,9 @@ class SequenceExpression extends NodeBase {
                 continue;
             }
             includedNodes++;
+            if (includedNodes === 1 && preventASI) {
+                removeLineBreaks(code, start, node.start);
+            }
             if (node === this.expressions[this.expressions.length - 1] && includedNodes === 1) {
                 node.render(code, options, {
                     isCalleeOfRenderedParent: renderedParentType
@@ -12408,6 +12465,9 @@ class ThrowStatement extends NodeBase {
     hasEffects(_options) {
         return true;
     }
+    render(code, options) {
+        this.argument.render(code, options, { preventASI: true });
+    }
 }
 
 class TryStatement extends NodeBase {
@@ -12766,8 +12826,8 @@ const nodeConstructors = {
     FunctionExpression: FunctionExpression$1,
     Identifier: Identifier$1,
     IfStatement,
-    Import,
     ImportDeclaration,
+    ImportExpression: Import,
     LabeledStatement,
     Literal,
     LogicalExpression,
@@ -13065,7 +13125,10 @@ base$1.ImportDeclaration = function (node, st, c) {
   }
   c(node.source, st, "Expression");
 };
-base$1.ImportSpecifier = base$1.ImportDefaultSpecifier = base$1.ImportNamespaceSpecifier = base$1.Identifier = base$1.Literal = base$1.Import = ignore;
+base$1.ImportExpression = function (node, st, c) {
+  c(node.source, st, "Expression");
+};
+base$1.ImportSpecifier = base$1.ImportDefaultSpecifier = base$1.ImportNamespaceSpecifier = base$1.Identifier = base$1.Literal = ignore;
 
 base$1.TaggedTemplateExpression = function (node, st, c) {
   c(node.tag, st, "Expression");
@@ -13243,7 +13306,7 @@ function initialiseTimers(inputOptions) {
 }
 
 const defaultAcornOptions = {
-    ecmaVersion: 2019,
+    ecmaVersion: 2020,
     preserveParens: false,
     sourceType: 'module'
 };
@@ -13268,8 +13331,8 @@ function tryParse(module, Parser, acornOptions) {
 function handleMissingExport(exportName, importingModule, importedModule, importerStart) {
     importingModule.error({
         code: 'MISSING_EXPORT',
-        message: `'${exportName}' is not exported by ${relativeId(importedModule)}`,
-        url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module-`
+        message: `'${exportName}' is not exported by ${index.relativeId(importedModule)}`,
+        url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
     }, importerStart);
 }
 const MISSING_EXPORT_SHIM_DESCRIPTION = {
@@ -13278,7 +13341,8 @@ const MISSING_EXPORT_SHIM_DESCRIPTION = {
 };
 class Module {
     constructor(graph, id, moduleSideEffects, isEntry) {
-        this.chunkAlias = null;
+        this.chunkFileNames = new Set();
+        this.chunkName = null;
         this.comments = [];
         this.dependencies = [];
         this.dynamicallyImportedBy = [];
@@ -13300,6 +13364,7 @@ class Module {
         this.manualChunkAlias = null;
         this.reexports = Object.create(null);
         this.sources = [];
+        this.userChunkNames = new Set();
         this.usesTopLevelAwait = false;
         this.namespaceVariable = undefined;
         this.transformDependencies = null;
@@ -13371,7 +13436,7 @@ class Module {
     }
     getDynamicImportExpressions() {
         return this.dynamicImports.map(({ node }) => {
-            const importArgument = node.parent.arguments[0];
+            const importArgument = node.source;
             if (importArgument instanceof TemplateLiteral &&
                 importArgument.quasis.length === 1 &&
                 importArgument.quasis[0].value.cooked) {
@@ -13405,7 +13470,11 @@ class Module {
         return Object.keys(this.exports);
     }
     getOrCreateNamespace() {
-        return (this.namespaceVariable || (this.namespaceVariable = new NamespaceVariable(this.astContext)));
+        if (!this.namespaceVariable) {
+            this.namespaceVariable = new NamespaceVariable(this.astContext);
+            this.namespaceVariable.initialise();
+        }
+        return this.namespaceVariable;
     }
     getReexports() {
         if (this.transitiveReexports) {
@@ -13553,16 +13622,13 @@ class Module {
         this.usesTopLevelAwait = this.astContext.usesTopLevelAwait;
         return magicString;
     }
-    setSource({ ast, code, customTransformCache, moduleSideEffects, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformAssets, transformChunks, transformDependencies }) {
+    setSource({ ast, code, customTransformCache, moduleSideEffects, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles }) {
         this.code = code;
         this.originalCode = originalCode;
         this.originalSourcemap = originalSourcemap;
         this.sourcemapChain = sourcemapChain;
-        if (transformAssets) {
-            this.transformAssets = transformAssets;
-        }
-        if (transformChunks) {
-            this.transformChunks = transformChunks;
+        if (transformFiles) {
+            this.transformFiles = transformFiles;
         }
         this.transformDependencies = transformDependencies;
         this.customTransformCache = customTransformCache;
@@ -13594,9 +13660,8 @@ class Module {
             deoptimizationTracker: this.graph.deoptimizationTracker,
             error: this.error.bind(this),
             fileName,
-            getAssetFileName: this.graph.pluginDriver.getAssetFileName,
-            getChunkFileName: this.graph.moduleLoader.getChunkFileName.bind(this.graph.moduleLoader),
             getExports: this.getExports.bind(this),
+            getFileName: this.graph.pluginDriver.getFileName,
             getModuleExecIndex: () => this.execIndex,
             getModuleName: this.basename.bind(this),
             getReexports: this.getReexports.bind(this),
@@ -13617,7 +13682,8 @@ class Module {
             tryCatchDeoptimization: (!this.graph.treeshakingOptions ||
                 this.graph.treeshakingOptions.tryCatchDeoptimization),
             usesTopLevelAwait: false,
-            warn: this.warn.bind(this)
+            warn: this.warn.bind(this),
+            warnDeprecation: this.graph.warnDeprecation.bind(this.graph)
         };
         this.scope = new ModuleScope(this.graph.scope, this.astContext);
         this.ast = new Program$1(this.esTreeAst, { type: 'Module', context: this.astContext }, this.scope);
@@ -13635,9 +13701,8 @@ class Module {
             originalSourcemap: this.originalSourcemap,
             resolvedIds: this.resolvedIds,
             sourcemapChain: this.sourcemapChain,
-            transformAssets: this.transformAssets,
-            transformChunks: this.transformChunks,
-            transformDependencies: this.transformDependencies
+            transformDependencies: this.transformDependencies,
+            transformFiles: this.transformFiles
         };
     }
     traceVariable(name) {
@@ -13810,9 +13875,9 @@ class Module {
         if (!this.exports[name]) {
             this.graph.warn({
                 code: 'SHIMMED_EXPORT',
-                exporter: relativeId(this.id),
+                exporter: index.relativeId(this.id),
                 exportName: name,
-                message: `Missing export "${name}" has been shimmed in module ${relativeId(this.id)}.`
+                message: `Missing export "${name}" has been shimmed in module ${index.relativeId(this.id)}.`
             });
             this.exports[name] = MISSING_EXPORT_SHIM_DESCRIPTION;
         }
@@ -14126,10 +14191,10 @@ function analyseModuleExecution(entryModules) {
     return { orderedModules, cyclePaths };
 }
 function getCyclePath(id, parentId, parents) {
-    const path = [relativeId(id)];
+    const path = [index.relativeId(id)];
     let curId = parentId;
     while (curId !== id) {
-        path.push(relativeId(curId));
+        path.push(index.relativeId(curId));
         curId = parents[curId];
         if (!curId)
             break;
@@ -14234,24 +14299,16 @@ function renderChunk({ graph, chunk, renderChunk, code, sourcemapChain, options
     });
 }
 
-function renderNamePattern(pattern, patternName, getReplacement) {
-    if (!isPlainName(pattern))
-        error({
-            code: 'INVALID_PATTERN',
-            message: `Invalid output pattern "${pattern}" for ${patternName}, cannot be an absolute or relative URL or path.`
-        });
+function renderNamePattern(pattern, patternName, replacements) {
+    if (!index.isPlainPathFragment(pattern))
+        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths and must not contain invalid characters.`));
     return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
-        const replacement = getReplacement(type);
-        if (replacement === undefined)
-            error({
-                code: 'INVALID_PATTERN_REPLACEMENT',
-                message: `"${type}" is not a valid substitution name in output option ${patternName} pattern.`
-            });
-        if (!isPlainName(replacement))
-            error({
-                code: 'INVALID_PATTERN_REPLACEMENT',
-                message: `Invalid replacement "${replacement}" for "${type}" in ${patternName} pattern, must be a plain path name.`
-            });
+        if (!replacements.hasOwnProperty(type)) {
+            return error(errFailedValidation(`"[${type}]" is not a valid placeholder in "${patternName}" pattern.`));
+        }
+        const replacement = replacements[type]();
+        if (!index.isPlainPathFragment(replacement))
+            return error(errFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
         return replacement;
     });
 }
@@ -14266,10 +14323,6 @@ function makeUnique(name, existingNames) {
     return uniqueName;
 }
 
-function sanitizeFileName(name) {
-    return name.replace(/[\0?*]/g, '_');
-}
-
 function getGlobalName(module, globals, graph, hasExports) {
     let globalName;
     if (typeof globals === 'function') {
@@ -14299,15 +14352,18 @@ class Chunk$1 {
         this.entryModules = [];
         this.exportMode = 'named';
         this.facadeModule = null;
-        this.id = undefined;
+        this.id = null;
         this.indentString = undefined;
         this.manualChunkAlias = null;
         this.usedModules = undefined;
+        this.variableName = 'chunk';
         this.dependencies = undefined;
         this.dynamicDependencies = undefined;
         this.exportNames = Object.create(null);
         this.exports = new Set();
+        this.fileName = null;
         this.imports = new Set();
+        this.name = null;
         this.needsExportsShim = false;
         this.renderedDeclarations = undefined;
         this.renderedHash = undefined;
@@ -14332,20 +14388,22 @@ class Chunk$1 {
                 this.entryModules.push(module);
             }
         }
-        const entryModule = this.entryModules[0];
-        if (entryModule) {
-            this.variableName = makeLegal(path.basename(entryModule.chunkAlias || entryModule.manualChunkAlias || getAliasName(entryModule.id)));
-        }
-        else {
-            this.variableName = '__chunk_' + ++graph.curChunkIndex;
+        const moduleForNaming = this.entryModules[0] || this.orderedModules[this.orderedModules.length - 1];
+        if (moduleForNaming) {
+            this.variableName = makeLegal(path.basename(moduleForNaming.chunkName ||
+                moduleForNaming.manualChunkAlias ||
+                index.getAliasName(moduleForNaming.id)));
         }
     }
-    static generateFacade(graph, facadedModule) {
+    static generateFacade(graph, facadedModule, facadeName) {
         const chunk = new Chunk$1(graph, []);
+        chunk.assignFacadeName(facadeName, facadedModule);
+        if (!facadedModule.facadeChunk) {
+            facadedModule.facadeChunk = chunk;
+        }
         chunk.dependencies = [facadedModule.chunk];
         chunk.dynamicDependencies = [];
         chunk.facadeModule = facadedModule;
-        facadedModule.facadeChunk = chunk;
         for (const exportName of facadedModule.getAllExportNames()) {
             const tracedVariable = facadedModule.getVariableForExportName(exportName);
             chunk.exports.add(tracedVariable);
@@ -14353,10 +14411,7 @@ class Chunk$1 {
         }
         return chunk;
     }
-    canModuleBeFacade(moduleExportNamesByVariable, moduleChunkAlias) {
-        if (this.manualChunkAlias && moduleChunkAlias && this.manualChunkAlias !== moduleChunkAlias) {
-            return false;
-        }
+    canModuleBeFacade(moduleExportNamesByVariable) {
         for (const exposedVariable of this.exports) {
             if (!moduleExportNamesByVariable.has(exposedVariable)) {
                 return false;
@@ -14367,39 +14422,48 @@ class Chunk$1 {
     generateFacades() {
         const facades = [];
         for (const module of this.entryModules) {
+            const requiredFacades = Array.from(module.userChunkNames).map(name => ({
+                name
+            }));
+            if (requiredFacades.length === 0 && module.isUserDefinedEntryPoint) {
+                requiredFacades.push({});
+            }
+            requiredFacades.push(...Array.from(module.chunkFileNames).map(fileName => ({ fileName })));
+            if (requiredFacades.length === 0) {
+                requiredFacades.push({});
+            }
             if (!this.facadeModule) {
                 const exportNamesByVariable = module.getExportNamesByVariable();
-                if (this.graph.preserveModules ||
-                    this.canModuleBeFacade(exportNamesByVariable, module.chunkAlias)) {
+                if (this.graph.preserveModules || this.canModuleBeFacade(exportNamesByVariable)) {
                     this.facadeModule = module;
+                    module.facadeChunk = this;
                     for (const [variable, exportNames] of exportNamesByVariable) {
                         for (const exportName of exportNames) {
                             this.exportNames[exportName] = variable;
                         }
                     }
-                    continue;
+                    this.assignFacadeName(requiredFacades.shift(), module);
                 }
             }
-            facades.push(Chunk$1.generateFacade(this.graph, module));
+            for (const facadeName of requiredFacades) {
+                facades.push(Chunk$1.generateFacade(this.graph, module, facadeName));
+            }
         }
         return facades;
     }
     generateId(pattern, patternName, addons, options, existingNames) {
-        this.id = makeUnique(renderNamePattern(pattern, patternName, type => {
-            switch (type) {
-                case 'format':
-                    return options.format === 'es' ? 'esm' : options.format;
-                case 'hash':
-                    return this.computeContentHashWithDependencies(addons, options);
-                case 'name':
-                    return this.getChunkName();
-            }
-            return undefined;
+        if (this.fileName !== null) {
+            return this.fileName;
+        }
+        return makeUnique(renderNamePattern(pattern, patternName, {
+            format: () => (options.format === 'es' ? 'esm' : options.format),
+            hash: () => this.computeContentHashWithDependencies(addons, options),
+            name: () => this.getChunkName()
         }), existingNames);
     }
     generateIdPreserveModules(preserveModulesRelativeDir, existingNames) {
-        const sanitizedId = sanitizeFileName(this.orderedModules[0].id);
-        this.id = makeUnique(normalize(isAbsolute(this.orderedModules[0].id)
+        const sanitizedId = index.sanitizeFileName(this.orderedModules[0].id);
+        return makeUnique(index.normalize(index.isAbsolute(this.orderedModules[0].id)
             ? relative(preserveModulesRelativeDir, sanitizedId)
             : '_virtual/' + path.basename(sanitizedId)), existingNames);
     }
@@ -14441,7 +14505,7 @@ class Chunk$1 {
         }
     }
     getChunkName() {
-        return this.chunkName || (this.chunkName = this.computeChunkName());
+        return this.name || (this.name = index.sanitizeFileName(this.getFallbackChunkName()));
     }
     getDynamicImportIds() {
         return this.dynamicDependencies.map(chunk => chunk.id).filter(Boolean);
@@ -14450,7 +14514,7 @@ class Chunk$1 {
         return (this.sortedExportNames || (this.sortedExportNames = Object.keys(this.exportNames).sort()));
     }
     getImportIds() {
-        return this.dependencies.map(chunk => chunk.id);
+        return this.dependencies.map(chunk => chunk.id).filter(Boolean);
     }
     getRenderedHash() {
         if (this.renderedHash)
@@ -14458,11 +14522,13 @@ class Chunk$1 {
         if (!this.renderedSource)
             return '';
         const hash = _256();
+        const hashAugmentation = this.calculateHashAugmentation();
+        hash.update(hashAugmentation);
         hash.update(this.renderedSource.toString());
         hash.update(this.getExportNames()
             .map(exportName => {
             const variable = this.exportNames[exportName];
-            return `${relativeId(variable.module.id).replace(/\\/g, '/')}:${variable.name}:${exportName}`;
+            return `${index.relativeId(variable.module.id).replace(/\\/g, '/')}:${variable.name}:${exportName}`;
         })
             .join(','));
         return (this.renderedHash = hash.digest('hex'));
@@ -14709,12 +14775,9 @@ class Chunk$1 {
                 continue;
             const renderedDependency = this.renderedDeclarations.dependencies[i];
             const depId = dep instanceof ExternalModule ? renderedDependency.id : dep.id;
-            let relPath = this.id ? normalize(relative(path.dirname(this.id), depId)) : depId;
-            if (!relPath.startsWith('../'))
-                relPath = './' + relPath;
             if (dep instanceof Chunk$1)
                 renderedDependency.namedExportsMode = dep.exportMode !== 'default';
-            renderedDependency.id = relPath;
+            renderedDependency.id = this.getRelativePath(depId);
         }
         this.finaliseDynamicImports(format);
         this.finaliseImportMetas(format);
@@ -14779,14 +14842,9 @@ class Chunk$1 {
                     file = path.resolve(options.dir, this.id);
                 else
                     file = path.resolve(this.id);
-                if (this.graph.pluginDriver.hasLoadersOrTransforms) {
-                    const decodedMap = magicString.generateDecodedMap({});
-                    map = collapseSourcemaps(this, file, decodedMap, this.usedModules, chunkSourcemapChain, options.sourcemapExcludeSources);
-                }
-                else {
-                    map = magicString.generateMap({ file, includeContent: !options.sourcemapExcludeSources });
-                }
-                map.sources = map.sources.map(sourcePath => normalize(options.sourcemapPathTransform ? options.sourcemapPathTransform(sourcePath) : sourcePath));
+                const decodedMap = magicString.generateDecodedMap({});
+                map = collapseSourcemaps(this, file, decodedMap, this.usedModules, chunkSourcemapChain, options.sourcemapExcludeSources);
+                map.sources = map.sources.map(sourcePath => index.normalize(options.sourcemapPathTransform ? options.sourcemapPathTransform(sourcePath) : sourcePath));
                 timeEnd('sourcemap', 3);
             }
             if (options.compact !== true && code[code.length - 1] !== '\n')
@@ -14843,18 +14901,36 @@ class Chunk$1 {
             chunkDependencies.add(dependency);
         }
     }
-    computeChunkName() {
-        if (this.manualChunkAlias) {
-            return sanitizeFileName(this.manualChunkAlias);
-        }
-        if (this.facadeModule !== null) {
-            return sanitizeFileName(this.facadeModule.chunkAlias || getAliasName(this.facadeModule.id));
-        }
-        for (const module of this.orderedModules) {
-            if (module.chunkAlias)
-                return sanitizeFileName(module.chunkAlias);
+    assignFacadeName({ fileName, name }, facadedModule) {
+        if (fileName) {
+            this.fileName = fileName;
         }
-        return 'chunk';
+        else {
+            this.name = index.sanitizeFileName(name || facadedModule.chunkName || index.getAliasName(facadedModule.id));
+        }
+    }
+    calculateHashAugmentation() {
+        const facadeModule = this.facadeModule;
+        const getChunkName = this.getChunkName.bind(this);
+        const preRenderedChunk = {
+            dynamicImports: this.getDynamicImportIds(),
+            exports: this.getExportNames(),
+            facadeModuleId: facadeModule && facadeModule.id,
+            imports: this.getImportIds(),
+            isDynamicEntry: facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
+            isEntry: facadeModule !== null && facadeModule.isEntryPoint,
+            modules: this.renderedModules,
+            get name() {
+                return getChunkName();
+            }
+        };
+        const hashAugmentation = this.graph.pluginDriver.hookReduceValueSync('augmentChunkHash', '', [preRenderedChunk], (hashAugmentation, pluginHash) => {
+            if (pluginHash) {
+                hashAugmentation += pluginHash;
+            }
+            return hashAugmentation;
+        });
+        return hashAugmentation;
     }
     computeContentHashWithDependencies(addons, options) {
         const hash = _256();
@@ -14876,23 +14952,15 @@ class Chunk$1 {
                 if (resolution instanceof Module) {
                     if (resolution.chunk !== this && isChunkRendered(resolution.chunk)) {
                         const resolutionChunk = resolution.facadeChunk || resolution.chunk;
-                        let relPath = normalize(relative(path.dirname(this.id), resolutionChunk.id));
-                        if (!relPath.startsWith('../'))
-                            relPath = './' + relPath;
-                        node.renderFinalResolution(code, `'${relPath}'`, format);
-                    }
-                }
-                else if (resolution instanceof ExternalModule) {
-                    let resolutionId = resolution.id;
-                    if (resolution.renormalizeRenderPath) {
-                        resolutionId = normalize(relative(path.dirname(this.id), resolution.renderPath));
-                        if (!resolutionId.startsWith('../'))
-                            resolutionId = './' + resolutionId;
+                        node.renderFinalResolution(code, `'${this.getRelativePath(resolutionChunk.id)}'`, format);
                     }
-                    node.renderFinalResolution(code, `'${resolutionId}'`, format);
                 }
                 else {
-                    node.renderFinalResolution(code, resolution, format);
+                    node.renderFinalResolution(code, resolution instanceof ExternalModule
+                        ? `'${resolution.renormalizeRenderPath
+                            ? this.getRelativePath(resolution.renderPath)
+                            : resolution.id}'`
+                        : resolution, format);
                 }
             }
         }
@@ -14911,6 +14979,7 @@ class Chunk$1 {
             let importName;
             let needsLiveBinding = false;
             if (exportName[0] === '*') {
+                needsLiveBinding = options.externalLiveBindings !== false;
                 exportChunk = this.graph.moduleById.get(exportName.substr(1));
                 importName = exportName = '*';
             }
@@ -14928,7 +14997,7 @@ class Chunk$1 {
                 else {
                     exportChunk = module;
                     importName = variable.name;
-                    needsLiveBinding = true;
+                    needsLiveBinding = options.externalLiveBindings !== false;
                 }
             }
             let reexportDeclaration = reexportDeclarations.get(exportChunk);
@@ -15027,6 +15096,19 @@ class Chunk$1 {
         }
         return exports;
     }
+    getFallbackChunkName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
+        }
+        if (this.fileName) {
+            return index.getAliasName(this.fileName);
+        }
+        return index.getAliasName(this.orderedModules[this.orderedModules.length - 1].id);
+    }
+    getRelativePath(targetPath) {
+        const relativePath = index.normalize(relative(path.dirname(this.id), targetPath));
+        return relativePath.startsWith('../') ? relativePath : './' + relativePath;
+    }
     inlineChunkDependencies(chunk, deep) {
         for (const dep of chunk.dependencies) {
             if (dep instanceof ExternalModule) {
@@ -15255,94 +15337,7 @@ function optimizeChunks(chunks, options, CHUNK_GROUPING_SIZE, inputBase) {
     return chunks;
 }
 
-const tt = acorn__default.tokTypes;
-const isIdentifierStart = acorn__default.isIdentifierStart;
-var acornBigint = function (Parser) {
-    return class extends Parser {
-        parseLiteral(value) {
-            const node = super.parseLiteral(value);
-            if (node.raw.charCodeAt(node.raw.length - 1) == 110)
-                node.bigint = this.getNumberInput(node.start, node.end);
-            return node;
-        }
-        readRadixNumber(radix) {
-            let start = this.pos;
-            this.pos += 2; // 0x
-            let val = this.readInt(radix);
-            if (val === null)
-                this.raise(this.start + 2, `Expected number in radix ${radix}`);
-            if (this.input.charCodeAt(this.pos) == 110) {
-                let str = this.getNumberInput(start, this.pos);
-                val = typeof BigInt !== "undefined" ? BigInt(str) : null;
-                ++this.pos;
-            }
-            else if (isIdentifierStart(this.fullCharCodeAtPos()))
-                this.raise(this.pos, "Identifier directly after number");
-            return this.finishToken(tt.num, val);
-        }
-        readNumber(startsWithDot) {
-            let start = this.pos;
-            // Not an int
-            if (startsWithDot)
-                return super.readNumber(startsWithDot);
-            // Legacy octal
-            if (this.input.charCodeAt(start) === 48 && this.input.charCodeAt(start + 1) !== 110) {
-                return super.readNumber(startsWithDot);
-            }
-            if (this.readInt(10) === null)
-                this.raise(start, "Invalid number");
-            // Not a BigInt, reset and parse again
-            if (this.input.charCodeAt(this.pos) != 110) {
-                this.pos = start;
-                return super.readNumber(startsWithDot);
-            }
-            let str = this.getNumberInput(start, this.pos);
-            let val = typeof BigInt !== "undefined" ? BigInt(str) : null;
-            ++this.pos;
-            return this.finishToken(tt.num, val);
-        }
-        // This is basically a hook for acorn-numeric-separator
-        getNumberInput(start, end) {
-            if (super.getNumberInput)
-                return super.getNumberInput(start, end);
-            return this.input.slice(start, end);
-        }
-    };
-};
-
-/* eslint-disable no-underscore-dangle */
-const DynamicImportKey = 'Import';
-// NOTE: This allows `yield import()` to parse correctly.
-acorn.tokTypes._import.startsExpr = true;
-function parseDynamicImport() {
-    const node = this.startNode();
-    this.next();
-    if (this.type !== acorn.tokTypes.parenL) {
-        this.unexpected();
-    }
-    return this.finishNode(node, DynamicImportKey);
-}
-function parenAfter() {
-    return /^(\s|\/\/.*|\/\*[^]*?\*\/)*\(/.test(this.input.slice(this.pos));
-}
-function dynamicImport(Parser) {
-    return class extends Parser {
-        parseStatement(context, topLevel, exports) {
-            if (this.type === acorn.tokTypes._import && parenAfter.call(this)) {
-                return this.parseExpressionStatement(this.startNode(), this.parseExpression());
-            }
-            return super.parseStatement(context, topLevel, exports);
-        }
-        parseExprAtom(refDestructuringErrors) {
-            if (this.type === acorn.tokTypes._import) {
-                return parseDynamicImport.call(this);
-            }
-            return super.parseExprAtom(refDestructuringErrors);
-        }
-    };
-}
-
-const tt$1 = acorn__default.tokTypes;
+const tt = acorn.tokTypes;
 const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 const nextTokenIsDot = parser => {
     skipWhiteSpace.lastIndex = parser.pos;
@@ -15353,14 +15348,14 @@ const nextTokenIsDot = parser => {
 var acornImportMeta = function (Parser) {
     return class extends Parser {
         parseExprAtom(refDestructuringErrors) {
-            if (this.type !== tt$1._import || !nextTokenIsDot(this))
+            if (this.type !== tt._import || !nextTokenIsDot(this))
                 return super.parseExprAtom(refDestructuringErrors);
             if (!this.options.allowImportExportEverywhere && !this.inModule) {
                 this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
             }
             let node = this.startNode();
             node.meta = this.parseIdent(true);
-            this.expect(tt$1.dot);
+            this.expect(tt.dot);
             node.property = this.parseIdent(true);
             if (node.property.name !== "meta") {
                 this.raiseRecoverable(node.property.start, "The only valid meta property for import is import.meta");
@@ -15371,7 +15366,7 @@ var acornImportMeta = function (Parser) {
             return this.finishNode(node, "MetaProperty");
         }
         parseStatement(context, topLevel, exports) {
-            if (this.type !== tt$1._import || !nextTokenIsDot(this)) {
+            if (this.type !== tt._import || !nextTokenIsDot(this)) {
                 return super.parseStatement(context, topLevel, exports);
             }
             let node = this.startNode();
@@ -15446,143 +15441,229 @@ class EntityPathTracker {
     }
 }
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
+var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
+    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
+    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
+})(BuildPhase || (BuildPhase = {}));
 
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-function __awaiter(thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try {
-            step(generator.next(value));
+function generateAssetFileName(name, source, output) {
+    const emittedName = name || 'asset';
+    return makeUnique(renderNamePattern(output.assetFileNames, 'output.assetFileNames', {
+        hash() {
+            const hash = _256();
+            hash.update(emittedName);
+            hash.update(':');
+            hash.update(source);
+            return hash.digest('hex').substr(0, 8);
+        },
+        ext: () => path.extname(emittedName).substr(1),
+        extname: () => path.extname(emittedName),
+        name: () => emittedName.substr(0, emittedName.length - path.extname(emittedName).length)
+    }), output.bundle);
+}
+function reserveFileNameInBundle(fileName, bundle) {
+    if (fileName in bundle) {
+        return error(errFileNameConflict(fileName));
+    }
+    bundle[fileName] = FILE_PLACEHOLDER;
+}
+const FILE_PLACEHOLDER = {
+    isPlaceholder: true
+};
+function hasValidType(emittedFile) {
+    return (emittedFile &&
+        (emittedFile.type === 'asset' ||
+            emittedFile.type === 'chunk'));
+}
+function hasValidName(emittedFile) {
+    const validatedName = emittedFile.fileName || emittedFile.name;
+    return (!validatedName || (typeof validatedName === 'string' && index.isPlainPathFragment(validatedName)));
+}
+function getValidSource(source, emittedFile, fileReferenceId) {
+    if (typeof source !== 'string' && !Buffer.isBuffer(source)) {
+        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 of Buffer.`));
+    }
+    return source;
+}
+function getAssetFileName(file, referenceId) {
+    if (typeof file.fileName !== 'string') {
+        return error(errAssetNotFinalisedForFileName(file.name || referenceId));
+    }
+    return file.fileName;
+}
+function getChunkFileName(file) {
+    const fileName = file.fileName || (file.module && file.module.facadeChunk.id);
+    if (!fileName)
+        return error(errChunkNotGeneratedForFileName(file.fileName || file.name));
+    return fileName;
+}
+class FileEmitter {
+    constructor(graph) {
+        this.filesByReferenceId = new Map();
+        // tslint:disable member-ordering
+        this.buildFilesByReferenceId = this.filesByReferenceId;
+        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 and do not contain invalid characters, received "${emittedFile.fileName ||
+                    emittedFile.name}".`));
+            }
+            if (emittedFile.type === 'chunk') {
+                return this.emitChunk(emittedFile);
+            }
+            else {
+                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);
+            }
+            else {
+                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.graph = graph;
+    }
+    startOutput(outputBundle, assetFileNames) {
+        this.filesByReferenceId = new Map(this.buildFilesByReferenceId);
+        this.output = {
+            assetFileNames,
+            bundle: outputBundle
+        };
+        for (const emittedFile of this.filesByReferenceId.values()) {
+            if (emittedFile.fileName) {
+                reserveFileNameInBundle(emittedFile.fileName, this.output.bundle);
+            }
         }
-        catch (e) {
-            reject(e);
-        } }
-        function rejected(value) { try {
-            step(generator["throw"](value));
+        for (const [referenceId, consumedFile] of this.filesByReferenceId.entries()) {
+            if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                this.finalizeAsset(consumedFile, consumedFile.source, referenceId, this.output);
+            }
         }
-        catch (e) {
-            reject(e);
-        } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function addWithNewReferenceId(item, idMap, hashBase) {
-    let referenceId;
-    do {
-        const hash = _256();
-        if (referenceId) {
-            hash.update(referenceId);
+    }
+    assertAssetsFinalized() {
+        for (const [referenceId, emittedFile] of this.filesByReferenceId.entries()) {
+            if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
+                error(errNoAssetSourceSet(emittedFile.name || referenceId));
         }
-        else {
-            hash.update(hashBase);
+    }
+    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.output) {
+            if (emittedAsset.fileName) {
+                reserveFileNameInBundle(emittedAsset.fileName, this.output.bundle);
+            }
+            if (source !== undefined) {
+                this.finalizeAsset(consumedAsset, source, referenceId, this.output);
+            }
         }
-        referenceId = hash.digest('hex').substr(0, 8);
-    } while (idMap.has(referenceId));
-    idMap.set(referenceId, item);
-    return referenceId;
-}
-
-function getAssetFileName(asset, existingNames, assetFileNames) {
-    if (asset.source === undefined)
-        error(errNoAssetSourceSet(asset));
-    if (asset.fileName)
-        return asset.fileName;
-    return makeUnique(renderNamePattern(assetFileNames, 'assetFileNames', name => {
-        switch (name) {
-            case 'hash':
-                const hash = _256();
-                hash.update(name);
-                hash.update(':');
-                hash.update(asset.source);
-                return hash.digest('hex').substr(0, 8);
-            case 'name':
-                return asset.name.substr(0, asset.name.length - path.extname(asset.name).length);
-            case 'extname':
-                return path.extname(asset.name);
-            case 'ext':
-                return path.extname(asset.name).substr(1);
+        return referenceId;
+    }
+    emitChunk(emittedChunk) {
+        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
+            error(errInvalidRollupPhaseForChunkEmission());
         }
-        return undefined;
-    }), existingNames);
-}
-function createAssetPluginHooks(assetsByReferenceId, outputBundle, assetFileNames) {
-    return {
-        emitAsset(name, source) {
-            if (typeof name !== 'string' || !isPlainName(name))
-                error(errInvalidAssetName(name));
-            const asset = { name, source: source, fileName: undefined };
-            if (outputBundle && source !== undefined)
-                finaliseAsset(asset, outputBundle, assetFileNames);
-            return addWithNewReferenceId(asset, assetsByReferenceId, name);
-        },
-        setAssetSource(assetReferenceId, source) {
-            const asset = assetsByReferenceId.get(assetReferenceId);
-            if (!asset)
-                return error(errAssetReferenceIdNotFoundForSetSource(assetReferenceId));
-            if (asset.source !== undefined)
-                return error(errAssetSourceAlreadySet(asset));
-            if (typeof source !== 'string' && !source)
-                return error(errAssetSourceMissingForSetSource(asset));
-            asset.source = source;
-            if (outputBundle)
-                finaliseAsset(asset, outputBundle, assetFileNames);
-        },
-        getAssetFileName(assetReferenceId) {
-            const asset = assetsByReferenceId.get(assetReferenceId);
-            if (!asset)
-                return error(errAssetReferenceIdNotFoundForFilename(assetReferenceId));
-            if ((asset).fileName === undefined)
-                return error(errAssetNotFinalisedForFileName(asset));
-            return (asset).fileName;
+        if (typeof emittedChunk.id !== 'string') {
+            return error(errFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
         }
-    };
-}
-function finaliseAsset(asset, outputBundle, assetFileNames) {
-    const fileName = getAssetFileName(asset, outputBundle, assetFileNames);
-    asset.fileName = fileName;
-    outputBundle[fileName] = {
-        fileName,
-        isAsset: true,
-        source: asset.source
-    };
-}
-function createTransformEmitAsset(assetsByReferenceId, emitAsset) {
-    const assets = [];
-    return {
-        assets,
-        emitAsset: (name, source) => {
-            const assetReferenceId = emitAsset(name, source);
-            const asset = assetsByReferenceId.get(assetReferenceId);
-            assets.push({
-                fileName: undefined,
-                name: asset.name,
-                source: asset.source
-            });
-            return assetReferenceId;
+        const consumedChunk = {
+            fileName: emittedChunk.fileName,
+            module: null,
+            name: emittedChunk.name || emittedChunk.id,
+            type: 'chunk'
+        };
+        this.graph.moduleLoader
+            .addEntryModules([
+            {
+                fileName: emittedChunk.fileName || null,
+                id: emittedChunk.id,
+                name: emittedChunk.name || null
+            }
+        ], false)
+            .then(({ newEntryModules: [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);
+    }
+    assignReferenceId(file, idBase) {
+        let referenceId;
+        do {
+            const hash = _256();
+            if (referenceId) {
+                hash.update(referenceId);
+            }
+            else {
+                hash.update(idBase);
+            }
+            referenceId = hash.digest('hex').substr(0, 8);
+        } while (this.filesByReferenceId.has(referenceId));
+        this.filesByReferenceId.set(referenceId, file);
+        return referenceId;
+    }
+    finalizeAsset(consumedFile, source, referenceId, output) {
+        const fileName = consumedFile.fileName ||
+            this.findExistingAssetFileNameWithSource(output.bundle, source) ||
+            generateAssetFileName(consumedFile.name, source, output);
+        // We must not modify the original assets to avoid interaction between outputs
+        const assetWithFileName = Object.assign({}, consumedFile, { source, fileName });
+        this.filesByReferenceId.set(referenceId, assetWithFileName);
+        output.bundle[fileName] = { fileName, isAsset: true, source };
+    }
+    findExistingAssetFileNameWithSource(bundle, source) {
+        for (const fileName of Object.keys(bundle)) {
+            const outputFile = bundle[fileName];
+            if (outputFile.isAsset &&
+                (Buffer.isBuffer(source) && Buffer.isBuffer(outputFile.source)
+                    ? source.equals(outputFile.source)
+                    : source === outputFile.source))
+                return fileName;
         }
-    };
+        return null;
+    }
 }
 
-var BuildPhase;
-(function (BuildPhase) {
-    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
-    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
-    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
-})(BuildPhase || (BuildPhase = {}));
-
 const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
 const deprecatedHooks = [
     { active: true, deprecated: 'ongenerate', replacement: 'generateBundle' },
@@ -15603,15 +15684,43 @@ function warnDeprecatedHooks(plugins, graph) {
         }
     }
 }
+function throwPluginError(err, plugin, { hook, id } = {}) {
+    if (typeof err === 'string')
+        err = { message: err };
+    if (err.code && err.code !== Errors.PLUGIN_ERROR) {
+        err.pluginCode = err.code;
+    }
+    err.code = Errors.PLUGIN_ERROR;
+    err.plugin = plugin;
+    if (hook) {
+        err.hook = hook;
+    }
+    if (id) {
+        err.id = id;
+    }
+    return error(err);
+}
 function createPluginDriver(graph, options, pluginCache, watcher) {
     warnDeprecatedHooks(options.plugins, graph);
+    function getDeprecatedHookHandler(handler, handlerName, newHandlerName, pluginName, acitveDeprecation) {
+        let deprecationWarningShown = false;
+        return ((...args) => {
+            if (!deprecationWarningShown) {
+                deprecationWarningShown = true;
+                graph.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
+                }, acitveDeprecation);
+            }
+            return handler(...args);
+        });
+    }
     const plugins = [
         ...options.plugins,
         getRollupDefaultPlugin(options.preserveSymlinks)
     ];
-    const { emitAsset, getAssetFileName, setAssetSource } = createAssetPluginHooks(graph.assetsById);
+    const fileEmitter = new FileEmitter(graph);
     const existingPluginKeys = new Set();
-    let hasLoadersOrTransforms = false;
     const pluginContexts = plugins.map((plugin, pidx) => {
         let cacheable = true;
         if (typeof plugin.cacheKey !== 'string') {
@@ -15622,9 +15731,6 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 existingPluginKeys.add(plugin.name);
             }
         }
-        if (!hasLoadersOrTransforms &&
-            (plugin.load || plugin.transform || plugin.transformBundle || plugin.transformChunk))
-            hasLoadersOrTransforms = true;
         let cacheInstance;
         if (!pluginCache) {
             cacheInstance = noCache;
@@ -15643,25 +15749,15 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 graph.watchFiles[id] = true;
             },
             cache: cacheInstance,
-            emitAsset,
-            emitChunk(id, options) {
-                if (graph.phase > BuildPhase.LOAD_AND_PARSE)
-                    this.error(errInvalidRollupPhaseForEmitChunk());
-                return pluginDriver.emitChunk(id, options);
-            },
+            emitAsset: getDeprecatedHookHandler((name, source) => fileEmitter.emitFile({ type: 'asset', name, source }), 'emitAsset', 'emitFile', plugin.name, false),
+            emitChunk: getDeprecatedHookHandler((id, options) => fileEmitter.emitFile({ type: 'chunk', id, name: options && options.name }), 'emitChunk', 'emitFile', plugin.name, false),
+            emitFile: fileEmitter.emitFile,
             error(err) {
-                if (typeof err === 'string')
-                    err = { message: err };
-                if (err.code)
-                    err.pluginCode = err.code;
-                err.code = 'PLUGIN_ERROR';
-                err.plugin = plugin.name;
-                return error(err);
-            },
-            getAssetFileName: getAssetFileName,
-            getChunkFileName(chunkReferenceId) {
-                return graph.moduleLoader.getChunkFileName(chunkReferenceId);
+                return throwPluginError(err, plugin.name);
             },
+            getAssetFileName: getDeprecatedHookHandler(fileEmitter.getFileName, 'getAssetFileName', 'getFileName', plugin.name, false),
+            getChunkFileName: getDeprecatedHookHandler(fileEmitter.getFileName, 'getChunkFileName', 'getFileName', plugin.name, false),
+            getFileName: fileEmitter.getFileName,
             getModuleInfo(moduleId) {
                 const foundModule = graph.moduleById.get(moduleId);
                 if (foundModule == null) {
@@ -15677,21 +15773,9 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                     isExternal: foundModule instanceof ExternalModule
                 };
             },
-            isExternal: (() => {
-                let deprecationWarningShown = false;
-                return (id, parentId, isResolved = false) => {
-                    if (!deprecationWarningShown) {
-                        deprecationWarningShown = true;
-                        graph.warnDeprecation({
-                            message: `The "this.isExternal" plugin context function used by plugin ${plugin.name} is deprecated. The "this.resolve" plugin context function should be used instead.`,
-                            plugin: plugin.name
-                        }, false);
-                    }
-                    return graph.moduleLoader.isExternal(id, parentId, isResolved);
-                };
-            })(),
+            isExternal: getDeprecatedHookHandler((id, parentId, isResolved = false) => graph.moduleLoader.isExternal(id, parentId, isResolved), 'isExternal', 'resolve', plugin.name, false),
             meta: {
-                rollupVersion: version
+                rollupVersion: index.version
             },
             get moduleIds() {
                 return graph.moduleById.keys();
@@ -15700,22 +15784,10 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
             resolve(source, importer, options) {
                 return graph.moduleLoader.resolveId(source, importer, options && options.skipSelf ? pidx : null);
             },
-            resolveId: (() => {
-                let deprecationWarningShown = false;
-                return (source, importer) => {
-                    if (!deprecationWarningShown) {
-                        deprecationWarningShown = true;
-                        graph.warnDeprecation({
-                            message: `The "this.resolveId" plugin context function used by plugin ${plugin.name} is deprecated. The "this.resolve" plugin context function should be used instead.`,
-                            plugin: plugin.name
-                        }, false);
-                    }
-                    return graph.moduleLoader
-                        .resolveId(source, importer)
-                        .then(resolveId => resolveId && resolveId.id);
-                };
-            })(),
-            setAssetSource,
+            resolveId: getDeprecatedHookHandler((source, importer) => graph.moduleLoader
+                .resolveId(source, importer)
+                .then(resolveId => resolveId && resolveId.id), 'resolveId', 'resolve', plugin.name, false),
+            setAssetSource: fileEmitter.setAssetSource,
             warn(warning) {
                 if (typeof warning === 'string')
                     warning = { message: warning };
@@ -15768,18 +15840,8 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
             return hook.apply(context, args);
         }
         catch (err) {
-            if (typeof err === 'string')
-                err = { message: err };
-            if (err.code !== 'PLUGIN_ERROR') {
-                if (err.code)
-                    err.pluginCode = err.code;
-                err.code = 'PLUGIN_ERROR';
-            }
-            err.plugin = plugin.name;
-            err.hook = hookName;
-            error(err);
+            return throwPluginError(err, plugin.name, { hook: hookName });
         }
-        return undefined;
     }
     function runHook(hookName, args, pluginIndex, permitValues = false, hookContext) {
         const plugin = plugins[pluginIndex];
@@ -15805,29 +15867,14 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
             }
             return hook.apply(context, args);
         })
-            .catch(err => {
-            if (typeof err === 'string')
-                err = { message: err };
-            if (err.code !== 'PLUGIN_ERROR') {
-                if (err.code)
-                    err.pluginCode = err.code;
-                err.code = 'PLUGIN_ERROR';
-            }
-            err.plugin = plugin.name;
-            err.hook = hookName;
-            error(err);
-        });
+            .catch(err => throwPluginError(err, plugin.name, { hook: hookName }));
     }
     const pluginDriver = {
-        emitAsset,
-        emitChunk(id, options) {
-            return graph.moduleLoader.addEntryModuleAndGetReferenceId({
-                alias: (options && options.name) || null,
-                unresolvedId: id
-            });
+        emitFile: fileEmitter.emitFile,
+        finaliseAssets() {
+            fileEmitter.assertAssetsFinalized();
         },
-        getAssetFileName: getAssetFileName,
-        hasLoadersOrTransforms,
+        getFileName: fileEmitter.getFileName,
         // chains, ignores returns
         hookSeq(name, args, hookContext) {
             let promise = Promise.resolve();
@@ -15907,6 +15954,18 @@ function createPluginDriver(graph, options, pluginCache, watcher) {
                 });
             }
             return promise;
+        },
+        // chains, reduces returns of type R, to type T, handling the reduced value separately. permits hooks as values.
+        hookReduceValueSync(name, initial, args, reduce, hookContext) {
+            let acc = initial;
+            for (let i = 0; i < plugins.length; i++) {
+                const result = runHookSync(name, args, i, true, hookContext);
+                acc = reduce.call(pluginContexts[i], acc, result, plugins[i]);
+            }
+            return acc;
+        },
+        startOutput(outputBundle, assetFileNames) {
+            fileEmitter.startOutput(outputBundle, assetFileNames);
         }
     };
     return pluginDriver;
@@ -16003,12 +16062,10 @@ function transform(graph, source, module) {
     const id = module.id;
     const sourcemapChain = [];
     let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
-    const baseEmitAsset = graph.pluginDriver.emitAsset;
     const originalCode = source.code;
     let ast = source.ast;
-    let transformDependencies;
-    let emittedAssets;
-    const emittedChunks = [];
+    const transformDependencies = [];
+    const emittedFiles = [];
     let customTransformCache = false;
     let moduleSideEffects = null;
     let trackedPluginCache;
@@ -16021,25 +16078,19 @@ function transform(graph, source, module) {
         if (customTransformCache) {
             if (result && typeof result === 'object' && Array.isArray(result.dependencies)) {
                 for (const dep of result.dependencies) {
-                    const depId = path.resolve(path.dirname(id), dep);
-                    if (!graph.watchFiles[depId])
-                        graph.watchFiles[depId] = true;
+                    graph.watchFiles[path.resolve(path.dirname(id), dep)] = true;
                 }
             }
         }
         else {
-            // assets/chunks emitted by a transform hook need to be emitted again if the hook is skipped
-            if (emittedAssets.length)
-                module.transformAssets = emittedAssets;
-            if (emittedChunks.length)
-                module.transformChunks = emittedChunks;
+            // files emitted by a transform hook need to be emitted again if the hook is skipped
+            if (emittedFiles.length)
+                module.transformFiles = emittedFiles;
             if (result && typeof result === 'object' && Array.isArray(result.dependencies)) {
                 // not great, but a useful way to track this without assuming WeakMap
                 if (!curPlugin.warnedTransformDependencies)
                     graph.warnDeprecation(`Returning "dependencies" from the "transform" hook as done by plugin ${plugin.name} is deprecated. The "this.addWatchFile" plugin context function should be used instead.`, true);
                 curPlugin.warnedTransformDependencies = true;
-                if (!transformDependencies)
-                    transformDependencies = [];
                 for (const dep of result.dependencies)
                     transformDependencies.push(path.resolve(path.dirname(id), dep));
             }
@@ -16078,8 +16129,6 @@ function transform(graph, source, module) {
             customTransformCache = true;
         else
             trackedPluginCache = trackPluginCache(pluginContext.cache);
-        let emitAsset;
-        ({ assets: emittedAssets, emitAsset } = createTransformEmitAsset(graph.assetsById, baseEmitAsset));
         return Object.assign({}, pluginContext, { cache: trackedPluginCache ? trackedPluginCache.cache : pluginContext.cache, warn(warning, pos) {
                 if (typeof warning === 'string')
                     warning = { message: warning };
@@ -16098,14 +16147,21 @@ function transform(graph, source, module) {
                 err.hook = 'transform';
                 return pluginContext.error(err);
             },
-            emitAsset,
+            emitAsset(name, source) {
+                const emittedFile = { type: 'asset', name, source };
+                emittedFiles.push(Object.assign({}, emittedFile));
+                return graph.pluginDriver.emitFile(emittedFile);
+            },
             emitChunk(id, options) {
-                emittedChunks.push({ id, options });
-                return graph.pluginDriver.emitChunk(id, options);
+                const emittedFile = { type: 'chunk', id, name: options && options.name };
+                emittedFiles.push(Object.assign({}, emittedFile));
+                return graph.pluginDriver.emitFile(emittedFile);
+            },
+            emitFile(emittedFile) {
+                emittedFiles.push(emittedFile);
+                return graph.pluginDriver.emitFile(emittedFile);
             },
             addWatchFile(id) {
-                if (!transformDependencies)
-                    transformDependencies = [];
                 transformDependencies.push(id);
                 pluginContext.addWatchFile(id);
             },
@@ -16115,7 +16171,7 @@ function transform(graph, source, module) {
                     try {
                         this.error({
                             code: 'INVALID_SETASSETSOURCE',
-                            message: `setAssetSource cannot be called in transform for caching reasons. Use emitAsset with a source, or call setAssetSource in another hook.`
+                            message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
                         });
                     }
                     catch (err) {
@@ -16136,17 +16192,7 @@ function transform(graph, source, module) {
                 return new SourceMap(Object.assign({}, combinedMap, { file: null, sourcesContent: combinedMap.sourcesContent }));
             } });
     })
-        .catch(err => {
-        if (typeof err === 'string')
-            err = { message: err };
-        if (err.code !== 'PLUGIN_ERROR') {
-            if (err.code)
-                err.pluginCode = err.code;
-            err.code = 'PLUGIN_ERROR';
-        }
-        err.id = id;
-        error(err);
-    })
+        .catch(err => throwPluginError(err, curPlugin.name, { hook: 'transform', id }))
         .then(code => {
         if (!customTransformCache && setAssetSourceErr)
             throw setAssetSourceErr;
@@ -16164,7 +16210,7 @@ function transform(graph, source, module) {
 }
 
 function normalizeRelativeExternalId(importer, source) {
-    return isRelative(source) ? path.resolve(importer, '..', source) : source;
+    return index.isRelative(source) ? path.resolve(importer, '..', source) : source;
 }
 function getIdMatcher(option) {
     if (option === true) {
@@ -16201,11 +16247,11 @@ function getHasModuleSideEffects(moduleSideEffectsOption, pureExternalModules, g
 }
 class ModuleLoader {
     constructor(graph, modulesById, pluginDriver, external, getManualChunk, moduleSideEffects, pureExternalModules) {
-        this.entriesByReferenceId = new Map();
-        this.entryModules = [];
+        this.indexedEntryModules = [];
         this.latestLoadModulesPromise = Promise.resolve();
         this.manualChunkModules = {};
-        this.loadEntryModule = ({ alias, unresolvedId }, isEntry) => this.pluginDriver.hookFirst('resolveId', [unresolvedId, undefined]).then(resolveIdResult => {
+        this.nextEntryModuleIndex = 0;
+        this.loadEntryModule = (unresolvedId, isEntry) => this.pluginDriver.hookFirst('resolveId', [unresolvedId, undefined]).then(resolveIdResult => {
             if (resolveIdResult === false ||
                 (resolveIdResult && typeof resolveIdResult === 'object' && resolveIdResult.external)) {
                 return error(errEntryCannotBeExternal(unresolvedId));
@@ -16214,15 +16260,7 @@ class ModuleLoader {
                 ? resolveIdResult.id
                 : resolveIdResult;
             if (typeof id === 'string') {
-                return this.fetchModule(id, undefined, true, isEntry).then(module => {
-                    if (alias !== null) {
-                        if (module.chunkAlias !== null && module.chunkAlias !== alias) {
-                            return error(errCannotAssignModuleToChunk(module.id, alias, module.chunkAlias));
-                        }
-                        module.chunkAlias = alias;
-                    }
-                    return module;
-                });
+                return this.fetchModule(id, undefined, true, isEntry);
             }
             return error(errUnresolvedEntry(unresolvedId));
         });
@@ -16233,35 +16271,40 @@ class ModuleLoader {
         this.hasModuleSideEffects = getHasModuleSideEffects(moduleSideEffects, pureExternalModules, graph);
         this.getManualChunk = typeof getManualChunk === 'function' ? getManualChunk : () => null;
     }
-    addEntryModuleAndGetReferenceId(unresolvedEntryModule) {
-        const entryRecord = {
-            module: null,
-            name: unresolvedEntryModule.unresolvedId
-        };
-        const referenceId = addWithNewReferenceId(entryRecord, this.entriesByReferenceId, unresolvedEntryModule.unresolvedId);
-        this.addEntryModules([unresolvedEntryModule], false)
-            .then(({ newEntryModules: [module] }) => {
-            entryRecord.module = module;
-        })
-            .catch(() => {
-            // Avoid unhandled Promise rejection as the error will be thrown later
-            // once module loading has finished
-        });
-        return referenceId;
-    }
     addEntryModules(unresolvedEntryModules, isUserDefined) {
-        const loadNewEntryModulesPromise = Promise.all(unresolvedEntryModules.map(unresolvedEntryModule => this.loadEntryModule(unresolvedEntryModule, true))).then(entryModules => {
+        const firstEntryModuleIndex = this.nextEntryModuleIndex;
+        this.nextEntryModuleIndex += unresolvedEntryModules.length;
+        const loadNewEntryModulesPromise = Promise.all(unresolvedEntryModules.map(({ fileName, id, name }) => this.loadEntryModule(id, true).then(module => {
+            if (fileName !== null) {
+                module.chunkFileNames.add(fileName);
+            }
+            else if (name !== null) {
+                if (module.chunkName === null) {
+                    module.chunkName = name;
+                }
+                if (isUserDefined) {
+                    module.userChunkNames.add(name);
+                }
+            }
+            return module;
+        }))).then(entryModules => {
+            let moduleIndex = firstEntryModuleIndex;
             for (const entryModule of entryModules) {
                 entryModule.isUserDefinedEntryPoint = entryModule.isUserDefinedEntryPoint || isUserDefined;
-                const existingEntryModule = this.entryModules.find(module => module.id === entryModule.id);
-                if (!existingEntryModule) {
-                    this.entryModules.push(entryModule);
+                const existingIndexModule = this.indexedEntryModules.find(indexedModule => indexedModule.module.id === entryModule.id);
+                if (!existingIndexModule) {
+                    this.indexedEntryModules.push({ module: entryModule, index: moduleIndex });
+                }
+                else {
+                    existingIndexModule.index = Math.min(existingIndexModule.index, moduleIndex);
                 }
+                moduleIndex++;
             }
+            this.indexedEntryModules.sort(({ index: indexA }, { index: indexB }) => indexA > indexB ? 1 : -1);
             return entryModules;
         });
         return this.awaitLoadModulesPromise(loadNewEntryModulesPromise).then(newEntryModules => ({
-            entryModules: this.entryModules,
+            entryModules: this.indexedEntryModules.map(({ module }) => module),
             manualChunkModulesByAlias: this.manualChunkModules,
             newEntryModules
         }));
@@ -16270,29 +16313,17 @@ class ModuleLoader {
         const unresolvedManualChunks = [];
         for (const alias of Object.keys(manualChunks)) {
             const manualChunkIds = manualChunks[alias];
-            for (const unresolvedId of manualChunkIds) {
-                unresolvedManualChunks.push({ alias: null, unresolvedId, manualChunkAlias: alias });
+            for (const id of manualChunkIds) {
+                unresolvedManualChunks.push({ id, alias });
             }
         }
-        const loadNewManualChunkModulesPromise = Promise.all(unresolvedManualChunks.map(unresolvedManualChunk => this.loadEntryModule(unresolvedManualChunk, false))).then(manualChunkModules => {
+        const loadNewManualChunkModulesPromise = Promise.all(unresolvedManualChunks.map(({ id }) => this.loadEntryModule(id, false))).then(manualChunkModules => {
             for (let index = 0; index < manualChunkModules.length; index++) {
-                this.addToManualChunk(unresolvedManualChunks[index].manualChunkAlias, manualChunkModules[index]);
+                this.addModuleToManualChunk(unresolvedManualChunks[index].alias, manualChunkModules[index]);
             }
         });
         return this.awaitLoadModulesPromise(loadNewManualChunkModulesPromise);
     }
-    getChunkFileName(referenceId) {
-        const entryRecord = this.entriesByReferenceId.get(referenceId);
-        if (!entryRecord)
-            return error(errChunkReferenceIdNotFoundForFilename(referenceId));
-        const fileName = entryRecord.module &&
-            (entryRecord.module.facadeChunk
-                ? entryRecord.module.facadeChunk.id
-                : entryRecord.module.chunk.id);
-        if (!fileName)
-            return error(errChunkNotGeneratedForFileName(entryRecord));
-        return fileName;
-    }
     resolveId(source, importer, skip) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.normalizeResolveIdResult(this.isExternal(source, importer, false)
@@ -16300,7 +16331,7 @@ class ModuleLoader {
                 : yield this.pluginDriver.hookFirst('resolveId', [source, importer], null, skip), importer, source);
         });
     }
-    addToManualChunk(alias, module) {
+    addModuleToManualChunk(alias, module) {
         if (module.manualChunkAlias !== null && module.manualChunkAlias !== alias) {
             error(errCannotAssignModuleToChunk(module.id, alias, module.manualChunkAlias));
         }
@@ -16326,15 +16357,15 @@ class ModuleLoader {
         return getCombinedPromise().then(() => loadNewModulesPromise);
     }
     fetchAllDependencies(module) {
-        const fetchDynamicImportsPromise = Promise.all(module.getDynamicImportExpressions().map((specifier, index) => this.resolveDynamicImport(module, specifier, module.id).then(resolvedId => {
+        const fetchDynamicImportsPromise = Promise.all(module.getDynamicImportExpressions().map((specifier, index$1) => this.resolveDynamicImport(module, specifier, module.id).then(resolvedId => {
             if (resolvedId === null)
                 return;
-            const dynamicImport = module.dynamicImports[index];
+            const dynamicImport = module.dynamicImports[index$1];
             if (typeof resolvedId === 'string') {
                 dynamicImport.resolution = resolvedId;
                 return;
             }
-            return this.fetchResolvedDependency(relativeId(resolvedId.id), module.id, resolvedId).then(module => {
+            return this.fetchResolvedDependency(index.relativeId(resolvedId.id), module.id, resolvedId).then(module => {
                 dynamicImport.resolution = module;
             });
         })));
@@ -16353,7 +16384,7 @@ class ModuleLoader {
         this.modulesById.set(id, module);
         const manualChunkAlias = this.getManualChunk(id);
         if (typeof manualChunkAlias === 'string') {
-            this.addToManualChunk(manualChunkAlias, module);
+            this.addModuleToManualChunk(manualChunkAlias, module);
         }
         timeStart('load modules', 3);
         return Promise.resolve(this.pluginDriver.hookFirst('load', [id]))
@@ -16379,13 +16410,9 @@ class ModuleLoader {
             if (cachedModule &&
                 !cachedModule.customTransformCache &&
                 cachedModule.originalCode === sourceDescription.code) {
-                if (cachedModule.transformAssets) {
-                    for (const { name, source } of cachedModule.transformAssets)
-                        this.pluginDriver.emitAsset(name, source);
-                }
-                if (cachedModule.transformChunks) {
-                    for (const { id, options } of cachedModule.transformChunks)
-                        this.pluginDriver.emitChunk(id, options);
+                if (cachedModule.transformFiles) {
+                    for (const emittedFile of cachedModule.transformFiles)
+                        this.pluginDriver.emitFile(emittedFile);
                 }
                 return cachedModule;
             }
@@ -16438,7 +16465,7 @@ class ModuleLoader {
     }
     handleMissingImports(resolvedId, source, importer) {
         if (resolvedId === null) {
-            if (isRelative(source)) {
+            if (index.isRelative(source)) {
                 error(errUnresolvedImport(source, importer));
             }
             this.graph.warn(errUnresolvedImportTreatedAsExternal(source, importer));
@@ -16621,20 +16648,19 @@ function makeOnwarn() {
 }
 function normalizeEntryModules(entryModules) {
     if (typeof entryModules === 'string') {
-        return [{ alias: null, unresolvedId: entryModules }];
+        return [{ fileName: null, name: null, id: entryModules }];
     }
     if (Array.isArray(entryModules)) {
-        return entryModules.map(unresolvedId => ({ alias: null, unresolvedId }));
+        return entryModules.map(id => ({ fileName: null, name: null, id }));
     }
-    return Object.keys(entryModules).map(alias => ({
-        alias,
-        unresolvedId: entryModules[alias]
+    return Object.keys(entryModules).map(name => ({
+        fileName: null,
+        id: entryModules[name],
+        name
     }));
 }
 class Graph {
     constructor(options, watcher) {
-        this.assetsById = new Map();
-        this.curChunkIndex = 0;
         this.moduleById = new Map();
         this.needsTreeshakingPass = false;
         this.phase = BuildPhase.LOAD_AND_PARSE;
@@ -16642,7 +16668,6 @@ class Graph {
         this.externalModules = [];
         this.modules = [];
         this.onwarn = options.onwarn || makeOnwarn();
-        this.curChunkIndex = 0;
         this.deoptimizationTracker = new EntityPathTracker();
         this.cachedModules = new Map();
         if (options.cache) {
@@ -16707,11 +16732,9 @@ class Graph {
         else {
             this.getModuleContext = () => this.context;
         }
-        this.acornOptions = options.acorn || {};
+        this.acornOptions = options.acorn ? Object.assign({}, options.acorn) : {};
         const acornPluginsToInject = [];
-        acornPluginsToInject.push(dynamicImport);
         acornPluginsToInject.push(acornImportMeta);
-        acornPluginsToInject.push(acornBigint);
         if (options.experimentalTopLevelAwait) {
             this.acornOptions.allowAwaitOutsideFunction = true;
         }
@@ -16818,23 +16841,13 @@ class Graph {
             chunks = chunks.filter(isChunkRendered);
             const facades = [];
             for (const chunk of chunks) {
-                for (const facade of chunk.generateFacades()) {
-                    facades.push(facade);
-                }
+                facades.push(...chunk.generateFacades());
             }
             timeEnd('generate chunks', 2);
             this.phase = BuildPhase.GENERATE;
             return chunks.concat(facades);
         });
     }
-    finaliseAssets(assetFileNames) {
-        const outputBundle = Object.create(null);
-        this.assetsById.forEach(asset => {
-            if (asset.source !== undefined)
-                finaliseAsset(asset, outputBundle, assetFileNames);
-        });
-        return outputBundle;
-    }
     getCache() {
         // handle plugin cache eviction
         for (const name in this.pluginCache) {
@@ -16879,7 +16892,7 @@ class Graph {
             if (warning.plugin)
                 str += `(${warning.plugin} plugin) `;
             if (warning.loc)
-                str += `${relativeId(warning.loc.file)} (${warning.loc.line}:${warning.loc.column}) `;
+                str += `${index.relativeId(warning.loc.file)} (${warning.loc.line}:${warning.loc.column}) `;
             str += warning.message;
             return str;
         };
@@ -16920,7 +16933,7 @@ class Graph {
                     !importDescription.module.getVariableForExportName(importDescription.name)) {
                     module.warn({
                         code: 'NON_EXISTENT_EXPORT',
-                        message: `Non-existent export '${importDescription.name}' is imported from ${relativeId(importDescription.module.id)}`,
+                        message: `Non-existent export '${importDescription.name}' is imported from ${index.relativeId(importDescription.module.id)}`,
                         name: importDescription.name,
                         source: importDescription.module.id
                     }, importDescription.start);
@@ -16970,27 +16983,27 @@ function createAddons(graph, options) {
     });
 }
 
-function assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons) {
-    const usedIds = {};
-    const [entryChunks, otherChunks] = chunks.reduce(([entryChunks, otherChunks], chunk) => {
+function assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons, bundle) {
+    const entryChunks = [];
+    const otherChunks = [];
+    for (const chunk of chunks) {
         (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint
             ? entryChunks
             : otherChunks).push(chunk);
-        return [entryChunks, otherChunks];
-    }, [[], []]);
+    }
     // make sure entry chunk names take precedence with regard to deconflicting
     const chunksForNaming = entryChunks.concat(otherChunks);
-    for (let i = 0; i < chunksForNaming.length; i++) {
-        const chunk = chunksForNaming[i];
+    for (const chunk of chunksForNaming) {
+        const facadeModule = chunk.facadeModule;
         if (outputOptions.file) {
             chunk.id = path.basename(outputOptions.file);
         }
         else if (inputOptions.preserveModules) {
-            chunk.generateIdPreserveModules(inputBase, usedIds);
+            chunk.id = chunk.generateIdPreserveModules(inputBase, bundle);
         }
         else {
             let pattern, patternName;
-            if (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint) {
+            if (facadeModule && facadeModule.isUserDefinedEntryPoint) {
                 pattern = outputOptions.entryFileNames || '[name].js';
                 patternName = 'output.entryFileNames';
             }
@@ -16998,9 +17011,9 @@ function assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons)
                 pattern = outputOptions.chunkFileNames || '[name]-[hash].js';
                 patternName = 'output.chunkFileNames';
             }
-            chunk.generateId(pattern, patternName, addons, outputOptions, usedIds);
+            chunk.id = chunk.generateId(pattern, patternName, addons, outputOptions, bundle);
         }
-        usedIds[chunk.id] = true;
+        bundle[chunk.id] = FILE_PLACEHOLDER;
     }
 }
 
@@ -17070,184 +17083,6 @@ function getExportMode(chunk, { exports: exportMode, name, format }) {
     return exportMode;
 }
 
-const createGetOption = (config, command) => (name, defaultValue) => command[name] !== undefined
-    ? command[name]
-    : config[name] !== undefined
-        ? config[name]
-        : defaultValue;
-const normalizeObjectOptionValue = (optionValue) => {
-    if (!optionValue) {
-        return optionValue;
-    }
-    if (typeof optionValue !== 'object') {
-        return {};
-    }
-    return optionValue;
-};
-const getObjectOption = (config, command, name) => {
-    const commandOption = normalizeObjectOptionValue(command[name]);
-    const configOption = normalizeObjectOptionValue(config[name]);
-    if (commandOption !== undefined) {
-        return commandOption && configOption ? Object.assign({}, configOption, commandOption) : commandOption;
-    }
-    return configOption;
-};
-const defaultOnWarn = warning => {
-    if (typeof warning === 'string') {
-        console.warn(warning);
-    }
-    else {
-        console.warn(warning.message);
-    }
-};
-const getOnWarn = (config, defaultOnWarnHandler = defaultOnWarn) => config.onwarn
-    ? warning => config.onwarn(warning, defaultOnWarnHandler)
-    : defaultOnWarnHandler;
-const getExternal = (config, command) => {
-    const configExternal = config.external;
-    return typeof configExternal === 'function'
-        ? (id, ...rest) => configExternal(id, ...rest) || command.external.indexOf(id) !== -1
-        : (typeof config.external === 'string'
-            ? [configExternal]
-            : Array.isArray(configExternal)
-                ? configExternal
-                : []).concat(command.external);
-};
-const commandAliases = {
-    c: 'config',
-    d: 'dir',
-    e: 'external',
-    f: 'format',
-    g: 'globals',
-    h: 'help',
-    i: 'input',
-    m: 'sourcemap',
-    n: 'name',
-    o: 'file',
-    v: 'version',
-    w: 'watch'
-};
-function mergeOptions({ config = {}, command: rawCommandOptions = {}, defaultOnWarnHandler }) {
-    const command = getCommandOptions(rawCommandOptions);
-    const inputOptions = getInputOptions(config, command, defaultOnWarnHandler);
-    if (command.output) {
-        Object.assign(command, command.output);
-    }
-    const output = config.output;
-    const normalizedOutputOptions = Array.isArray(output) ? output : output ? [output] : [];
-    if (normalizedOutputOptions.length === 0)
-        normalizedOutputOptions.push({});
-    const outputOptions = normalizedOutputOptions.map(singleOutputOptions => getOutputOptions(singleOutputOptions, command));
-    const unknownOptionErrors = [];
-    const validInputOptions = Object.keys(inputOptions);
-    addUnknownOptionErrors(unknownOptionErrors, Object.keys(config), validInputOptions, 'input option', /^output$/);
-    const validOutputOptions = Object.keys(outputOptions[0]);
-    addUnknownOptionErrors(unknownOptionErrors, outputOptions.reduce((allKeys, options) => allKeys.concat(Object.keys(options)), []), validOutputOptions, 'output option');
-    const validCliOutputOptions = validOutputOptions.filter(option => option !== 'sourcemapPathTransform');
-    addUnknownOptionErrors(unknownOptionErrors, Object.keys(command), validInputOptions.concat(validCliOutputOptions, Object.keys(commandAliases), 'config', 'environment', 'silent'), 'CLI flag', /^_|output|(config.*)$/);
-    return {
-        inputOptions,
-        optionError: unknownOptionErrors.length > 0 ? unknownOptionErrors.join('\n') : null,
-        outputOptions
-    };
-}
-function addUnknownOptionErrors(errors, options, validOptions, optionType, ignoredKeys = /$./) {
-    const unknownOptions = options.filter(key => validOptions.indexOf(key) === -1 && !ignoredKeys.test(key));
-    if (unknownOptions.length > 0)
-        errors.push(`Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.sort().join(', ')}`);
-}
-function getCommandOptions(rawCommandOptions) {
-    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
-        ? rawCommandOptions.external.split(',')
-        : [];
-    return Object.assign({}, rawCommandOptions, { external, globals: typeof rawCommandOptions.globals === 'string'
-            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
-                const [id, variableName] = globalDefinition.split(':');
-                globals[id] = variableName;
-                if (external.indexOf(id) === -1) {
-                    external.push(id);
-                }
-                return globals;
-            }, Object.create(null))
-            : undefined });
-}
-function getInputOptions(config, command = { external: [], globals: undefined }, defaultOnWarnHandler) {
-    const getOption = createGetOption(config, command);
-    const inputOptions = {
-        acorn: config.acorn,
-        acornInjectPlugins: config.acornInjectPlugins,
-        cache: getOption('cache'),
-        chunkGroupingSize: getOption('chunkGroupingSize', 5000),
-        context: config.context,
-        experimentalCacheExpiry: getOption('experimentalCacheExpiry', 10),
-        experimentalOptimizeChunks: getOption('experimentalOptimizeChunks'),
-        experimentalTopLevelAwait: getOption('experimentalTopLevelAwait'),
-        external: getExternal(config, command),
-        inlineDynamicImports: getOption('inlineDynamicImports', false),
-        input: getOption('input', []),
-        manualChunks: getOption('manualChunks'),
-        moduleContext: config.moduleContext,
-        onwarn: getOnWarn(config, defaultOnWarnHandler),
-        perf: getOption('perf', false),
-        plugins: config.plugins,
-        preserveModules: getOption('preserveModules'),
-        preserveSymlinks: getOption('preserveSymlinks'),
-        shimMissingExports: getOption('shimMissingExports'),
-        strictDeprecations: getOption('strictDeprecations', false),
-        treeshake: getObjectOption(config, command, 'treeshake'),
-        watch: config.watch
-    };
-    // support rollup({ cache: prevBuildObject })
-    if (inputOptions.cache && inputOptions.cache.cache)
-        inputOptions.cache = inputOptions.cache.cache;
-    return inputOptions;
-}
-function getOutputOptions(config, command = {}) {
-    const getOption = createGetOption(config, command);
-    let format = getOption('format');
-    // Handle format aliases
-    switch (format) {
-        case 'esm':
-        case 'module':
-            format = 'es';
-            break;
-        case 'commonjs':
-            format = 'cjs';
-    }
-    return {
-        amd: Object.assign({}, config.amd, command.amd),
-        assetFileNames: getOption('assetFileNames'),
-        banner: getOption('banner'),
-        chunkFileNames: getOption('chunkFileNames'),
-        compact: getOption('compact', false),
-        dir: getOption('dir'),
-        dynamicImportFunction: getOption('dynamicImportFunction'),
-        entryFileNames: getOption('entryFileNames'),
-        esModule: getOption('esModule', true),
-        exports: getOption('exports'),
-        extend: getOption('extend'),
-        file: getOption('file'),
-        footer: getOption('footer'),
-        format: format === 'esm' ? 'es' : format,
-        freeze: getOption('freeze', true),
-        globals: getOption('globals'),
-        indent: getOption('indent', true),
-        interop: getOption('interop', true),
-        intro: getOption('intro'),
-        name: getOption('name'),
-        namespaceToStringTag: getOption('namespaceToStringTag', false),
-        noConflict: getOption('noConflict'),
-        outro: getOption('outro'),
-        paths: getOption('paths'),
-        preferConst: getOption('preferConst'),
-        sourcemap: getOption('sourcemap'),
-        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
-        sourcemapFile: getOption('sourcemapFile'),
-        sourcemapPathTransform: getOption('sourcemapPathTransform'),
-        strict: getOption('strict', true)
-    };
-}
-
 function checkOutputOptions(options) {
     if (options.format === 'es6') {
         error(errDeprecation({
@@ -17266,7 +17101,7 @@ function getAbsoluteEntryModulePaths(chunks) {
     const absoluteEntryModulePaths = [];
     for (const chunk of chunks) {
         for (const entryModule of chunk.entryModules) {
-            if (isAbsolute(entryModule.id)) {
+            if (index.isAbsolute(entryModule.id)) {
                 absoluteEntryModulePaths.push(entryModule.id);
             }
         }
@@ -17280,7 +17115,7 @@ const throwAsyncGenerateError = {
 };
 function applyOptionHook(inputOptions, plugin) {
     if (plugin.options)
-        return plugin.options.call({ meta: { rollupVersion: version } }, inputOptions) || inputOptions;
+        return plugin.options.call({ meta: { rollupVersion: index.version } }, inputOptions) || inputOptions;
     return inputOptions;
 }
 function ensureArray(items) {
@@ -17292,11 +17127,11 @@ function ensureArray(items) {
     }
     return [];
 }
-function getInputOptions$1(rawInputOptions) {
+function getInputOptions(rawInputOptions) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    let { inputOptions, optionError } = mergeOptions({
+    let { inputOptions, optionError } = index.mergeOptions({
         config: rawInputOptions
     });
     if (optionError)
@@ -17350,9 +17185,31 @@ let curWatcher;
 function setWatcher(watcher) {
     curWatcher = watcher;
 }
+function assignChunksToBundle(chunks, outputBundle) {
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const facadeModule = chunk.facadeModule;
+        outputBundle[chunk.id] = {
+            code: undefined,
+            dynamicImports: chunk.getDynamicImportIds(),
+            exports: chunk.getExportNames(),
+            facadeModuleId: facadeModule && facadeModule.id,
+            fileName: chunk.id,
+            imports: chunk.getImportIds(),
+            isDynamicEntry: facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
+            isEntry: facadeModule !== null && facadeModule.isEntryPoint,
+            map: undefined,
+            modules: chunk.renderedModules,
+            get name() {
+                return chunk.getChunkName();
+            }
+        };
+    }
+    return outputBundle;
+}
 function rollup(rawInputOptions) {
-    try {
-        const inputOptions = getInputOptions$1(rawInputOptions);
+    return __awaiter(this, void 0, void 0, function* () {
+        const inputOptions = getInputOptions(rawInputOptions);
         initialiseTimers(inputOptions);
         const graph = new Graph(inputOptions, curWatcher);
         curWatcher = undefined;
@@ -17361,29 +17218,33 @@ function rollup(rawInputOptions) {
         delete inputOptions.cache;
         delete rawInputOptions.cache;
         timeStart('BUILD', 1);
-        return graph.pluginDriver
-            .hookParallel('buildStart', [inputOptions])
-            .then(() => graph.build(inputOptions.input, inputOptions.manualChunks, inputOptions.inlineDynamicImports))
-            .then(chunks => graph.pluginDriver.hookParallel('buildEnd', []).then(() => chunks), err => graph.pluginDriver.hookParallel('buildEnd', [err]).then(() => {
+        let chunks;
+        try {
+            yield graph.pluginDriver.hookParallel('buildStart', [inputOptions]);
+            chunks = yield graph.build(inputOptions.input, inputOptions.manualChunks, inputOptions.inlineDynamicImports);
+        }
+        catch (err) {
+            yield graph.pluginDriver.hookParallel('buildEnd', [err]);
             throw err;
-        }))
-            .then(chunks => {
-            timeEnd('BUILD', 1);
-            // ensure we only do one optimization pass per build
-            let optimized = false;
-            function getOutputOptions(rawOutputOptions) {
-                return normalizeOutputOptions(inputOptions, rawOutputOptions, chunks.length > 1, graph.pluginDriver);
-            }
-            function generate(outputOptions, isWrite) {
+        }
+        yield graph.pluginDriver.hookParallel('buildEnd', []);
+        timeEnd('BUILD', 1);
+        // ensure we only do one optimization pass per build
+        let optimized = false;
+        function getOutputOptions(rawOutputOptions) {
+            return normalizeOutputOptions(inputOptions, rawOutputOptions, chunks.length > 1, graph.pluginDriver);
+        }
+        function generate(outputOptions, isWrite) {
+            return __awaiter(this, void 0, void 0, function* () {
                 timeStart('GENERATE', 1);
                 const assetFileNames = outputOptions.assetFileNames || 'assets/[name]-[hash][extname]';
-                const outputBundle = graph.finaliseAssets(assetFileNames);
+                const outputBundleWithPlaceholders = Object.create(null);
+                let outputBundle;
                 const inputBase = commondir(getAbsoluteEntryModulePaths(chunks));
-                return graph.pluginDriver
-                    .hookParallel('renderStart', [])
-                    .then(() => createAddons(graph, outputOptions))
-                    .then(addons => {
-                    // pre-render all chunks
+                graph.pluginDriver.startOutput(outputBundleWithPlaceholders, assetFileNames);
+                try {
+                    yield graph.pluginDriver.hookParallel('renderStart', []);
+                    const addons = yield createAddons(graph, outputOptions);
                     for (const chunk of chunks) {
                         if (!inputOptions.preserveModules)
                             chunk.generateInternalExports(outputOptions);
@@ -17397,29 +17258,10 @@ function rollup(rawInputOptions) {
                         optimizeChunks(chunks, outputOptions, inputOptions.chunkGroupingSize, inputBase);
                         optimized = true;
                     }
-                    assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons);
-                    // assign to outputBundle
-                    for (let i = 0; i < chunks.length; i++) {
-                        const chunk = chunks[i];
-                        const facadeModule = chunk.facadeModule;
-                        outputBundle[chunk.id] = {
-                            code: undefined,
-                            dynamicImports: chunk.getDynamicImportIds(),
-                            exports: chunk.getExportNames(),
-                            facadeModuleId: facadeModule && facadeModule.id,
-                            fileName: chunk.id,
-                            imports: chunk.getImportIds(),
-                            isDynamicEntry: facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
-                            isEntry: facadeModule !== null && facadeModule.isEntryPoint,
-                            map: undefined,
-                            modules: chunk.renderedModules,
-                            get name() {
-                                return chunk.getChunkName();
-                            }
-                        };
-                    }
-                    return Promise.all(chunks.map(chunk => {
-                        const outputChunk = outputBundle[chunk.id];
+                    assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons, outputBundleWithPlaceholders);
+                    outputBundle = assignChunksToBundle(chunks, outputBundleWithPlaceholders);
+                    yield Promise.all(chunks.map(chunk => {
+                        const outputChunk = outputBundleWithPlaceholders[chunk.id];
                         return chunk.render(outputOptions, addons, outputChunk).then(rendered => {
                             outputChunk.code = rendered.code;
                             outputChunk.map = rendered.map;
@@ -17428,89 +17270,72 @@ function rollup(rawInputOptions) {
                                 outputChunk
                             ]);
                         });
-                    })).then(() => { });
-                })
-                    .catch(error => graph.pluginDriver.hookParallel('renderError', [error]).then(() => {
+                    }));
+                }
+                catch (error) {
+                    yield graph.pluginDriver.hookParallel('renderError', [error]);
                     throw error;
-                }))
-                    .then(() => {
-                    // run generateBundle hook
-                    // assets emitted during generateBundle are unique to that specific generate call
-                    const assets = new Map(graph.assetsById);
-                    const generateAssetPluginHooks = createAssetPluginHooks(assets, outputBundle, assetFileNames);
-                    return graph.pluginDriver
-                        .hookSeq('generateBundle', [outputOptions, outputBundle, isWrite], context => (Object.assign({}, context, generateAssetPluginHooks)))
-                        .then(() => {
-                        // throw errors for assets not finalised with a source
-                        assets.forEach(asset => {
-                            if (asset.fileName === undefined)
-                                finaliseAsset(asset, outputBundle, assetFileNames);
-                        });
+                }
+                yield graph.pluginDriver.hookSeq('generateBundle', [outputOptions, outputBundle, isWrite]);
+                graph.pluginDriver.finaliseAssets();
+                timeEnd('GENERATE', 1);
+                return outputBundle;
+            });
+        }
+        const cache = useCache ? graph.getCache() : undefined;
+        const result = {
+            cache: cache,
+            generate: ((rawOutputOptions) => {
+                const promise = generate(getOutputOptions(rawOutputOptions), false).then(result => createOutput(result));
+                Object.defineProperty(promise, 'code', throwAsyncGenerateError);
+                Object.defineProperty(promise, 'map', throwAsyncGenerateError);
+                return promise;
+            }),
+            watchFiles: Object.keys(graph.watchFiles),
+            write: ((rawOutputOptions) => {
+                const outputOptions = getOutputOptions(rawOutputOptions);
+                if (!outputOptions.dir && !outputOptions.file) {
+                    error({
+                        code: 'MISSING_OPTION',
+                        message: 'You must specify "output.file" or "output.dir" for the build.'
                     });
-                })
-                    .then(() => {
-                    timeEnd('GENERATE', 1);
-                    return outputBundle;
-                });
-            }
-            const cache = useCache ? graph.getCache() : undefined;
-            const result = {
-                cache: cache,
-                generate: ((rawOutputOptions) => {
-                    const promise = generate(getOutputOptions(rawOutputOptions), false).then(result => createOutput(result));
-                    Object.defineProperty(promise, 'code', throwAsyncGenerateError);
-                    Object.defineProperty(promise, 'map', throwAsyncGenerateError);
-                    return promise;
-                }),
-                watchFiles: Object.keys(graph.watchFiles),
-                write: ((rawOutputOptions) => {
-                    const outputOptions = getOutputOptions(rawOutputOptions);
-                    if (!outputOptions.dir && !outputOptions.file) {
-                        error({
-                            code: 'MISSING_OPTION',
-                            message: 'You must specify "output.file" or "output.dir" for the build.'
-                        });
+                }
+                return generate(outputOptions, true).then((bundle) => __awaiter(this, void 0, void 0, function* () {
+                    let chunkCnt = 0;
+                    for (const fileName of Object.keys(bundle)) {
+                        const file = bundle[fileName];
+                        if (file.isAsset)
+                            continue;
+                        chunkCnt++;
+                        if (chunkCnt > 1)
+                            break;
                     }
-                    return generate(outputOptions, true).then(bundle => {
-                        let chunkCnt = 0;
-                        for (const fileName of Object.keys(bundle)) {
-                            const file = bundle[fileName];
-                            if (file.isAsset)
-                                continue;
-                            chunkCnt++;
-                            if (chunkCnt > 1)
-                                break;
-                        }
-                        if (chunkCnt > 1) {
-                            if (outputOptions.sourcemapFile)
-                                error({
-                                    code: 'INVALID_OPTION',
-                                    message: '"output.sourcemapFile" is only supported for single-file builds.'
-                                });
-                            if (typeof outputOptions.file === 'string')
-                                error({
-                                    code: 'INVALID_OPTION',
-                                    message: 'When building multiple chunks, the "output.dir" option must be used, not "output.file".' +
-                                        (typeof inputOptions.input !== 'string' ||
-                                            inputOptions.inlineDynamicImports === true
-                                            ? ''
-                                            : ' To inline dynamic imports, set the "inlineDynamicImports" option.')
-                                });
-                        }
-                        return Promise.all(Object.keys(bundle).map(chunkId => writeOutputFile(graph, result, bundle[chunkId], outputOptions)))
-                            .then(() => graph.pluginDriver.hookParallel('writeBundle', [bundle]))
-                            .then(() => createOutput(bundle));
-                    });
-                })
-            };
-            if (inputOptions.perf === true)
-                result.getTimings = getTimings;
-            return result;
-        });
-    }
-    catch (err) {
-        return Promise.reject(err);
-    }
+                    if (chunkCnt > 1) {
+                        if (outputOptions.sourcemapFile)
+                            error({
+                                code: 'INVALID_OPTION',
+                                message: '"output.sourcemapFile" is only supported for single-file builds.'
+                            });
+                        if (typeof outputOptions.file === 'string')
+                            error({
+                                code: 'INVALID_OPTION',
+                                message: 'When building multiple chunks, the "output.dir" option must be used, not "output.file".' +
+                                    (typeof inputOptions.input !== 'string' ||
+                                        inputOptions.inlineDynamicImports === true
+                                        ? ''
+                                        : ' To inline dynamic imports, set the "inlineDynamicImports" option.')
+                            });
+                    }
+                    yield Promise.all(Object.keys(bundle).map(chunkId => writeOutputFile(graph, result, bundle[chunkId], outputOptions)));
+                    yield graph.pluginDriver.hookParallel('writeBundle', [bundle]);
+                    return createOutput(bundle);
+                }));
+            })
+        };
+        if (inputOptions.perf === true)
+            result.getTimings = getTimings;
+        return result;
+    });
 }
 var SortingFileType;
 (function (SortingFileType) {
@@ -17531,7 +17356,7 @@ function createOutput(outputBundle) {
     return {
         output: Object.keys(outputBundle)
             .map(fileName => outputBundle[fileName])
-            .sort((outputFileA, outputFileB) => {
+            .filter(outputFile => Object.keys(outputFile).length > 0).sort((outputFileA, outputFileB) => {
             const fileTypeA = getSortingFileType(outputFileA);
             const fileTypeB = getSortingFileType(outputFileB);
             if (fileTypeA === fileTypeB)
@@ -17577,7 +17402,7 @@ function normalizeOutputOptions(inputOptions, rawOutputOptions, hasMultipleChunk
     if (!rawOutputOptions) {
         throw new Error('You must supply an options object');
     }
-    const mergedOptions = mergeOptions({
+    const mergedOptions = index.mergeOptions({
         config: {
             output: Object.assign({}, rawOutputOptions, rawOutputOptions.output, inputOptions.output)
         }
@@ -17587,7 +17412,10 @@ function normalizeOutputOptions(inputOptions, rawOutputOptions, hasMultipleChunk
     // now outputOptions is an array, but rollup.rollup API doesn't support arrays
     const mergedOutputOptions = mergedOptions.outputOptions[0];
     const outputOptionsReducer = (outputOptions, result) => result || outputOptions;
-    const outputOptions = pluginDriver.hookReduceArg0Sync('outputOptions', [mergedOutputOptions], outputOptionsReducer);
+    const outputOptions = pluginDriver.hookReduceArg0Sync('outputOptions', [mergedOutputOptions], outputOptionsReducer, pluginContext => {
+        const emitError = () => pluginContext.error(errCannotEmitFromOptionsHook());
+        return Object.assign({}, pluginContext, { emitFile: emitError, setAssetSource: emitError });
+    });
     checkOutputOptions(outputOptions);
     if (typeof outputOptions.file === 'string') {
         if (typeof outputOptions.dir === 'string')
@@ -17622,7 +17450,7 @@ function normalizeOutputOptions(inputOptions, rawOutputOptions, hasMultipleChunk
     return outputOptions;
 }
 
-var utils$1 = createCommonjsModule(function (module, exports) {
+var utils$1 = index.createCommonjsModule(function (module, exports) {
     exports.isInteger = num => {
         if (typeof num === 'number') {
             return Number.isInteger(num);
@@ -18897,7 +18725,7 @@ var constants$1 = {
     CHAR_UNDERSCORE: 95,
     CHAR_VERTICAL_LINE: 124,
     CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-    SEP: path__default.sep,
+    SEP: path.sep,
     /**
      * Create EXTGLOB_CHARS
      */
@@ -18918,7 +18746,7 @@ var constants$1 = {
     }
 };
 
-var utils$2 = createCommonjsModule(function (module, exports) {
+var utils$2 = index.createCommonjsModule(function (module, exports) {
     const win32 = process.platform === 'win32';
     const { REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL, REGEX_REMOVE_BACKSLASH } = constants$1;
     exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -18942,7 +18770,7 @@ var utils$2 = createCommonjsModule(function (module, exports) {
         if (options && typeof options.windows === 'boolean') {
             return options.windows;
         }
-        return win32 === true || path__default.sep === '\\';
+        return win32 === true || path.sep === '\\';
     };
     exports.escapeLast = (input, char, lastIdx) => {
         let idx = input.lastIndexOf(char, lastIdx);
@@ -20047,7 +19875,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  */
 picomatch.matchBase = (input, glob, options, posix = utils$2.isWindows(options)) => {
     let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-    return regex.test(path__default.basename(input));
+    return regex.test(path.basename(input));
 };
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -20650,32 +20478,9 @@ const createFilter = function createFilter(include, exclude, options) {
     };
 };
 
-var modules = {};
-var getModule = function (dir) {
-    var rootPath = dir ? path__default.resolve(dir) : process.cwd();
-    var rootName = path__default.join(rootPath, '@root');
-    var root = modules[rootName];
-    if (!root) {
-        root = new module$1(rootName);
-        root.filename = rootName;
-        root.paths = module$1._nodeModulePaths(rootPath);
-        modules[rootName] = root;
-    }
-    return root;
-};
-var requireRelative = function (requested, relativeTo) {
-    var root = getModule(relativeTo);
-    return root.require(requested);
-};
-requireRelative.resolve = function (requested, relativeTo) {
-    var root = getModule(relativeTo);
-    return module$1._resolveFilename(requested, root);
-};
-var requireRelative_1 = requireRelative;
-
 let chokidar;
 try {
-    chokidar = requireRelative_1('chokidar', process.cwd());
+    chokidar = index.relative('chokidar', process.cwd());
 }
 catch (err) {
     chokidar = null;
@@ -20868,14 +20673,14 @@ class Task {
         this.watcher = watcher;
         this.closed = false;
         this.watched = new Set();
-        const { inputOptions, outputOptions } = mergeOptions({
+        const { inputOptions, outputOptions } = index.mergeOptions({
             config
         });
         this.inputOptions = inputOptions;
         this.outputs = outputOptions;
         this.outputFiles = this.outputs.map(output => {
             if (output.file || output.dir)
-                return path__default.resolve(output.file || output.dir);
+                return path.resolve(output.file || output.dir);
             return undefined;
         });
         const watchOptions = inputOptions.watch || {};
@@ -20994,7 +20799,7 @@ function watch(configs) {
     return new Watcher(configs).emitter;
 }
 
-exports.VERSION = version;
+exports.VERSION = index.version;
 exports.rollup = rollup;
 exports.watch = watch;
 //# sourceMappingURL=rollup.js.map