rollup 2.36.1 → 2.38.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.36.1
-	Wed, 06 Jan 2021 14:06:54 GMT - commit d6600638c61b5eb7f389681d5fa4af9a1b95823e
+	Rollup.js v2.38.0
+	Fri, 22 Jan 2021 16:26:00 GMT - commit 889fa5267ad93cc706fdbff2024e9c4d4f273749
 
 
 	https://github.com/rollup/rollup
@@ -10,16 +10,16 @@
 */
 'use strict';
 
-var fs = require('fs');
 var sysPath = require('path');
 var crypto = require('crypto');
+var fs = require('fs');
 var require$$0$1 = require('events');
 
 function _interopNamespaceDefaultOnly(e) {
   return {__proto__: null, 'default': e};
 }
 
-var version = "2.36.1";
+var version = "2.38.0";
 
 function ensureArray(items) {
     if (Array.isArray(items)) {
@@ -1609,11 +1609,11 @@ function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
         }
     }
 }
-const WHITESPACE = /\s/;
+const NON_WHITESPACE = /\S/g;
 function findNonWhiteSpace(code, index) {
-    while (index < code.length && WHITESPACE.test(code[index]))
-        index++;
-    return index;
+    NON_WHITESPACE.lastIndex = index;
+    const result = NON_WHITESPACE.exec(code);
+    return result.index;
 }
 // This assumes "code" only contains white-space and comments
 // Returns position of line-comment if applicable
@@ -2274,6 +2274,34 @@ function getMemberReturnExpressionWhenCalled(members, memberName) {
         : new members[memberName].returns();
 }
 
+const BROKEN_FLOW_NONE = 0;
+const BROKEN_FLOW_BREAK_CONTINUE = 1;
+const BROKEN_FLOW_ERROR_RETURN_LABEL = 2;
+function createInclusionContext() {
+    return {
+        brokenFlow: BROKEN_FLOW_NONE,
+        includedCallArguments: new Set(),
+        includedLabels: new Set()
+    };
+}
+function createHasEffectsContext() {
+    return {
+        accessed: new PathTracker(),
+        assigned: new PathTracker(),
+        brokenFlow: BROKEN_FLOW_NONE,
+        called: new DiscriminatedPathTracker(),
+        ignore: {
+            breaks: false,
+            continues: false,
+            labels: new Set(),
+            returnAwaitYield: false
+        },
+        includedLabels: new Set(),
+        instantiated: new DiscriminatedPathTracker(),
+        replacedVariableInits: new Map()
+    };
+}
+
 class Variable {
     constructor(name) {
         this.alwaysRendered = false;
@@ -2335,191 +2363,6 @@ class Variable {
     }
 }
 
-class ExternalVariable extends Variable {
-    constructor(module, name) {
-        super(name);
-        this.module = module;
-        this.isNamespace = name === '*';
-        this.referenced = false;
-    }
-    addReference(identifier) {
-        this.referenced = true;
-        if (this.name === 'default' || this.name === '*') {
-            this.module.suggestName(identifier.name);
-        }
-    }
-    include() {
-        if (!this.included) {
-            this.included = true;
-            this.module.used = true;
-        }
-    }
-}
-
-const BLANK = Object.freeze(Object.create(null));
-const EMPTY_OBJECT = Object.freeze({});
-const EMPTY_ARRAY = Object.freeze([]);
-
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'.split(' ');
-const builtins = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');
-const blacklisted = new Set(reservedWords.concat(builtins));
-const illegalCharacters = /[^$_a-zA-Z0-9]/g;
-const startsWithDigit = (str) => /\d/.test(str[0]);
-function isLegal(str) {
-    if (startsWithDigit(str) || blacklisted.has(str)) {
-        return false;
-    }
-    return !illegalCharacters.test(str);
-}
-function makeLegal(str) {
-    str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
-    if (startsWithDigit(str) || blacklisted.has(str))
-        str = `_${str}`;
-    return str || '_';
-}
-
-class ExternalModule {
-    constructor(options, id, hasModuleSideEffects, meta) {
-        this.options = options;
-        this.id = id;
-        this.defaultVariableName = '';
-        this.dynamicImporters = [];
-        this.importers = [];
-        this.mostCommonSuggestion = 0;
-        this.namespaceVariableName = '';
-        this.reexported = false;
-        this.renderPath = undefined;
-        this.renormalizeRenderPath = false;
-        this.used = false;
-        this.variableName = '';
-        this.execIndex = Infinity;
-        this.suggestedVariableName = makeLegal(id.split(/[\\/]/).pop());
-        this.nameSuggestions = Object.create(null);
-        this.declarations = Object.create(null);
-        this.exportedVariables = new Map();
-        const module = this;
-        this.info = {
-            ast: null,
-            code: null,
-            dynamicallyImportedIds: EMPTY_ARRAY,
-            get dynamicImporters() {
-                return module.dynamicImporters.sort();
-            },
-            hasModuleSideEffects,
-            id,
-            implicitlyLoadedAfterOneOf: EMPTY_ARRAY,
-            implicitlyLoadedBefore: EMPTY_ARRAY,
-            importedIds: EMPTY_ARRAY,
-            get importers() {
-                return module.importers.sort();
-            },
-            isEntry: false,
-            isExternal: true,
-            meta,
-            syntheticNamedExports: false
-        };
-    }
-    getVariableForExportName(name) {
-        let declaration = this.declarations[name];
-        if (declaration)
-            return declaration;
-        this.declarations[name] = declaration = new ExternalVariable(this, name);
-        this.exportedVariables.set(declaration, name);
-        return declaration;
-    }
-    setRenderPath(options, inputBase) {
-        this.renderPath =
-            typeof options.paths === 'function' ? options.paths(this.id) : options.paths[this.id];
-        if (!this.renderPath) {
-            if (!isAbsolute(this.id)) {
-                this.renderPath = this.id;
-            }
-            else {
-                this.renderPath = normalize(sysPath.relative(inputBase, this.id));
-                this.renormalizeRenderPath = true;
-            }
-        }
-        return this.renderPath;
-    }
-    suggestName(name) {
-        if (!this.nameSuggestions[name])
-            this.nameSuggestions[name] = 0;
-        this.nameSuggestions[name] += 1;
-        if (this.nameSuggestions[name] > this.mostCommonSuggestion) {
-            this.mostCommonSuggestion = this.nameSuggestions[name];
-            this.suggestedVariableName = name;
-        }
-    }
-    warnUnusedImports() {
-        const unused = Object.keys(this.declarations).filter(name => {
-            if (name === '*')
-                return false;
-            const declaration = this.declarations[name];
-            return !declaration.included && !this.reexported && !declaration.referenced;
-        });
-        if (unused.length === 0)
-            return;
-        const names = unused.length === 1
-            ? `'${unused[0]}' is`
-            : `${unused
-                .slice(0, -1)
-                .map(name => `'${name}'`)
-                .join(', ')} and '${unused.slice(-1)}' are`;
-        this.options.onwarn({
-            code: 'UNUSED_EXTERNAL_IMPORT',
-            message: `${names} imported from external module '${this.id}' but never used`,
-            names: unused,
-            source: this.id
-        });
-    }
-}
-
-function markModuleAndImpureDependenciesAsExecuted(baseModule) {
-    baseModule.isExecuted = true;
-    const modules = [baseModule];
-    const visitedModules = new Set();
-    for (const module of modules) {
-        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
-            if (!(dependency instanceof ExternalModule) &&
-                !dependency.isExecuted &&
-                (dependency.info.hasModuleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
-                !visitedModules.has(dependency.id)) {
-                dependency.isExecuted = true;
-                visitedModules.add(dependency.id);
-                modules.push(dependency);
-            }
-        }
-    }
-}
-
-const BROKEN_FLOW_NONE = 0;
-const BROKEN_FLOW_BREAK_CONTINUE = 1;
-const BROKEN_FLOW_ERROR_RETURN_LABEL = 2;
-function createInclusionContext() {
-    return {
-        brokenFlow: BROKEN_FLOW_NONE,
-        includedCallArguments: new Set(),
-        includedLabels: new Set()
-    };
-}
-function createHasEffectsContext() {
-    return {
-        accessed: new PathTracker(),
-        assigned: new PathTracker(),
-        brokenFlow: BROKEN_FLOW_NONE,
-        called: new DiscriminatedPathTracker(),
-        ignore: {
-            breaks: false,
-            continues: false,
-            labels: new Set(),
-            returnAwaitYield: false
-        },
-        includedLabels: new Set(),
-        instantiated: new DiscriminatedPathTracker(),
-        replacedVariableInits: new Map()
-    };
-}
-
 // To avoid infinite recursions
 const MAX_PATH_DEPTH = 7;
 class LocalVariable extends Variable {
@@ -2642,9 +2485,6 @@ class LocalVariable extends Variable {
     include() {
         if (!this.included) {
             this.included = true;
-            if (!this.module.isExecuted) {
-                markModuleAndImpureDependenciesAsExecuted(this.module);
-            }
             for (const declaration of this.declarations) {
                 // If node is a default export, it can save a tree-shaking run to include the full declaration now
                 if (!declaration.included)
@@ -2849,6 +2689,7 @@ class NodeBase {
         this.context.magicString.addSourcemapLocation(this.start);
         this.context.magicString.addSourcemapLocation(this.end);
     }
+    addExportedVariables(_variables, _exportNamesByVariable) { }
     /**
      * Override this to bind assignments to variables and do any initialisations that
      * require the scopes to be populated with variables.
@@ -2875,9 +2716,6 @@ class NodeBase {
     createScope(parentScope) {
         this.scope = parentScope;
     }
-    declare(_kind, _init) {
-        return [];
-    }
     deoptimizePath(_path) { }
     getLiteralValueAtPath(_path, _recursionTracker, _origin) {
         return UnknownValue;
@@ -2927,14 +2765,14 @@ class NodeBase {
             }
         }
     }
+    includeAllDeclaredVariables(context, includeChildrenRecursively) {
+        this.include(context, includeChildrenRecursively);
+    }
     includeCallArguments(context, args) {
         for (const arg of args) {
             arg.include(context, false);
         }
     }
-    includeWithAllDeclaredVariables(includeChildrenRecursively, context) {
-        this.include(context, includeChildrenRecursively);
-    }
     /**
      * Override to perform special initialisation steps after the scope is initialised
      */
@@ -2987,9 +2825,6 @@ class NodeBase {
     shouldBeIncluded(context) {
         return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
     }
-    toString() {
-        return this.context.code.slice(this.start, this.end);
-    }
 }
 
 class ClassNode extends NodeBase {
@@ -3238,6 +3073,10 @@ function isReference(node, parent) {
     return false;
 }
 
+const BLANK = Object.freeze(Object.create(null));
+const EMPTY_OBJECT = Object.freeze({});
+const EMPTY_ARRAY = Object.freeze([]);
+
 const ValueProperties = Symbol('Value Properties');
 const PURE = { pure: true };
 const IMPURE = { pure: false };
@@ -4205,7 +4044,7 @@ class Identifier$1 extends NodeBase {
         if (!this.included) {
             this.included = true;
             if (this.variable !== null) {
-                this.context.includeVariable(this.variable);
+                this.context.includeVariableInModule(this.variable);
             }
         }
     }
@@ -4397,7 +4236,7 @@ class ExportDefaultDeclaration extends NodeBase {
     include(context, includeChildrenRecursively) {
         super.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively) {
-            this.context.includeVariable(this.variable);
+            this.context.includeVariableInModule(this.variable);
         }
     }
     initialise() {
@@ -4480,9 +4319,8 @@ class ExportDefaultVariable extends LocalVariable {
     constructor(name, exportDefaultDeclaration, context) {
         super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context);
         this.hasId = false;
-        // Not initialised during construction
         this.originalId = null;
-        this.originalVariableAndDeclarationModules = null;
+        this.originalVariable = null;
         const declaration = exportDefaultDeclaration.declaration;
         if ((declaration instanceof FunctionDeclaration || declaration instanceof ClassDeclaration) &&
             declaration.id) {
@@ -4510,6 +4348,14 @@ class ExportDefaultVariable extends LocalVariable {
             return original.getBaseVariableName();
         }
     }
+    getDirectOriginalVariable() {
+        return this.originalId &&
+            (this.hasId ||
+                !(this.originalId.variable.isReassigned ||
+                    this.originalId.variable instanceof UndefinedVariable))
+            ? this.originalId.variable
+            : null;
+    }
     getName() {
         const original = this.getOriginalVariable();
         if (original === this) {
@@ -4520,34 +4366,17 @@ class ExportDefaultVariable extends LocalVariable {
         }
     }
     getOriginalVariable() {
-        return this.getOriginalVariableAndDeclarationModules().original;
-    }
-    getOriginalVariableAndDeclarationModules() {
-        if (this.originalVariableAndDeclarationModules === null) {
-            if (!this.originalId ||
-                (!this.hasId &&
-                    (this.originalId.variable.isReassigned ||
-                        this.originalId.variable instanceof UndefinedVariable))) {
-                this.originalVariableAndDeclarationModules = { modules: [], original: this };
-            }
-            else {
-                const assignedOriginal = this.originalId.variable;
-                if (assignedOriginal instanceof ExportDefaultVariable) {
-                    const { modules, original } = assignedOriginal.getOriginalVariableAndDeclarationModules();
-                    this.originalVariableAndDeclarationModules = {
-                        modules: modules.concat(this.module),
-                        original
-                    };
-                }
-                else {
-                    this.originalVariableAndDeclarationModules = {
-                        modules: [this.module],
-                        original: assignedOriginal
-                    };
-                }
-            }
-        }
-        return this.originalVariableAndDeclarationModules;
+        if (this.originalVariable)
+            return this.originalVariable;
+        let original = this;
+        let currentVariable;
+        const checkedVariables = new Set();
+        do {
+            checkedVariables.add(original);
+            currentVariable = original;
+            original = currentVariable.getDirectOriginalVariable();
+        } while (original instanceof ExportDefaultVariable && !checkedVariables.has(original));
+        return (this.originalVariable = original || currentVariable);
     }
 }
 
@@ -4660,897 +4489,1081 @@ class NamespaceVariable extends Variable {
 }
 NamespaceVariable.prototype.isNamespace = true;
 
-class SyntheticNamedExportVariable extends Variable {
-    constructor(context, name, syntheticNamespace) {
-        super(name);
-        this.context = context;
-        this.module = context.module;
-        this.syntheticNamespace = syntheticNamespace;
-    }
-    getBaseVariable() {
-        let baseVariable = this.syntheticNamespace;
-        if (baseVariable instanceof ExportDefaultVariable) {
-            baseVariable = baseVariable.getOriginalVariable();
-        }
-        if (baseVariable instanceof SyntheticNamedExportVariable) {
-            baseVariable = baseVariable.getBaseVariable();
-        }
-        return baseVariable;
-    }
-    getBaseVariableName() {
-        return this.syntheticNamespace.getBaseVariableName();
-    }
-    getName() {
-        const name = this.name;
-        return `${this.syntheticNamespace.getName()}${getPropertyAccess(name)}`;
+function spaces(i) {
+    let result = '';
+    while (i--)
+        result += ' ';
+    return result;
+}
+function tabsToSpaces(str) {
+    return str.replace(/^\t+/, match => match.split('\t').join('  '));
+}
+function getCodeFrame(source, line, column) {
+    let lines = source.split('\n');
+    const frameStart = Math.max(0, line - 3);
+    let frameEnd = Math.min(line + 2, lines.length);
+    lines = lines.slice(frameStart, frameEnd);
+    while (!/\S/.test(lines[lines.length - 1])) {
+        lines.pop();
+        frameEnd -= 1;
     }
-    include() {
-        if (!this.included) {
-            this.included = true;
-            this.context.includeVariable(this.syntheticNamespace);
+    const digits = String(frameEnd).length;
+    return lines
+        .map((str, i) => {
+        const isErrorLine = frameStart + i + 1 === line;
+        let lineNum = String(i + frameStart + 1);
+        while (lineNum.length < digits)
+            lineNum = ` ${lineNum}`;
+        if (isErrorLine) {
+            const indicator = spaces(digits + 2 + tabsToSpaces(str.slice(0, column)).length) + '^';
+            return `${lineNum}: ${tabsToSpaces(str)}\n${indicator}`;
         }
-    }
-    setRenderNames(baseName, name) {
-        super.setRenderNames(baseName, name);
-    }
+        return `${lineNum}: ${tabsToSpaces(str)}`;
+    })
+        .join('\n');
 }
-const getPropertyAccess = (name) => {
-    return !RESERVED_NAMES[name] && /^(?!\d)[\w$]+$/.test(name)
-        ? `.${name}`
-        : `[${JSON.stringify(name)}]`;
-};
 
-function removeJsExtension(name) {
-    return name.endsWith('.js') ? name.slice(0, -3) : name;
+function error(base) {
+    if (!(base instanceof Error))
+        base = Object.assign(new Error(base.message), base);
+    throw base;
 }
-
-function getCompleteAmdId(options, chunkId) {
-    if (!options.autoId) {
-        return options.id || '';
+function augmentCodeLocation(props, pos, source, id) {
+    if (typeof pos === 'object') {
+        const { line, column } = pos;
+        props.loc = { file: id, line, column };
     }
     else {
-        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
+        props.pos = pos;
+        const { line, column } = locate(source, pos, { offsetLine: 1 });
+        props.loc = { file: id, line, column };
+    }
+    if (props.frame === undefined) {
+        const { line, column } = props.loc;
+        props.frame = getCodeFrame(source, line, column);
     }
 }
-
-const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
-const INTEROP_DEFAULT_LEGACY_VARIABLE = '_interopDefaultLegacy';
-const INTEROP_NAMESPACE_VARIABLE = '_interopNamespace';
-const INTEROP_NAMESPACE_DEFAULT_VARIABLE = '_interopNamespaceDefault';
-const INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE = '_interopNamespaceDefaultOnly';
-const defaultInteropHelpersByInteropType = {
-    auto: INTEROP_DEFAULT_VARIABLE,
-    default: null,
-    defaultOnly: null,
-    esModule: null,
-    false: null,
-    true: INTEROP_DEFAULT_LEGACY_VARIABLE
-};
-function isDefaultAProperty(interopType, externalLiveBindings) {
-    return (interopType === 'esModule' ||
-        (externalLiveBindings && (interopType === 'auto' || interopType === 'true')));
+var Errors;
+(function (Errors) {
+    Errors["ALREADY_CLOSED"] = "ALREADY_CLOSED";
+    Errors["ASSET_NOT_FINALISED"] = "ASSET_NOT_FINALISED";
+    Errors["ASSET_NOT_FOUND"] = "ASSET_NOT_FOUND";
+    Errors["ASSET_SOURCE_ALREADY_SET"] = "ASSET_SOURCE_ALREADY_SET";
+    Errors["ASSET_SOURCE_MISSING"] = "ASSET_SOURCE_MISSING";
+    Errors["BAD_LOADER"] = "BAD_LOADER";
+    Errors["CANNOT_EMIT_FROM_OPTIONS_HOOK"] = "CANNOT_EMIT_FROM_OPTIONS_HOOK";
+    Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
+    Errors["CIRCULAR_REEXPORT"] = "CIRCULAR_REEXPORT";
+    Errors["CYCLIC_CROSS_CHUNK_REEXPORT"] = "CYCLIC_CROSS_CHUNK_REEXPORT";
+    Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
+    Errors["EXTERNAL_SYNTHETIC_EXPORTS"] = "EXTERNAL_SYNTHETIC_EXPORTS";
+    Errors["FILE_NAME_CONFLICT"] = "FILE_NAME_CONFLICT";
+    Errors["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+    Errors["INPUT_HOOK_IN_OUTPUT_PLUGIN"] = "INPUT_HOOK_IN_OUTPUT_PLUGIN";
+    Errors["INVALID_CHUNK"] = "INVALID_CHUNK";
+    Errors["INVALID_EXPORT_OPTION"] = "INVALID_EXPORT_OPTION";
+    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["MISSING_EXPORT"] = "MISSING_EXPORT";
+    Errors["MISSING_IMPLICIT_DEPENDANT"] = "MISSING_IMPLICIT_DEPENDANT";
+    Errors["MIXED_EXPORTS"] = "MIXED_EXPORTS";
+    Errors["NAMESPACE_CONFLICT"] = "NAMESPACE_CONFLICT";
+    Errors["NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE"] = "NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE";
+    Errors["PLUGIN_ERROR"] = "PLUGIN_ERROR";
+    Errors["PREFER_NAMED_EXPORTS"] = "PREFER_NAMED_EXPORTS";
+    Errors["SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT"] = "SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT";
+    Errors["UNEXPECTED_NAMED_IMPORT"] = "UNEXPECTED_NAMED_IMPORT";
+    Errors["UNRESOLVED_ENTRY"] = "UNRESOLVED_ENTRY";
+    Errors["UNRESOLVED_IMPORT"] = "UNRESOLVED_IMPORT";
+    Errors["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+})(Errors || (Errors = {}));
+function errAssetNotFinalisedForFileName(name) {
+    return {
+        code: Errors.ASSET_NOT_FINALISED,
+        message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first.`
+    };
 }
-const namespaceInteropHelpersByInteropType = {
-    auto: INTEROP_NAMESPACE_VARIABLE,
-    default: INTEROP_NAMESPACE_DEFAULT_VARIABLE,
-    defaultOnly: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE,
-    esModule: null,
-    false: null,
-    true: INTEROP_NAMESPACE_VARIABLE
-};
-function canDefaultBeTakenFromNamespace(interopType, externalLiveBindings) {
-    return (isDefaultAProperty(interopType, externalLiveBindings) &&
-        defaultInteropHelpersByInteropType[interopType] === INTEROP_DEFAULT_VARIABLE);
+function errCannotEmitFromOptionsHook() {
+    return {
+        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 getDefaultOnlyHelper() {
-    return INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE;
+function errChunkNotGeneratedForFileName(name) {
+    return {
+        code: Errors.CHUNK_NOT_GENERATED,
+        message: `Plugin error - Unable to get file name for chunk "${name}". Ensure that generate is called first.`
+    };
 }
-function getHelpersBlock(usedHelpers, accessedGlobals, _, n, s, t, liveBindings, freeze, namespaceToStringTag) {
-    return HELPER_NAMES.map(variable => usedHelpers.has(variable) || accessedGlobals.has(variable)
-        ? HELPER_GENERATORS[variable](_, n, s, t, liveBindings, freeze, namespaceToStringTag, usedHelpers)
-        : '').join('');
+function errCircularReexport(exportName, importedModule) {
+    return {
+        code: Errors.CIRCULAR_REEXPORT,
+        id: importedModule,
+        message: `"${exportName}" cannot be exported from ${relativeId(importedModule)} as it is a reexport that references itself.`
+    };
 }
-const HELPER_GENERATORS = {
-    [INTEROP_DEFAULT_VARIABLE]: (_, n, s, _t, liveBindings) => `function ${INTEROP_DEFAULT_VARIABLE}${_}(e)${_}{${_}return ` +
-        `e${_}&&${_}e.__esModule${_}?${_}` +
-        `${liveBindings ? getDefaultLiveBinding(_) : getDefaultStatic(_)}${s}${_}}${n}${n}`,
-    [INTEROP_DEFAULT_LEGACY_VARIABLE]: (_, n, s, _t, liveBindings) => `function ${INTEROP_DEFAULT_LEGACY_VARIABLE}${_}(e)${_}{${_}return ` +
-        `e${_}&&${_}typeof e${_}===${_}'object'${_}&&${_}'default'${_}in e${_}?${_}` +
-        `${liveBindings ? getDefaultLiveBinding(_) : getDefaultStatic(_)}${s}${_}}${n}${n}`,
-    [INTEROP_NAMESPACE_VARIABLE]: (_, n, s, t, liveBindings, freeze, namespaceToStringTag, usedHelpers) => `function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
-        (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)
-            ? `${t}return e${_}&&${_}e.__esModule${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${s}${n}`
-            : `${t}if${_}(e${_}&&${_}e.__esModule)${_}return e;${n}` +
-                createNamespaceObject(_, n, t, t, liveBindings, freeze, namespaceToStringTag)) +
-        `}${n}${n}`,
-    [INTEROP_NAMESPACE_DEFAULT_VARIABLE]: (_, n, _s, t, liveBindings, freeze, namespaceToStringTag) => `function ${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${_}{${n}` +
-        createNamespaceObject(_, n, t, t, liveBindings, freeze, namespaceToStringTag) +
-        `}${n}${n}`,
-    [INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE]: (_, n, _s, t, _liveBindings, freeze, namespaceToStringTag) => `function ${INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE}(e)${_}{${n}` +
-        `${t}return ${getFrozen(`{__proto__: null,${namespaceToStringTag ? `${_}[Symbol.toStringTag]:${_}'Module',` : ''}${_}'default':${_}e}`, freeze)};${n}` +
-        `}${n}${n}`
-};
-function getDefaultLiveBinding(_) {
-    return `e${_}:${_}{${_}'default':${_}e${_}}`;
+function errCyclicCrossChunkReexport(exportName, exporter, reexporter, importer) {
+    return {
+        code: Errors.CYCLIC_CROSS_CHUNK_REEXPORT,
+        exporter,
+        importer,
+        message: `Export "${exportName}" of module ${relativeId(exporter)} was reexported through module ${relativeId(reexporter)} while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in ${relativeId(importer)} to point directly to the exporting module or do not use "preserveModules" to ensure these modules end up in the same chunk.`,
+        reexporter
+    };
 }
-function getDefaultStatic(_) {
-    return `e['default']${_}:${_}e`;
+function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+    return {
+        code: Errors.ASSET_NOT_FOUND,
+        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
+    };
 }
-function createNamespaceObject(_, n, t, i, liveBindings, freeze, namespaceToStringTag) {
-    return (`${i}var n${_}=${_}${namespaceToStringTag
-        ? `{__proto__:${_}null,${_}[Symbol.toStringTag]:${_}'Module'}`
-        : 'Object.create(null)'};${n}` +
-        `${i}if${_}(e)${_}{${n}` +
-        `${i}${t}Object.keys(e).forEach(function${_}(k)${_}{${n}` +
-        (liveBindings ? copyPropertyLiveBinding : copyPropertyStatic)(_, n, t, i + t + t) +
-        `${i}${t}});${n}` +
-        `${i}}${n}` +
-        `${i}n['default']${_}=${_}e;${n}` +
-        `${i}return ${getFrozen('n', freeze)};${n}`);
+function errAssetSourceAlreadySet(name) {
+    return {
+        code: Errors.ASSET_SOURCE_ALREADY_SET,
+        message: `Unable to set the source for asset "${name}", source already set.`
+    };
 }
-function copyPropertyLiveBinding(_, n, t, i) {
-    return (`${i}if${_}(k${_}!==${_}'default')${_}{${n}` +
-        `${i}${t}var d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
-        `${i}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
-        `${i}${t}${t}enumerable:${_}true,${n}` +
-        `${i}${t}${t}get:${_}function${_}()${_}{${n}` +
-        `${i}${t}${t}${t}return e[k];${n}` +
-        `${i}${t}${t}}${n}` +
-        `${i}${t}});${n}` +
-        `${i}}${n}`);
+function errNoAssetSourceSet(assetName) {
+    return {
+        code: Errors.ASSET_SOURCE_MISSING,
+        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+    };
 }
-function copyPropertyStatic(_, n, _t, i) {
-    return `${i}n[k]${_}=${_}e[k];${n}`;
+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 getFrozen(fragment, freeze) {
-    return freeze ? `Object.freeze(${fragment})` : fragment;
+function errDeprecation(deprecation) {
+    return {
+        code: Errors.DEPRECATED_FEATURE,
+        ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
+    };
 }
-const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
-
-function getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, mechanism = 'return ') {
-    const _ = compact ? '' : ' ';
-    const n = compact ? '' : '\n';
-    if (!namedExportsMode) {
-        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings)};`;
-    }
-    let exportBlock = '';
-    // star exports must always output first for precedence
-    for (const { name, reexports } of dependencies) {
-        if (reexports && namedExportsMode) {
-            for (const specifier of reexports) {
-                if (specifier.reexported === '*') {
-                    if (exportBlock)
-                        exportBlock += 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}});`;
-                    }
-                }
-            }
-        }
-    }
-    for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
-        if (reexports && namedExportsMode) {
-            for (const specifier of reexports) {
-                if (specifier.reexported !== '*') {
-                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings);
-                    if (exportBlock)
-                        exportBlock += n;
-                    exportBlock +=
-                        specifier.imported !== '*' && specifier.needsLiveBinding
-                            ? `Object.defineProperty(exports,${_}'${specifier.reexported}',${_}{${n}` +
-                                `${t}enumerable:${_}true,${n}` +
-                                `${t}get:${_}function${_}()${_}{${n}` +
-                                `${t}${t}return ${importName};${n}${t}}${n}});`
-                            : `exports.${specifier.reexported}${_}=${_}${importName};`;
-                }
-            }
-        }
-    }
-    for (const chunkExport of exports) {
-        const lhs = `exports.${chunkExport.exported}`;
-        const rhs = chunkExport.local;
-        if (lhs !== rhs) {
-            if (exportBlock)
-                exportBlock += n;
-            exportBlock += `${lhs}${_}=${_}${rhs};`;
-        }
-    }
-    if (exportBlock) {
-        return `${n}${n}${exportBlock}`;
-    }
-    return '';
+function errFileReferenceIdNotFoundForFilename(assetReferenceId) {
+    return {
+        code: Errors.FILE_NOT_FOUND,
+        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+    };
 }
-function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings) {
-    if (exports.length > 0) {
-        return exports[0].local;
-    }
-    else {
-        for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
-            if (reexports) {
-                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings);
-            }
-        }
-    }
+function errFileNameConflict(fileName) {
+    return {
+        code: Errors.FILE_NAME_CONFLICT,
+        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
+    };
 }
-function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings) {
-    if (imported === 'default') {
-        if (!isChunk) {
-            const moduleInterop = String(interop(moduleId));
-            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
-                ? defaultVariableName
-                : moduleVariableName;
-            return isDefaultAProperty(moduleInterop, externalLiveBindings)
-                ? `${variableName}['default']`
-                : variableName;
-        }
-        return depNamedExportsMode ? `${moduleVariableName}['default']` : moduleVariableName;
-    }
-    if (imported === '*') {
-        return (isChunk
-            ? !depNamedExportsMode
-            : namespaceInteropHelpersByInteropType[String(interop(moduleId))])
-            ? namespaceVariableName
-            : moduleVariableName;
-    }
-    return `${moduleVariableName}.${imported}`;
+function errInputHookInOutputPlugin(pluginName, hookName) {
+    return {
+        code: Errors.INPUT_HOOK_IN_OUTPUT_PLUGIN,
+        message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
+    };
 }
-function getEsModuleExport(_) {
-    return `Object.defineProperty(exports,${_}'__esModule',${_}{${_}value:${_}true${_}});`;
+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.`
+    };
 }
-function getNamespaceToStringExport(_) {
-    return `exports[Symbol.toStringTag]${_}=${_}'Module';`;
+function errInvalidExportOptionValue(optionValue) {
+    return {
+        code: Errors.INVALID_EXPORT_OPTION,
+        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}"`,
+        url: `https://rollupjs.org/guide/en/#outputexports`
+    };
 }
-function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, _, n) {
-    let namespaceMarkers = '';
-    if (hasNamedExports) {
-        if (addEsModule) {
-            namespaceMarkers += getEsModuleExport(_);
-        }
-        if (addNamespaceToStringTag) {
-            if (namespaceMarkers) {
-                namespaceMarkers += n;
-            }
-            namespaceMarkers += getNamespaceToStringExport(_);
-        }
-    }
-    return namespaceMarkers;
+function errIncompatibleExportOptionValue(optionValue, keys, entryModule) {
+    return {
+        code: 'INVALID_EXPORT_OPTION',
+        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${keys.join(', ')}`
+    };
 }
-
-function getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t) {
-    const neededInteropHelpers = new Set();
-    const interopStatements = [];
-    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
-        neededInteropHelpers.add(helper);
-        interopStatements.push(`${varOrConst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
+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.`
     };
-    for (const { defaultVariableName, imports, id, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
-        if (isChunk) {
-            for (const { imported, reexported } of [
-                ...(imports || []),
-                ...(reexports || [])
-            ]) {
-                if (imported === '*' && reexported !== '*') {
-                    if (!namedExportsMode) {
-                        addInteropStatement(namespaceVariableName, getDefaultOnlyHelper(), name);
-                    }
-                    break;
-                }
-            }
-        }
-        else {
-            const moduleInterop = String(interop(id));
-            let hasDefault = false;
-            let hasNamespace = false;
-            for (const { imported, reexported } of [
-                ...(imports || []),
-                ...(reexports || [])
-            ]) {
-                let helper;
-                let variableName;
-                if (imported === 'default') {
-                    if (!hasDefault) {
-                        hasDefault = true;
-                        if (defaultVariableName !== namespaceVariableName) {
-                            variableName = defaultVariableName;
-                            helper = defaultInteropHelpersByInteropType[moduleInterop];
-                        }
-                    }
-                }
-                else if (imported === '*' && reexported !== '*') {
-                    if (!hasNamespace) {
-                        hasNamespace = true;
-                        helper = namespaceInteropHelpersByInteropType[moduleInterop];
-                        variableName = namespaceVariableName;
-                    }
-                }
-                if (helper) {
-                    addInteropStatement(variableName, helper, name);
-                }
-            }
-        }
-    }
-    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, _, n, s, t, externalLiveBindings, freeze, namespaceToStringTag)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
 }
-
-// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
-// The assumption is that this makes sense for all relative ids:
-// https://requirejs.org/docs/api.html#jsfiles
-function removeExtensionFromRelativeAmdId(id) {
-    return id[0] === '.' ? removeJsExtension(id) : id;
+function errInvalidOption(option, explanation) {
+    return {
+        code: Errors.INVALID_OPTION,
+        message: `Invalid value for option "${option}" - ${explanation}.`
+    };
 }
-
-const builtins$1 = {
-    assert: true,
-    buffer: true,
-    console: true,
-    constants: true,
-    domain: true,
-    events: true,
-    http: true,
-    https: true,
-    os: true,
-    path: true,
-    process: true,
-    punycode: true,
-    querystring: true,
-    stream: true,
-    string_decoder: true,
-    timers: true,
-    tty: true,
-    url: true,
-    util: true,
-    vm: true,
-    zlib: true
-};
-function warnOnBuiltins(warn, dependencies) {
-    const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins$1);
-    if (!externalBuiltins.length)
-        return;
-    const detail = externalBuiltins.length === 1
-        ? `module ('${externalBuiltins[0]}')`
-        : `modules (${externalBuiltins
-            .slice(0, -1)
-            .map(name => `'${name}'`)
-            .join(', ')} and '${externalBuiltins.slice(-1)}')`;
-    warn({
-        code: 'MISSING_NODE_BUILTINS',
-        message: `Creating a browser bundle that depends on Node.js built-in ${detail}. You might need to include https://github.com/ionic-team/rollup-plugin-node-polyfills`,
-        modules: externalBuiltins
-    });
+function errInvalidRollupPhaseForAddWatchFile() {
+    return {
+        code: Errors.INVALID_ROLLUP_PHASE,
+        message: `Cannot call addWatchFile after the build has finished.`
+    };
 }
-
-function amd(magicString, { accessedGlobals, dependencies, exports, hasExports, id, indentString: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, varOrConst, warn }, { amd, compact, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
-    warnOnBuiltins(warn, dependencies);
-    const deps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.id)}'`);
-    const args = dependencies.map(m => m.name);
-    const n = compact ? '' : '\n';
-    const s = compact ? '' : ';';
-    const _ = compact ? '' : ' ';
-    if (namedExportsMode && hasExports) {
-        args.unshift(`exports`);
-        deps.unshift(`'exports'`);
-    }
-    if (accessedGlobals.has('require')) {
-        args.unshift('require');
-        deps.unshift(`'require'`);
-    }
-    if (accessedGlobals.has('module')) {
-        args.unshift('module');
-        deps.unshift(`'module'`);
-    }
-    const completeAmdId = getCompleteAmdId(amd, id);
-    const params = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
-        (deps.length ? `[${deps.join(`,${_}`)}],${_}` : ``);
-    const useStrict = strict ? `${_}'use strict';` : '';
-    magicString.prepend(`${intro}${getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t)}`);
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && esModule, isModuleFacade && namespaceToStringTag, _, n);
-    if (namespaceMarkers) {
-        namespaceMarkers = n + n + namespaceMarkers;
+function errInvalidRollupPhaseForChunkEmission() {
+    return {
+        code: Errors.INVALID_ROLLUP_PHASE,
+        message: `Cannot emit chunks after module loading has finished.`
+    };
+}
+function errMissingExport(exportName, importingModule, importedModule) {
+    return {
+        code: Errors.MISSING_EXPORT,
+        message: `'${exportName}' is not exported by ${relativeId(importedModule)}, imported by ${relativeId(importingModule)}`,
+        url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
+    };
+}
+function errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
+    };
+}
+function errUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
+    };
+}
+function errImplicitDependantIsNotIncluded(module) {
+    const implicitDependencies = Array.from(module.implicitlyLoadedBefore, dependency => relativeId(dependency.id)).sort();
+    return {
+        code: Errors.MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before "${implicitDependencies.length === 1
+            ? implicitDependencies[0]
+            : `${implicitDependencies.slice(0, -1).join('", "')}" and "${implicitDependencies.slice(-1)[0]}`}" is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
+    };
+}
+function errMixedExport(facadeModuleId, name) {
+    return {
+        code: Errors.MIXED_EXPORTS,
+        id: facadeModuleId,
+        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}["default"]\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning`,
+        url: `https://rollupjs.org/guide/en/#outputexports`
+    };
+}
+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)`,
+        name,
+        reexporter: reexportingModule.id,
+        sources: [reexportingModule.exportsAll[name], additionalExportAllModule.exportsAll[name]]
+    };
+}
+function errNoTransformMapOrAstWithoutCode(pluginName) {
+    return {
+        code: Errors.NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
+        message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
+            'a "code". This will be ignored.'
+    };
+}
+function errPreferNamedExports(facadeModuleId) {
+    const file = relativeId(facadeModuleId);
+    return {
+        code: Errors.PREFER_NAMED_EXPORTS,
+        id: facadeModuleId,
+        message: `Entry module "${file}" is implicitly using "default" export mode, which means for CommonJS output that its default export is assigned to "module.exports". For many tools, such CommonJS output will not be interchangeable with the original ES module. If this is intended, explicitly set "output.exports" to either "auto" or "default", otherwise you might want to consider changing the signature of "${file}" to use named exports only.`,
+        url: `https://rollupjs.org/guide/en/#outputexports`
+    };
+}
+function errSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+    return {
+        code: Errors.SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
+        id,
+        message: `Module "${relativeId(id)}" that is marked with 'syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}' needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
+            ? `an export named "${syntheticNamedExportsOption}"`
+            : 'a default export'} that does not reexport an unresolved named export of the same module.`
+    };
+}
+function errUnexpectedNamedImport(id, imported, isReexport) {
+    const importType = isReexport ? 'reexport' : 'import';
+    return {
+        code: Errors.UNEXPECTED_NAMED_IMPORT,
+        id,
+        message: `The named export "${imported}" was ${importType}ed from the external module ${relativeId(id)} even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
+        url: 'https://rollupjs.org/guide/en/#outputinterop'
+    };
+}
+function errUnexpectedNamespaceReexport(id) {
+    return {
+        code: Errors.UNEXPECTED_NAMED_IMPORT,
+        id,
+        message: `There was a namespace "*" reexport from the external module ${relativeId(id)} even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
+        url: 'https://rollupjs.org/guide/en/#outputinterop'
+    };
+}
+function errEntryCannotBeExternal(unresolvedId) {
+    return {
+        code: Errors.UNRESOLVED_ENTRY,
+        message: `Entry module cannot be external (${relativeId(unresolvedId)}).`
+    };
+}
+function errUnresolvedEntry(unresolvedId) {
+    return {
+        code: Errors.UNRESOLVED_ENTRY,
+        message: `Could not resolve entry module (${relativeId(unresolvedId)}).`
+    };
+}
+function errUnresolvedImport(source, importer) {
+    return {
+        code: Errors.UNRESOLVED_IMPORT,
+        message: `Could not resolve '${source}' from ${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`,
+        source,
+        url: 'https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency'
+    };
+}
+function errExternalSyntheticExports(source, importer) {
+    return {
+        code: Errors.EXTERNAL_SYNTHETIC_EXPORTS,
+        importer: relativeId(importer),
+        message: `External '${source}' can not have 'syntheticNamedExports' enabled.`,
+        source
+    };
+}
+function errFailedValidation(message) {
+    return {
+        code: Errors.VALIDATION_ERROR,
+        message
+    };
+}
+function errAlreadyClosed() {
+    return {
+        code: Errors.ALREADY_CLOSED,
+        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
+    };
+}
+function warnDeprecation(deprecation, activeDeprecation, options) {
+    warnDeprecationWithOptions(deprecation, activeDeprecation, options.onwarn, options.strictDeprecations);
+}
+function warnDeprecationWithOptions(deprecation, activeDeprecation, warn, strictDeprecations) {
+    if (activeDeprecation || strictDeprecations) {
+        const warning = errDeprecation(deprecation);
+        if (strictDeprecations) {
+            return error(warning);
+        }
+        warn(warning);
     }
-    magicString.append(`${exportBlock}${namespaceMarkers}${outro}`);
-    return magicString
-        .indent(t)
-        .prepend(`${amd.define}(${params}function${_}(${args.join(`,${_}`)})${_}{${useStrict}${n}${n}`)
-        .append(`${n}${n}});`);
 }
 
-function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports, indentString: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, varOrConst }, { compact, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
-    const n = compact ? '' : '\n';
-    const s = compact ? '' : ';';
-    const _ = compact ? '' : ' ';
-    const useStrict = strict ? `'use strict';${n}${n}` : '';
-    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && esModule, isModuleFacade && namespaceToStringTag, _, n);
-    if (namespaceMarkers) {
-        namespaceMarkers += n + n;
+class SyntheticNamedExportVariable extends Variable {
+    constructor(context, name, syntheticNamespace) {
+        super(name);
+        this.baseVariable = null;
+        this.context = context;
+        this.module = context.module;
+        this.syntheticNamespace = syntheticNamespace;
     }
-    const importBlock = getImportBlock(dependencies, compact, varOrConst, n, _);
-    const interopBlock = getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t);
-    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
-    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, `module.exports${_}=${_}`);
-    return magicString.append(`${exportBlock}${outro}`);
-}
-function getImportBlock(dependencies, compact, varOrConst, n, _) {
-    let importBlock = '';
-    let definingVariable = false;
-    for (const { id, name, reexports, imports } of dependencies) {
-        if (!reexports && !imports) {
-            if (importBlock) {
-                importBlock += !compact || definingVariable ? `;${n}` : ',';
+    getBaseVariable() {
+        if (this.baseVariable)
+            return this.baseVariable;
+        let baseVariable = this.syntheticNamespace;
+        const checkedVariables = new Set();
+        while (baseVariable instanceof ExportDefaultVariable ||
+            baseVariable instanceof SyntheticNamedExportVariable) {
+            checkedVariables.add(baseVariable);
+            if (baseVariable instanceof ExportDefaultVariable) {
+                const original = baseVariable.getOriginalVariable();
+                if (original === baseVariable)
+                    break;
+                baseVariable = original;
+            }
+            if (baseVariable instanceof SyntheticNamedExportVariable) {
+                baseVariable = baseVariable.syntheticNamespace;
+            }
+            if (checkedVariables.has(baseVariable)) {
+                return error(errSyntheticNamedExportsNeedNamespaceExport(this.module.id, this.module.info.syntheticNamedExports));
             }
-            definingVariable = false;
-            importBlock += `require('${id}')`;
         }
-        else {
-            importBlock +=
-                compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${varOrConst} `;
-            definingVariable = true;
-            importBlock += `${name}${_}=${_}require('${id}')`;
+        return (this.baseVariable = baseVariable);
+    }
+    getBaseVariableName() {
+        return this.syntheticNamespace.getBaseVariableName();
+    }
+    getName() {
+        const name = this.name;
+        return `${this.syntheticNamespace.getName()}${getPropertyAccess(name)}`;
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.context.includeVariableInModule(this.syntheticNamespace);
         }
     }
-    if (importBlock) {
-        return `${importBlock};${n}${n}`;
+    setRenderNames(baseName, name) {
+        super.setRenderNames(baseName, name);
     }
-    return '';
 }
+const getPropertyAccess = (name) => {
+    return !RESERVED_NAMES[name] && /^(?!\d)[\w$]+$/.test(name)
+        ? `.${name}`
+        : `[${JSON.stringify(name)}]`;
+};
 
-function es(magicString, { intro, outro, dependencies, exports, varOrConst }, { compact }) {
-    const _ = compact ? '' : ' ';
-    const n = compact ? '' : '\n';
-    const importBlock = getImportBlock$1(dependencies, _);
-    if (importBlock.length > 0)
-        intro += importBlock.join(n) + n + n;
-    if (intro)
-        magicString.prepend(intro);
-    const exportBlock = getExportBlock$1(exports, _, varOrConst);
-    if (exportBlock.length)
-        magicString.append(n + n + exportBlock.join(n).trim());
-    if (outro)
-        magicString.append(outro);
-    return magicString.trim();
-}
-function getImportBlock$1(dependencies, _) {
-    const importBlock = [];
-    for (const { id, reexports, imports, name } of dependencies) {
-        if (!reexports && !imports) {
-            importBlock.push(`import${_}'${id}';`);
-            continue;
-        }
-        if (imports) {
-            let defaultImport = null;
-            let starImport = null;
-            const importedNames = [];
-            for (const specifier of imports) {
-                if (specifier.imported === 'default') {
-                    defaultImport = specifier;
-                }
-                else if (specifier.imported === '*') {
-                    starImport = specifier;
-                }
-                else {
-                    importedNames.push(specifier);
-                }
-            }
-            if (starImport) {
-                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}'${id}';`);
-            }
-            if (defaultImport && importedNames.length === 0) {
-                importBlock.push(`import ${defaultImport.local} from${_}'${id}';`);
-            }
-            else if (importedNames.length > 0) {
-                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
-                    .map(specifier => {
-                    if (specifier.imported === specifier.local) {
-                        return specifier.imported;
-                    }
-                    else {
-                        return `${specifier.imported} as ${specifier.local}`;
-                    }
-                })
-                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
-            }
-        }
-        if (reexports) {
-            let starExport = null;
-            const namespaceReexports = [];
-            const namedReexports = [];
-            for (const specifier of reexports) {
-                if (specifier.reexported === '*') {
-                    starExport = specifier;
-                }
-                else if (specifier.imported === '*') {
-                    namespaceReexports.push(specifier);
-                }
-                else {
-                    namedReexports.push(specifier);
-                }
-            }
-            if (starExport) {
-                importBlock.push(`export${_}*${_}from${_}'${id}';`);
-            }
-            if (namespaceReexports.length > 0) {
-                if (!imports ||
-                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
-                    importBlock.push(`import${_}*${_}as ${name} from${_}'${id}';`);
-                }
-                for (const specifier of namespaceReexports) {
-                    importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${specifier.reexported}`} };`);
-                }
-            }
-            if (namedReexports.length > 0) {
-                importBlock.push(`export${_}{${_}${namedReexports
-                    .map(specifier => {
-                    if (specifier.imported === specifier.reexported) {
-                        return specifier.imported;
-                    }
-                    else {
-                        return `${specifier.imported} as ${specifier.reexported}`;
-                    }
-                })
-                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
-            }
+class ExternalVariable extends Variable {
+    constructor(module, name) {
+        super(name);
+        this.module = module;
+        this.isNamespace = name === '*';
+        this.referenced = false;
+    }
+    addReference(identifier) {
+        this.referenced = true;
+        if (this.name === 'default' || this.name === '*') {
+            this.module.suggestName(identifier.name);
         }
     }
-    return importBlock;
-}
-function getExportBlock$1(exports, _, varOrConst) {
-    const exportBlock = [];
-    const exportDeclaration = [];
-    for (const specifier of exports) {
-        if (specifier.exported === 'default') {
-            exportBlock.push(`export default ${specifier.local};`);
-        }
-        else {
-            if (specifier.expression) {
-                exportBlock.push(`${varOrConst} ${specifier.local}${_}=${_}${specifier.expression};`);
-            }
-            exportDeclaration.push(specifier.exported === specifier.local
-                ? specifier.local
-                : `${specifier.local} as ${specifier.exported}`);
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.module.used = true;
         }
     }
-    if (exportDeclaration.length) {
-        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
-    }
-    return exportBlock;
 }
 
-function spaces(i) {
-    let result = '';
-    while (i--)
-        result += ' ';
-    return result;
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'.split(' ');
+const builtins = 'Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'.split(' ');
+const blacklisted = new Set(reservedWords.concat(builtins));
+const illegalCharacters = /[^$_a-zA-Z0-9]/g;
+const startsWithDigit = (str) => /\d/.test(str[0]);
+function isLegal(str) {
+    if (startsWithDigit(str) || blacklisted.has(str)) {
+        return false;
+    }
+    return !illegalCharacters.test(str);
 }
-function tabsToSpaces(str) {
-    return str.replace(/^\t+/, match => match.split('\t').join('  '));
+function makeLegal(str) {
+    str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
+    if (startsWithDigit(str) || blacklisted.has(str))
+        str = `_${str}`;
+    return str || '_';
 }
-function getCodeFrame(source, line, column) {
-    let lines = source.split('\n');
-    const frameStart = Math.max(0, line - 3);
-    let frameEnd = Math.min(line + 2, lines.length);
-    lines = lines.slice(frameStart, frameEnd);
-    while (!/\S/.test(lines[lines.length - 1])) {
-        lines.pop();
-        frameEnd -= 1;
+
+class ExternalModule {
+    constructor(options, id, hasModuleSideEffects, meta) {
+        this.options = options;
+        this.id = id;
+        this.defaultVariableName = '';
+        this.dynamicImporters = [];
+        this.importers = [];
+        this.mostCommonSuggestion = 0;
+        this.namespaceVariableName = '';
+        this.reexported = false;
+        this.renderPath = undefined;
+        this.renormalizeRenderPath = false;
+        this.used = false;
+        this.variableName = '';
+        this.execIndex = Infinity;
+        this.suggestedVariableName = makeLegal(id.split(/[\\/]/).pop());
+        this.nameSuggestions = Object.create(null);
+        this.declarations = Object.create(null);
+        this.exportedVariables = new Map();
+        const module = this;
+        this.info = {
+            ast: null,
+            code: null,
+            dynamicallyImportedIds: EMPTY_ARRAY,
+            get dynamicImporters() {
+                return module.dynamicImporters.sort();
+            },
+            hasModuleSideEffects,
+            id,
+            implicitlyLoadedAfterOneOf: EMPTY_ARRAY,
+            implicitlyLoadedBefore: EMPTY_ARRAY,
+            importedIds: EMPTY_ARRAY,
+            get importers() {
+                return module.importers.sort();
+            },
+            isEntry: false,
+            isExternal: true,
+            meta,
+            syntheticNamedExports: false
+        };
     }
-    const digits = String(frameEnd).length;
-    return lines
-        .map((str, i) => {
-        const isErrorLine = frameStart + i + 1 === line;
-        let lineNum = String(i + frameStart + 1);
-        while (lineNum.length < digits)
-            lineNum = ` ${lineNum}`;
-        if (isErrorLine) {
-            const indicator = spaces(digits + 2 + tabsToSpaces(str.slice(0, column)).length) + '^';
-            return `${lineNum}: ${tabsToSpaces(str)}\n${indicator}`;
+    getVariableForExportName(name) {
+        let declaration = this.declarations[name];
+        if (declaration)
+            return declaration;
+        this.declarations[name] = declaration = new ExternalVariable(this, name);
+        this.exportedVariables.set(declaration, name);
+        return declaration;
+    }
+    setRenderPath(options, inputBase) {
+        this.renderPath =
+            typeof options.paths === 'function' ? options.paths(this.id) : options.paths[this.id];
+        if (!this.renderPath) {
+            if (!isAbsolute(this.id)) {
+                this.renderPath = this.id;
+            }
+            else {
+                this.renderPath = normalize(sysPath.relative(inputBase, this.id));
+                this.renormalizeRenderPath = true;
+            }
         }
-        return `${lineNum}: ${tabsToSpaces(str)}`;
-    })
-        .join('\n');
+        return this.renderPath;
+    }
+    suggestName(name) {
+        if (!this.nameSuggestions[name])
+            this.nameSuggestions[name] = 0;
+        this.nameSuggestions[name] += 1;
+        if (this.nameSuggestions[name] > this.mostCommonSuggestion) {
+            this.mostCommonSuggestion = this.nameSuggestions[name];
+            this.suggestedVariableName = name;
+        }
+    }
+    warnUnusedImports() {
+        const unused = Object.keys(this.declarations).filter(name => {
+            if (name === '*')
+                return false;
+            const declaration = this.declarations[name];
+            return !declaration.included && !this.reexported && !declaration.referenced;
+        });
+        if (unused.length === 0)
+            return;
+        const names = unused.length === 1
+            ? `'${unused[0]}' is`
+            : `${unused
+                .slice(0, -1)
+                .map(name => `'${name}'`)
+                .join(', ')} and '${unused.slice(-1)}' are`;
+        this.options.onwarn({
+            code: 'UNUSED_EXTERNAL_IMPORT',
+            message: `${names} imported from external module '${this.id}' but never used`,
+            names: unused,
+            source: this.id
+        });
+    }
 }
 
-function error(base) {
-    if (!(base instanceof Error))
-        base = Object.assign(new Error(base.message), base);
-    throw base;
+function removeJsExtension(name) {
+    return name.endsWith('.js') ? name.slice(0, -3) : name;
 }
-function augmentCodeLocation(props, pos, source, id) {
-    if (typeof pos === 'object') {
-        const { line, column } = pos;
-        props.loc = { file: id, line, column };
+
+function getCompleteAmdId(options, chunkId) {
+    if (!options.autoId) {
+        return options.id || '';
     }
     else {
-        props.pos = pos;
-        const { line, column } = locate(source, pos, { offsetLine: 1 });
-        props.loc = { file: id, line, column };
-    }
-    if (props.frame === undefined) {
-        const { line, column } = props.loc;
-        props.frame = getCodeFrame(source, line, column);
+        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
     }
 }
-var Errors;
-(function (Errors) {
-    Errors["ALREADY_CLOSED"] = "ALREADY_CLOSED";
-    Errors["ASSET_NOT_FINALISED"] = "ASSET_NOT_FINALISED";
-    Errors["ASSET_NOT_FOUND"] = "ASSET_NOT_FOUND";
-    Errors["ASSET_SOURCE_ALREADY_SET"] = "ASSET_SOURCE_ALREADY_SET";
-    Errors["ASSET_SOURCE_MISSING"] = "ASSET_SOURCE_MISSING";
-    Errors["BAD_LOADER"] = "BAD_LOADER";
-    Errors["CANNOT_EMIT_FROM_OPTIONS_HOOK"] = "CANNOT_EMIT_FROM_OPTIONS_HOOK";
-    Errors["CHUNK_NOT_GENERATED"] = "CHUNK_NOT_GENERATED";
-    Errors["DEPRECATED_FEATURE"] = "DEPRECATED_FEATURE";
-    Errors["EXTERNAL_SYNTHETIC_EXPORTS"] = "EXTERNAL_SYNTHETIC_EXPORTS";
-    Errors["FILE_NAME_CONFLICT"] = "FILE_NAME_CONFLICT";
-    Errors["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
-    Errors["INPUT_HOOK_IN_OUTPUT_PLUGIN"] = "INPUT_HOOK_IN_OUTPUT_PLUGIN";
-    Errors["INVALID_CHUNK"] = "INVALID_CHUNK";
-    Errors["INVALID_EXPORT_OPTION"] = "INVALID_EXPORT_OPTION";
-    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["MISSING_IMPLICIT_DEPENDANT"] = "MISSING_IMPLICIT_DEPENDANT";
-    Errors["MIXED_EXPORTS"] = "MIXED_EXPORTS";
-    Errors["NAMESPACE_CONFLICT"] = "NAMESPACE_CONFLICT";
-    Errors["NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE"] = "NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE";
-    Errors["PLUGIN_ERROR"] = "PLUGIN_ERROR";
-    Errors["PREFER_NAMED_EXPORTS"] = "PREFER_NAMED_EXPORTS";
-    Errors["SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT"] = "SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT";
-    Errors["UNEXPECTED_NAMED_IMPORT"] = "UNEXPECTED_NAMED_IMPORT";
-    Errors["UNRESOLVED_ENTRY"] = "UNRESOLVED_ENTRY";
-    Errors["UNRESOLVED_IMPORT"] = "UNRESOLVED_IMPORT";
-    Errors["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-})(Errors || (Errors = {}));
-function errAssetNotFinalisedForFileName(name) {
-    return {
-        code: Errors.ASSET_NOT_FINALISED,
-        message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first.`
-    };
-}
-function errCannotEmitFromOptionsHook() {
-    return {
-        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 errChunkNotGeneratedForFileName(name) {
-    return {
-        code: Errors.CHUNK_NOT_GENERATED,
-        message: `Plugin error - Unable to get file name for chunk "${name}". Ensure that generate is called first.`
-    };
-}
-function errAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
-    return {
-        code: Errors.ASSET_NOT_FOUND,
-        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
-    };
-}
-function errAssetSourceAlreadySet(name) {
-    return {
-        code: Errors.ASSET_SOURCE_ALREADY_SET,
-        message: `Unable to set the source for asset "${name}", source already set.`
-    };
-}
-function errNoAssetSourceSet(assetName) {
-    return {
-        code: Errors.ASSET_SOURCE_MISSING,
-        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 errDeprecation(deprecation) {
-    return {
-        code: Errors.DEPRECATED_FEATURE,
-        ...(typeof deprecation === 'string' ? { message: deprecation } : deprecation)
-    };
-}
-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.FILE_NAME_CONFLICT,
-        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
-    };
-}
-function errInputHookInOutputPlugin(pluginName, hookName) {
-    return {
-        code: Errors.INPUT_HOOK_IN_OUTPUT_PLUGIN,
-        message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
-    };
-}
-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.`
-    };
-}
-function errInvalidExportOptionValue(optionValue) {
-    return {
-        code: Errors.INVALID_EXPORT_OPTION,
-        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}"`,
-        url: `https://rollupjs.org/guide/en/#outputexports`
-    };
+
+const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
+const INTEROP_DEFAULT_LEGACY_VARIABLE = '_interopDefaultLegacy';
+const INTEROP_NAMESPACE_VARIABLE = '_interopNamespace';
+const INTEROP_NAMESPACE_DEFAULT_VARIABLE = '_interopNamespaceDefault';
+const INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE = '_interopNamespaceDefaultOnly';
+const defaultInteropHelpersByInteropType = {
+    auto: INTEROP_DEFAULT_VARIABLE,
+    default: null,
+    defaultOnly: null,
+    esModule: null,
+    false: null,
+    true: INTEROP_DEFAULT_LEGACY_VARIABLE
+};
+function isDefaultAProperty(interopType, externalLiveBindings) {
+    return (interopType === 'esModule' ||
+        (externalLiveBindings && (interopType === 'auto' || interopType === 'true')));
 }
-function errIncompatibleExportOptionValue(optionValue, keys, entryModule) {
-    return {
-        code: 'INVALID_EXPORT_OPTION',
-        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${keys.join(', ')}`
-    };
+const namespaceInteropHelpersByInteropType = {
+    auto: INTEROP_NAMESPACE_VARIABLE,
+    default: INTEROP_NAMESPACE_DEFAULT_VARIABLE,
+    defaultOnly: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE,
+    esModule: null,
+    false: null,
+    true: INTEROP_NAMESPACE_VARIABLE
+};
+function canDefaultBeTakenFromNamespace(interopType, externalLiveBindings) {
+    return (isDefaultAProperty(interopType, externalLiveBindings) &&
+        defaultInteropHelpersByInteropType[interopType] === INTEROP_DEFAULT_VARIABLE);
 }
-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.`
-    };
+function getDefaultOnlyHelper() {
+    return INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE;
 }
-function errInvalidOption(option, explanation) {
-    return {
-        code: Errors.INVALID_OPTION,
-        message: `Invalid value for option "${option}" - ${explanation}.`
-    };
+function getHelpersBlock(usedHelpers, accessedGlobals, _, n, s, t, liveBindings, freeze, namespaceToStringTag) {
+    return HELPER_NAMES.map(variable => usedHelpers.has(variable) || accessedGlobals.has(variable)
+        ? HELPER_GENERATORS[variable](_, n, s, t, liveBindings, freeze, namespaceToStringTag, usedHelpers)
+        : '').join('');
 }
-function errInvalidRollupPhaseForAddWatchFile() {
-    return {
-        code: Errors.INVALID_ROLLUP_PHASE,
-        message: `Cannot call addWatchFile after the build has finished.`
-    };
+const HELPER_GENERATORS = {
+    [INTEROP_DEFAULT_VARIABLE]: (_, n, s, _t, liveBindings) => `function ${INTEROP_DEFAULT_VARIABLE}${_}(e)${_}{${_}return ` +
+        `e${_}&&${_}e.__esModule${_}?${_}` +
+        `${liveBindings ? getDefaultLiveBinding(_) : getDefaultStatic(_)}${s}${_}}${n}${n}`,
+    [INTEROP_DEFAULT_LEGACY_VARIABLE]: (_, n, s, _t, liveBindings) => `function ${INTEROP_DEFAULT_LEGACY_VARIABLE}${_}(e)${_}{${_}return ` +
+        `e${_}&&${_}typeof e${_}===${_}'object'${_}&&${_}'default'${_}in e${_}?${_}` +
+        `${liveBindings ? getDefaultLiveBinding(_) : getDefaultStatic(_)}${s}${_}}${n}${n}`,
+    [INTEROP_NAMESPACE_VARIABLE]: (_, n, s, t, liveBindings, freeze, namespaceToStringTag, usedHelpers) => `function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
+        (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)
+            ? `${t}return e${_}&&${_}e.__esModule${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${s}${n}`
+            : `${t}if${_}(e${_}&&${_}e.__esModule)${_}return e;${n}` +
+                createNamespaceObject(_, n, t, t, liveBindings, freeze, namespaceToStringTag)) +
+        `}${n}${n}`,
+    [INTEROP_NAMESPACE_DEFAULT_VARIABLE]: (_, n, _s, t, liveBindings, freeze, namespaceToStringTag) => `function ${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${_}{${n}` +
+        createNamespaceObject(_, n, t, t, liveBindings, freeze, namespaceToStringTag) +
+        `}${n}${n}`,
+    [INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE]: (_, n, _s, t, _liveBindings, freeze, namespaceToStringTag) => `function ${INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE}(e)${_}{${n}` +
+        `${t}return ${getFrozen(`{__proto__: null,${namespaceToStringTag ? `${_}[Symbol.toStringTag]:${_}'Module',` : ''}${_}'default':${_}e}`, freeze)};${n}` +
+        `}${n}${n}`
+};
+function getDefaultLiveBinding(_) {
+    return `e${_}:${_}{${_}'default':${_}e${_}}`;
 }
-function errInvalidRollupPhaseForChunkEmission() {
-    return {
-        code: Errors.INVALID_ROLLUP_PHASE,
-        message: `Cannot emit chunks after module loading has finished.`
-    };
+function getDefaultStatic(_) {
+    return `e['default']${_}:${_}e`;
 }
-function errImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
-    return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
-        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
-    };
+function createNamespaceObject(_, n, t, i, liveBindings, freeze, namespaceToStringTag) {
+    return (`${i}var n${_}=${_}${namespaceToStringTag
+        ? `{__proto__:${_}null,${_}[Symbol.toStringTag]:${_}'Module'}`
+        : 'Object.create(null)'};${n}` +
+        `${i}if${_}(e)${_}{${n}` +
+        `${i}${t}Object.keys(e).forEach(function${_}(k)${_}{${n}` +
+        (liveBindings ? copyPropertyLiveBinding : copyPropertyStatic)(_, n, t, i + t + t) +
+        `${i}${t}});${n}` +
+        `${i}}${n}` +
+        `${i}n['default']${_}=${_}e;${n}` +
+        `${i}return ${getFrozen('n', freeze)};${n}`);
 }
-function errUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
-    return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
-        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
-    };
+function copyPropertyLiveBinding(_, n, t, i) {
+    return (`${i}if${_}(k${_}!==${_}'default')${_}{${n}` +
+        `${i}${t}var d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${i}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${i}${t}${t}enumerable:${_}true,${n}` +
+        `${i}${t}${t}get:${_}function${_}()${_}{${n}` +
+        `${i}${t}${t}${t}return e[k];${n}` +
+        `${i}${t}${t}}${n}` +
+        `${i}${t}});${n}` +
+        `${i}}${n}`);
 }
-function errImplicitDependantIsNotIncluded(module) {
-    const implicitDependencies = Array.from(module.implicitlyLoadedBefore, dependency => relativeId(dependency.id)).sort();
-    return {
-        code: Errors.MISSING_IMPLICIT_DEPENDANT,
-        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before "${implicitDependencies.length === 1
-            ? implicitDependencies[0]
-            : `${implicitDependencies.slice(0, -1).join('", "')}" and "${implicitDependencies.slice(-1)[0]}`}" is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
-    };
+function copyPropertyStatic(_, n, _t, i) {
+    return `${i}n[k]${_}=${_}e[k];${n}`;
 }
-function errMixedExport(facadeModuleId, name) {
-    return {
-        code: Errors.MIXED_EXPORTS,
-        id: facadeModuleId,
-        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}["default"]\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning`,
-        url: `https://rollupjs.org/guide/en/#outputexports`
-    };
+function getFrozen(fragment, freeze) {
+    return freeze ? `Object.freeze(${fragment})` : fragment;
 }
-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)`,
-        name,
-        reexporter: reexportingModule.id,
-        sources: [reexportingModule.exportsAll[name], additionalExportAllModule.exportsAll[name]]
-    };
+const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
+
+function getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, mechanism = 'return ') {
+    const _ = compact ? '' : ' ';
+    const n = compact ? '' : '\n';
+    if (!namedExportsMode) {
+        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings)};`;
+    }
+    let exportBlock = '';
+    // star exports must always output first for precedence
+    for (const { name, reexports } of dependencies) {
+        if (reexports && namedExportsMode) {
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    if (exportBlock)
+                        exportBlock += 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}});`;
+                    }
+                }
+            }
+        }
+    }
+    for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        if (reexports && namedExportsMode) {
+            for (const specifier of reexports) {
+                if (specifier.reexported !== '*') {
+                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings);
+                    if (exportBlock)
+                        exportBlock += n;
+                    exportBlock +=
+                        specifier.imported !== '*' && specifier.needsLiveBinding
+                            ? `Object.defineProperty(exports,${_}'${specifier.reexported}',${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}get:${_}function${_}()${_}{${n}` +
+                                `${t}${t}return ${importName};${n}${t}}${n}});`
+                            : `exports.${specifier.reexported}${_}=${_}${importName};`;
+                }
+            }
+        }
+    }
+    for (const chunkExport of exports) {
+        const lhs = `exports.${chunkExport.exported}`;
+        const rhs = chunkExport.local;
+        if (lhs !== rhs) {
+            if (exportBlock)
+                exportBlock += n;
+            exportBlock += `${lhs}${_}=${_}${rhs};`;
+        }
+    }
+    if (exportBlock) {
+        return `${n}${n}${exportBlock}`;
+    }
+    return '';
 }
-function errNoTransformMapOrAstWithoutCode(pluginName) {
-    return {
-        code: Errors.NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
-        message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
-            'a "code". This will be ignored.'
-    };
+function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings) {
+    if (exports.length > 0) {
+        return exports[0].local;
+    }
+    else {
+        for (const { defaultVariableName, id, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (reexports) {
+                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, id, externalLiveBindings);
+            }
+        }
+    }
 }
-function errPreferNamedExports(facadeModuleId) {
-    const file = relativeId(facadeModuleId);
-    return {
-        code: Errors.PREFER_NAMED_EXPORTS,
-        id: facadeModuleId,
-        message: `Entry module "${file}" is implicitly using "default" export mode, which means for CommonJS output that its default export is assigned to "module.exports". For many tools, such CommonJS output will not be interchangeable with the original ES module. If this is intended, explicitly set "output.exports" to either "auto" or "default", otherwise you might want to consider changing the signature of "${file}" to use named exports only.`,
-        url: `https://rollupjs.org/guide/en/#outputexports`
-    };
+function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings) {
+    if (imported === 'default') {
+        if (!isChunk) {
+            const moduleInterop = String(interop(moduleId));
+            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                ? defaultVariableName
+                : moduleVariableName;
+            return isDefaultAProperty(moduleInterop, externalLiveBindings)
+                ? `${variableName}['default']`
+                : variableName;
+        }
+        return depNamedExportsMode ? `${moduleVariableName}['default']` : moduleVariableName;
+    }
+    if (imported === '*') {
+        return (isChunk
+            ? !depNamedExportsMode
+            : namespaceInteropHelpersByInteropType[String(interop(moduleId))])
+            ? namespaceVariableName
+            : moduleVariableName;
+    }
+    return `${moduleVariableName}.${imported}`;
 }
-function errUnexpectedNamedImport(id, imported, isReexport) {
-    const importType = isReexport ? 'reexport' : 'import';
-    return {
-        code: Errors.UNEXPECTED_NAMED_IMPORT,
-        id,
-        message: `The named export "${imported}" was ${importType}ed from the external module ${relativeId(id)} even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
-        url: 'https://rollupjs.org/guide/en/#outputinterop'
-    };
+function getEsModuleExport(_) {
+    return `Object.defineProperty(exports,${_}'__esModule',${_}{${_}value:${_}true${_}});`;
 }
-function errUnexpectedNamespaceReexport(id) {
-    return {
-        code: Errors.UNEXPECTED_NAMED_IMPORT,
-        id,
-        message: `There was a namespace "*" reexport from the external module ${relativeId(id)} even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
-        url: 'https://rollupjs.org/guide/en/#outputinterop'
-    };
+function getNamespaceToStringExport(_) {
+    return `exports[Symbol.toStringTag]${_}=${_}'Module';`;
 }
-function errEntryCannotBeExternal(unresolvedId) {
-    return {
-        code: Errors.UNRESOLVED_ENTRY,
-        message: `Entry module cannot be external (${relativeId(unresolvedId)}).`
-    };
+function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, _, n) {
+    let namespaceMarkers = '';
+    if (hasNamedExports) {
+        if (addEsModule) {
+            namespaceMarkers += getEsModuleExport(_);
+        }
+        if (addNamespaceToStringTag) {
+            if (namespaceMarkers) {
+                namespaceMarkers += n;
+            }
+            namespaceMarkers += getNamespaceToStringExport(_);
+        }
+    }
+    return namespaceMarkers;
 }
-function errUnresolvedEntry(unresolvedId) {
-    return {
-        code: Errors.UNRESOLVED_ENTRY,
-        message: `Could not resolve entry module (${relativeId(unresolvedId)}).`
+
+function getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t) {
+    const neededInteropHelpers = new Set();
+    const interopStatements = [];
+    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
+        neededInteropHelpers.add(helper);
+        interopStatements.push(`${varOrConst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
     };
+    for (const { defaultVariableName, imports, id, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        if (isChunk) {
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                if (imported === '*' && reexported !== '*') {
+                    if (!namedExportsMode) {
+                        addInteropStatement(namespaceVariableName, getDefaultOnlyHelper(), name);
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            const moduleInterop = String(interop(id));
+            let hasDefault = false;
+            let hasNamespace = false;
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                let helper;
+                let variableName;
+                if (imported === 'default') {
+                    if (!hasDefault) {
+                        hasDefault = true;
+                        if (defaultVariableName !== namespaceVariableName) {
+                            variableName = defaultVariableName;
+                            helper = defaultInteropHelpersByInteropType[moduleInterop];
+                        }
+                    }
+                }
+                else if (imported === '*' && reexported !== '*') {
+                    if (!hasNamespace) {
+                        hasNamespace = true;
+                        helper = namespaceInteropHelpersByInteropType[moduleInterop];
+                        variableName = namespaceVariableName;
+                    }
+                }
+                if (helper) {
+                    addInteropStatement(variableName, helper, name);
+                }
+            }
+        }
+    }
+    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, _, n, s, t, externalLiveBindings, freeze, namespaceToStringTag)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
 }
-function errUnresolvedImport(source, importer) {
-    return {
-        code: Errors.UNRESOLVED_IMPORT,
-        message: `Could not resolve '${source}' from ${relativeId(importer)}`
-    };
+
+// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
+// The assumption is that this makes sense for all relative ids:
+// https://requirejs.org/docs/api.html#jsfiles
+function removeExtensionFromRelativeAmdId(id) {
+    return id[0] === '.' ? removeJsExtension(id) : id;
 }
-function 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`,
-        source,
-        url: 'https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency'
-    };
+
+const builtins$1 = {
+    assert: true,
+    buffer: true,
+    console: true,
+    constants: true,
+    domain: true,
+    events: true,
+    http: true,
+    https: true,
+    os: true,
+    path: true,
+    process: true,
+    punycode: true,
+    querystring: true,
+    stream: true,
+    string_decoder: true,
+    timers: true,
+    tty: true,
+    url: true,
+    util: true,
+    vm: true,
+    zlib: true
+};
+function warnOnBuiltins(warn, dependencies) {
+    const externalBuiltins = dependencies.map(({ id }) => id).filter(id => id in builtins$1);
+    if (!externalBuiltins.length)
+        return;
+    const detail = externalBuiltins.length === 1
+        ? `module ('${externalBuiltins[0]}')`
+        : `modules (${externalBuiltins
+            .slice(0, -1)
+            .map(name => `'${name}'`)
+            .join(', ')} and '${externalBuiltins.slice(-1)}')`;
+    warn({
+        code: 'MISSING_NODE_BUILTINS',
+        message: `Creating a browser bundle that depends on Node.js built-in ${detail}. You might need to include https://github.com/ionic-team/rollup-plugin-node-polyfills`,
+        modules: externalBuiltins
+    });
 }
-function errExternalSyntheticExports(source, importer) {
-    return {
-        code: Errors.EXTERNAL_SYNTHETIC_EXPORTS,
-        importer: relativeId(importer),
-        message: `External '${source}' can not have 'syntheticNamedExports' enabled.`,
-        source
-    };
+
+function amd(magicString, { accessedGlobals, dependencies, exports, hasExports, id, indentString: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, varOrConst, warn }, { amd, compact, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
+    warnOnBuiltins(warn, dependencies);
+    const deps = dependencies.map(m => `'${removeExtensionFromRelativeAmdId(m.id)}'`);
+    const args = dependencies.map(m => m.name);
+    const n = compact ? '' : '\n';
+    const s = compact ? '' : ';';
+    const _ = compact ? '' : ' ';
+    if (namedExportsMode && hasExports) {
+        args.unshift(`exports`);
+        deps.unshift(`'exports'`);
+    }
+    if (accessedGlobals.has('require')) {
+        args.unshift('require');
+        deps.unshift(`'require'`);
+    }
+    if (accessedGlobals.has('module')) {
+        args.unshift('module');
+        deps.unshift(`'module'`);
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const params = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (deps.length ? `[${deps.join(`,${_}`)}],${_}` : ``);
+    const useStrict = strict ? `${_}'use strict';` : '';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t)}`);
+    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && esModule, isModuleFacade && namespaceToStringTag, _, n);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString.append(`${exportBlock}${namespaceMarkers}${outro}`);
+    return magicString
+        .indent(t)
+        .prepend(`${amd.define}(${params}function${_}(${args.join(`,${_}`)})${_}{${useStrict}${n}${n}`)
+        .append(`${n}${n}});`);
 }
-function errFailedValidation(message) {
-    return {
-        code: Errors.VALIDATION_ERROR,
-        message
-    };
+
+function cjs(magicString, { accessedGlobals, dependencies, exports, hasExports, indentString: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, varOrConst }, { compact, esModule, externalLiveBindings, freeze, interop, namespaceToStringTag, strict }) {
+    const n = compact ? '' : '\n';
+    const s = compact ? '' : ';';
+    const _ = compact ? '' : ' ';
+    const useStrict = strict ? `'use strict';${n}${n}` : '';
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && esModule, isModuleFacade && namespaceToStringTag, _, n);
+    if (namespaceMarkers) {
+        namespaceMarkers += n + n;
+    }
+    const importBlock = getImportBlock(dependencies, compact, varOrConst, n, _);
+    const interopBlock = getInteropBlock(dependencies, varOrConst, interop, externalLiveBindings, freeze, namespaceToStringTag, accessedGlobals, _, n, s, t);
+    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
+    const exportBlock = getExportBlock(exports, dependencies, namedExportsMode, interop, compact, t, externalLiveBindings, `module.exports${_}=${_}`);
+    return magicString.append(`${exportBlock}${outro}`);
 }
-function errAlreadyClosed() {
-    return {
-        code: Errors.ALREADY_CLOSED,
-        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
-    };
+function getImportBlock(dependencies, compact, varOrConst, n, _) {
+    let importBlock = '';
+    let definingVariable = false;
+    for (const { id, name, reexports, imports } of dependencies) {
+        if (!reexports && !imports) {
+            if (importBlock) {
+                importBlock += !compact || definingVariable ? `;${n}` : ',';
+            }
+            definingVariable = false;
+            importBlock += `require('${id}')`;
+        }
+        else {
+            importBlock +=
+                compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${varOrConst} `;
+            definingVariable = true;
+            importBlock += `${name}${_}=${_}require('${id}')`;
+        }
+    }
+    if (importBlock) {
+        return `${importBlock};${n}${n}`;
+    }
+    return '';
 }
-function warnDeprecation(deprecation, activeDeprecation, options) {
-    warnDeprecationWithOptions(deprecation, activeDeprecation, options.onwarn, options.strictDeprecations);
+
+function es(magicString, { intro, outro, dependencies, exports, varOrConst }, { compact }) {
+    const _ = compact ? '' : ' ';
+    const n = compact ? '' : '\n';
+    const importBlock = getImportBlock$1(dependencies, _);
+    if (importBlock.length > 0)
+        intro += importBlock.join(n) + n + n;
+    if (intro)
+        magicString.prepend(intro);
+    const exportBlock = getExportBlock$1(exports, _, varOrConst);
+    if (exportBlock.length)
+        magicString.append(n + n + exportBlock.join(n).trim());
+    if (outro)
+        magicString.append(outro);
+    return magicString.trim();
 }
-function warnDeprecationWithOptions(deprecation, activeDeprecation, warn, strictDeprecations) {
-    if (activeDeprecation || strictDeprecations) {
-        const warning = errDeprecation(deprecation);
-        if (strictDeprecations) {
-            return error(warning);
+function getImportBlock$1(dependencies, _) {
+    const importBlock = [];
+    for (const { id, reexports, imports, name } of dependencies) {
+        if (!reexports && !imports) {
+            importBlock.push(`import${_}'${id}';`);
+            continue;
         }
-        warn(warning);
+        if (imports) {
+            let defaultImport = null;
+            let starImport = null;
+            const importedNames = [];
+            for (const specifier of imports) {
+                if (specifier.imported === 'default') {
+                    defaultImport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    starImport = specifier;
+                }
+                else {
+                    importedNames.push(specifier);
+                }
+            }
+            if (starImport) {
+                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}'${id}';`);
+            }
+            if (defaultImport && importedNames.length === 0) {
+                importBlock.push(`import ${defaultImport.local} from${_}'${id}';`);
+            }
+            else if (importedNames.length > 0) {
+                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
+                    .map(specifier => {
+                    if (specifier.imported === specifier.local) {
+                        return specifier.imported;
+                    }
+                    else {
+                        return `${specifier.imported} as ${specifier.local}`;
+                    }
+                })
+                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
+            }
+        }
+        if (reexports) {
+            let starExport = null;
+            const namespaceReexports = [];
+            const namedReexports = [];
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    starExport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    namespaceReexports.push(specifier);
+                }
+                else {
+                    namedReexports.push(specifier);
+                }
+            }
+            if (starExport) {
+                importBlock.push(`export${_}*${_}from${_}'${id}';`);
+            }
+            if (namespaceReexports.length > 0) {
+                if (!imports ||
+                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
+                    importBlock.push(`import${_}*${_}as ${name} from${_}'${id}';`);
+                }
+                for (const specifier of namespaceReexports) {
+                    importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${specifier.reexported}`} };`);
+                }
+            }
+            if (namedReexports.length > 0) {
+                importBlock.push(`export${_}{${_}${namedReexports
+                    .map(specifier => {
+                    if (specifier.imported === specifier.reexported) {
+                        return specifier.imported;
+                    }
+                    else {
+                        return `${specifier.imported} as ${specifier.reexported}`;
+                    }
+                })
+                    .join(`,${_}`)}${_}}${_}from${_}'${id}';`);
+            }
+        }
+    }
+    return importBlock;
+}
+function getExportBlock$1(exports, _, varOrConst) {
+    const exportBlock = [];
+    const exportDeclaration = [];
+    for (const specifier of exports) {
+        if (specifier.exported === 'default') {
+            exportBlock.push(`export default ${specifier.local};`);
+        }
+        else {
+            if (specifier.expression) {
+                exportBlock.push(`${varOrConst} ${specifier.local}${_}=${_}${specifier.expression};`);
+            }
+            exportDeclaration.push(specifier.exported === specifier.local
+                ? specifier.local
+                : `${specifier.local} as ${specifier.exported}`);
+        }
+    }
+    if (exportDeclaration.length) {
+        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
     }
+    return exportBlock;
 }
 
 // Generate strings which dereference dotted properties, but use array notation `['prop-deref']`
@@ -6221,7 +6234,8 @@ class AssignmentExpression extends NodeBase {
             this.right.render(code, options, {
                 renderedParentType: renderedParentType || this.parent.type
             });
-            code.remove(this.start, this.right.start);
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', this.left.end);
+            code.remove(this.start, findNonWhiteSpace(code.original, operatorPos + 1));
         }
         if (options.format === 'system') {
             const exportNames = this.left.variable && options.exportNamesByVariable.get(this.left.variable);
@@ -6465,7 +6479,6 @@ class MemberExpression extends NodeBase {
         this.replacement = null;
         this.wasPathDeoptimizedWhileOptimized = false;
     }
-    addExportedVariables() { }
     bind() {
         if (this.bound)
             return;
@@ -6572,7 +6585,7 @@ class MemberExpression extends NodeBase {
         if (!this.included) {
             this.included = true;
             if (this.variable !== null) {
-                this.context.includeVariable(this.variable);
+                this.context.includeVariableInModule(this.variable);
             }
         }
         this.object.include(context, includeChildrenRecursively);
@@ -6612,7 +6625,7 @@ class MemberExpression extends NodeBase {
             const variable = this.scope.findVariable(this.object.name);
             if (variable.isNamespace) {
                 if (this.variable) {
-                    this.context.includeVariable(this.variable);
+                    this.context.includeVariableInModule(this.variable);
                 }
                 this.context.warn({
                     code: 'ILLEGAL_NAMESPACE_REASSIGNMENT',
@@ -7240,7 +7253,7 @@ class ForInStatement extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
-        this.left.includeWithAllDeclaredVariables(includeChildrenRecursively, context);
+        this.left.includeAllDeclaredVariables(context, includeChildrenRecursively);
         this.left.deoptimizePath(EMPTY_PATH);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
@@ -7274,7 +7287,7 @@ class ForOfStatement extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
-        this.left.includeWithAllDeclaredVariables(includeChildrenRecursively, context);
+        this.left.includeAllDeclaredVariables(context, includeChildrenRecursively);
         this.left.deoptimizePath(EMPTY_PATH);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
@@ -8969,7 +8982,7 @@ function isReassignedExportsMember(variable, exportNamesByVariable) {
 }
 function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
     for (const declarator of declarations) {
-        if (!declarator.included)
+        if (!declarator.id.included)
             return false;
         if (declarator.id.type === Identifier) {
             if (exportNamesByVariable.has(declarator.id.variable))
@@ -9000,10 +9013,11 @@ class VariableDeclaration extends NodeBase {
                 declarator.include(context, includeChildrenRecursively);
         }
     }
-    includeWithAllDeclaredVariables(includeChildrenRecursively, context) {
+    includeAllDeclaredVariables(context, includeChildrenRecursively) {
         this.included = true;
         for (const declarator of this.declarations) {
-            declarator.include(context, includeChildrenRecursively);
+            declarator.id.included = true;
+            declarator.includeAllDeclaredVariables(context, includeChildrenRecursively);
         }
     }
     initialise() {
@@ -9025,13 +9039,11 @@ class VariableDeclaration extends NodeBase {
             this.renderReplacedDeclarations(code, options, nodeRenderOptions);
         }
     }
-    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, addSemicolon, systemPatternExports, options) {
+    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
         if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
             code.remove(this.end - 1, this.end);
         }
-        if (addSemicolon) {
-            separatorString += ';';
-        }
+        separatorString += ';';
         if (lastSeparatorPos !== null) {
             if (code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/ &&
                 (code.original.charCodeAt(this.end) === 10 /*"\n"*/ ||
@@ -9056,15 +9068,10 @@ class VariableDeclaration extends NodeBase {
             code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
         }
     }
-    renderReplacedDeclarations(code, options, { start = this.start, end = this.end, isNoStatement }) {
+    renderReplacedDeclarations(code, options, { start = this.start, end = this.end }) {
         const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.declarations, code, this.start + this.kind.length, this.end - (code.original.charCodeAt(this.end - 1) === 59 /*";"*/ ? 1 : 0));
         let actualContentEnd, renderedContentEnd;
-        if (/\n\s*$/.test(code.slice(this.start, separatedNodes[0].start))) {
-            renderedContentEnd = this.start + this.kind.length;
-        }
-        else {
-            renderedContentEnd = separatedNodes[0].start;
-        }
+        renderedContentEnd = findNonWhiteSpace(code.original, this.start + this.kind.length);
         let lastSeparatorPos = renderedContentEnd - 1;
         code.remove(this.start, lastSeparatorPos);
         let isInDeclaration = false;
@@ -9081,8 +9088,9 @@ class VariableDeclaration extends NodeBase {
             }
             leadingString = '';
             nextSeparatorString = '';
-            if (node.id instanceof Identifier$1 &&
-                isReassignedExportsMember(node.id.variable, options.exportNamesByVariable)) {
+            if (!node.id.included ||
+                (node.id instanceof Identifier$1 &&
+                    isReassignedExportsMember(node.id.variable, options.exportNamesByVariable))) {
                 if (hasRenderedContent) {
                     separatorString += ';';
                 }
@@ -9131,7 +9139,7 @@ class VariableDeclaration extends NodeBase {
             separatorString = nextSeparatorString;
         }
         if (hasRenderedContent) {
-            this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, !isNoStatement, systemPatternExports, options);
+            this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options);
         }
         else {
             code.remove(start, end);
@@ -9146,6 +9154,35 @@ class VariableDeclarator extends NodeBase {
     deoptimizePath(path) {
         this.id.deoptimizePath(path);
     }
+    hasEffects(context) {
+        return this.id.hasEffects(context) || (this.init !== null && this.init.hasEffects(context));
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        if (includeChildrenRecursively || this.id.shouldBeIncluded(context)) {
+            this.id.include(context, includeChildrenRecursively);
+        }
+        if (this.init) {
+            this.init.include(context, includeChildrenRecursively);
+        }
+    }
+    includeAllDeclaredVariables(context, includeChildrenRecursively) {
+        this.included = true;
+        this.id.include(context, includeChildrenRecursively);
+    }
+    render(code, options) {
+        const renderId = this.id.included;
+        if (renderId) {
+            this.id.render(code, options);
+        }
+        else {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', this.id.end);
+            code.remove(this.start, findNonWhiteSpace(code.original, operatorPos + 1));
+        }
+        if (this.init) {
+            this.init.render(code, options, renderId ? BLANK : { renderedParentType: ExpressionStatement });
+        }
+    }
 }
 
 class WhileStatement extends NodeBase {
@@ -9721,6 +9758,24 @@ function initialiseTimers(inputOptions) {
     }
 }
 
+function markModuleAndImpureDependenciesAsExecuted(baseModule) {
+    baseModule.isExecuted = true;
+    const modules = [baseModule];
+    const visitedModules = new Set();
+    for (const module of modules) {
+        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
+            if (!(dependency instanceof ExternalModule) &&
+                !dependency.isExecuted &&
+                (dependency.info.hasModuleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
+                !visitedModules.has(dependency.id)) {
+                dependency.isExecuted = true;
+                visitedModules.add(dependency.id);
+                modules.push(dependency);
+            }
+        }
+    }
+}
+
 function tryParse(module, Parser, acornOptions) {
     try {
         return Parser.parse(module.info.code, {
@@ -9743,39 +9798,60 @@ function tryParse(module, Parser, acornOptions) {
         }, err.pos);
     }
 }
-function handleMissingExport(exportName, importingModule, importedModule, importerStart) {
-    return importingModule.error({
-        code: 'MISSING_EXPORT',
-        message: `'${exportName}' is not exported by ${relativeId(importedModule)}, imported by ${relativeId(importingModule.id)}`,
-        url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
-    }, importerStart);
-}
 const MISSING_EXPORT_SHIM_DESCRIPTION = {
     identifier: null,
     localName: MISSING_EXPORT_SHIM_VARIABLE
 };
-function getVariableForExportNameRecursive(target, name, isExportAllSearch, searchedNamesAndModules = new Map()) {
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map()) {
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
-            return null;
+            return isExportAllSearch ? null : error(errCircularReexport(name, target.id));
         }
         searchedModules.add(target);
     }
     else {
         searchedNamesAndModules.set(name, new Set([target]));
     }
-    return target.getVariableForExportName(name, isExportAllSearch, searchedNamesAndModules);
+    return target.getVariableForExportName(name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules);
+}
+function getAndExtendSideEffectModules(variable, module) {
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, () => new Set());
+    let currentVariable = variable;
+    const referencedVariables = new Set([currentVariable]);
+    while (true) {
+        const importingModule = currentVariable.module;
+        currentVariable =
+            currentVariable instanceof ExportDefaultVariable
+                ? currentVariable.getDirectOriginalVariable()
+                : currentVariable instanceof SyntheticNamedExportVariable
+                    ? currentVariable.syntheticNamespace
+                    : null;
+        if (!currentVariable || referencedVariables.has(currentVariable)) {
+            break;
+        }
+        referencedVariables.add(variable);
+        sideEffectModules.add(importingModule);
+        const originalSideEffects = importingModule.sideEffectDependenciesByVariable.get(currentVariable);
+        if (originalSideEffects) {
+            for (const module of originalSideEffects) {
+                sideEffectModules.add(module);
+            }
+        }
+    }
+    return sideEffectModules;
 }
 class Module {
     constructor(graph, id, options, isEntry, hasModuleSideEffects, syntheticNamedExports, meta) {
         this.graph = graph;
         this.id = id;
         this.options = options;
+        this.alternativeReexportModules = new Map();
         this.ast = null;
         this.chunkFileNames = new Set();
         this.chunkName = null;
         this.comments = [];
+        this.cycles = new Set();
         this.dependencies = new Set();
         this.dynamicDependencies = new Set();
         this.dynamicImporters = [];
@@ -9795,6 +9871,7 @@ class Module {
         this.isUserDefinedEntryPoint = false;
         this.preserveSignature = this.options.preserveEntrySignatures;
         this.reexportDescriptions = Object.create(null);
+        this.sideEffectDependenciesByVariable = new Map();
         this.sources = new Set();
         this.userChunkNames = new Set();
         this.usesTopLevelAwait = false;
@@ -9884,9 +9961,9 @@ class Module {
         if (this.relevantDependencies)
             return this.relevantDependencies;
         const relevantDependencies = new Set();
-        const additionalSideEffectModules = new Set();
-        const possibleDependencies = new Set(this.dependencies);
-        let dependencyVariables = this.imports;
+        const necessaryDependencies = new Set();
+        const alwaysCheckedDependencies = new Set();
+        let dependencyVariables = this.imports.keys();
         if (this.info.isEntry ||
             this.includedDynamicImporters.length > 0 ||
             this.namespace.included ||
@@ -9897,41 +9974,31 @@ class Module {
             }
         }
         for (let variable of dependencyVariables) {
+            const sideEffectDependencies = this.sideEffectDependenciesByVariable.get(variable);
+            if (sideEffectDependencies) {
+                for (const module of sideEffectDependencies) {
+                    alwaysCheckedDependencies.add(module);
+                }
+            }
             if (variable instanceof SyntheticNamedExportVariable) {
                 variable = variable.getBaseVariable();
             }
             else if (variable instanceof ExportDefaultVariable) {
-                const { modules, original } = variable.getOriginalVariableAndDeclarationModules();
-                variable = original;
-                for (const module of modules) {
-                    additionalSideEffectModules.add(module);
-                    possibleDependencies.add(module);
-                }
+                variable = variable.getOriginalVariable();
             }
-            relevantDependencies.add(variable.module);
+            necessaryDependencies.add(variable.module);
         }
         if (this.options.treeshake && this.info.hasModuleSideEffects !== 'no-treeshake') {
-            for (const dependency of possibleDependencies) {
-                if (!(dependency.info.hasModuleSideEffects ||
-                    additionalSideEffectModules.has(dependency)) ||
-                    relevantDependencies.has(dependency)) {
-                    continue;
-                }
-                if (dependency instanceof ExternalModule || dependency.hasEffects()) {
-                    relevantDependencies.add(dependency);
-                }
-                else {
-                    for (const transitiveDependency of dependency.dependencies) {
-                        possibleDependencies.add(transitiveDependency);
-                    }
-                }
-            }
+            this.addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies);
         }
         else {
             for (const dependency of this.dependencies) {
                 relevantDependencies.add(dependency);
             }
         }
+        for (const dependency of necessaryDependencies) {
+            relevantDependencies.add(dependency);
+        }
         return (this.relevantDependencies = relevantDependencies);
     }
     getExportNamesByVariable() {
@@ -10004,20 +10071,14 @@ class Module {
                 : 'default');
         }
         if (!this.syntheticNamespace) {
-            return error({
-                code: Errors.SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
-                id: this.id,
-                message: `Module "${relativeId(this.id)}" that is marked with 'syntheticNamedExports: ${JSON.stringify(this.info.syntheticNamedExports)}' needs ${typeof this.info.syntheticNamedExports === 'string' &&
-                    this.info.syntheticNamedExports !== 'default'
-                    ? `an export named "${this.info.syntheticNamedExports}"`
-                    : 'a default export'}.`
-            });
+            return error(errSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, isExportAllSearch, searchedNamesAndModules) {
+    getVariableForExportName(name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules) {
         if (name[0] === '*') {
             if (name.length === 1) {
+                // export * from './other'
                 return this.namespace;
             }
             else {
@@ -10029,11 +10090,14 @@ class Module {
         // export { foo } from './other'
         const reexportDeclaration = this.reexportDescriptions[name];
         if (reexportDeclaration) {
-            const declaration = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, false, searchedNamesAndModules);
-            if (!declaration) {
-                return handleMissingExport(reexportDeclaration.localName, this, reexportDeclaration.module.id, reexportDeclaration.start);
+            const variable = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
+            if (!variable) {
+                return this.error(errMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
             }
-            return declaration;
+            if (importerForSideEffects) {
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+            }
+            return variable;
         }
         const exportDeclaration = this.exports[name];
         if (exportDeclaration) {
@@ -10041,28 +10105,43 @@ class Module {
                 return this.exportShimVariable;
             }
             const name = exportDeclaration.localName;
-            return this.traceVariable(name);
+            const variable = this.traceVariable(name, importerForSideEffects);
+            if (importerForSideEffects) {
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, () => new Set()).add(this);
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+            }
+            return variable;
         }
         if (name !== 'default') {
+            let foundSyntheticDeclaration = null;
             for (const module of this.exportAllModules) {
-                const declaration = getVariableForExportNameRecursive(module, name, true, searchedNamesAndModules);
-                if (declaration)
-                    return declaration;
+                const declaration = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, searchedNamesAndModules);
+                if (declaration) {
+                    if (!(declaration instanceof SyntheticNamedExportVariable)) {
+                        return declaration;
+                    }
+                    if (!foundSyntheticDeclaration) {
+                        foundSyntheticDeclaration = declaration;
+                    }
+                }
+            }
+            if (foundSyntheticDeclaration) {
+                return foundSyntheticDeclaration;
+            }
+        }
+        if (this.info.syntheticNamedExports) {
+            let syntheticExport = this.syntheticExports.get(name);
+            if (!syntheticExport) {
+                const syntheticNamespace = this.getSyntheticNamespace();
+                syntheticExport = new SyntheticNamedExportVariable(this.astContext, name, syntheticNamespace);
+                this.syntheticExports.set(name, syntheticExport);
+                return syntheticExport;
             }
+            return syntheticExport;
         }
         // we don't want to create shims when we are just
         // probing export * modules for exports
         if (!isExportAllSearch) {
-            if (this.info.syntheticNamedExports) {
-                let syntheticExport = this.syntheticExports.get(name);
-                if (!syntheticExport) {
-                    const syntheticNamespace = this.getSyntheticNamespace();
-                    syntheticExport = new SyntheticNamedExportVariable(this.astContext, name, syntheticNamespace);
-                    this.syntheticExports.set(name, syntheticExport);
-                    return syntheticExport;
-                }
-                return syntheticExport;
-            }
             if (this.options.shimMissingExports) {
                 this.shimMissingExport(name);
                 return this.exportShimVariable;
@@ -10089,8 +10168,7 @@ class Module {
                 const variable = this.getVariableForExportName(exportName);
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
-                    variable.include();
-                    this.graph.needsTreeshakingPass = true;
+                    this.includeVariable(variable);
                 }
             }
         }
@@ -10098,8 +10176,7 @@ class Module {
             const variable = this.getVariableForExportName(name);
             variable.deoptimizePath(UNKNOWN_PATH);
             if (!variable.included) {
-                variable.include();
-                this.graph.needsTreeshakingPass = true;
+                this.includeVariable(variable);
             }
             if (variable instanceof ExternalVariable) {
                 variable.module.reexported = true;
@@ -10119,7 +10196,7 @@ class Module {
         this.addModulesToImportDescriptions(this.importDescriptions);
         this.addModulesToImportDescriptions(this.reexportDescriptions);
         for (const name in this.exports) {
-            if (name !== 'default') {
+            if (name !== 'default' && name !== this.info.syntheticNamedExports) {
                 this.exportsAll[name] = this.id;
             }
         }
@@ -10199,7 +10276,7 @@ class Module {
             importDescriptions: this.importDescriptions,
             includeAllExports: () => this.includeAllExports(true),
             includeDynamicImport: this.includeDynamicImport.bind(this),
-            includeVariable: this.includeVariable.bind(this),
+            includeVariableInModule: this.includeVariableInModule.bind(this),
             magicString: this.magicString,
             module: this,
             moduleContext: this.context,
@@ -10235,7 +10312,7 @@ class Module {
             transformFiles: this.transformFiles
         };
     }
-    traceVariable(name) {
+    traceVariable(name, importerForSideEffects) {
         const localVariable = this.scope.variables.get(name);
         if (localVariable) {
             return localVariable;
@@ -10246,9 +10323,9 @@ class Module {
             if (otherModule instanceof Module && importDeclaration.name === '*') {
                 return otherModule.namespace;
             }
-            const declaration = otherModule.getVariableForExportName(importDeclaration.name);
+            const declaration = otherModule.getVariableForExportName(importDeclaration.name, importerForSideEffects || this);
             if (!declaration) {
-                return handleMissingExport(importDeclaration.name, this, otherModule.id, importDeclaration.start);
+                return this.error(errMissingExport(importDeclaration.name, this.id, otherModule.id), importDeclaration.start);
             }
             return declaration;
         }
@@ -10400,6 +10477,31 @@ class Module {
             specifier.module = this.graph.modulesById.get(id);
         }
     }
+    addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies) {
+        const handledDependencies = new Set();
+        const addSideEffectDependencies = (possibleDependencies) => {
+            for (const dependency of possibleDependencies) {
+                if (handledDependencies.has(dependency)) {
+                    continue;
+                }
+                handledDependencies.add(dependency);
+                if (necessaryDependencies.has(dependency)) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                if (!(dependency.info.hasModuleSideEffects || alwaysCheckedDependencies.has(dependency))) {
+                    continue;
+                }
+                if (dependency instanceof ExternalModule || dependency.hasEffects()) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                addSideEffectDependencies(dependency.dependencies);
+            }
+        };
+        addSideEffectDependencies(this.dependencies);
+        addSideEffectDependencies(alwaysCheckedDependencies);
+    }
     includeAndGetAdditionalMergedNamespaces() {
         const mergedNamespaces = [];
         for (const module of this.exportAllModules) {
@@ -10426,11 +10528,26 @@ class Module {
         }
     }
     includeVariable(variable) {
-        const variableModule = variable.module;
         if (!variable.included) {
             variable.include();
             this.graph.needsTreeshakingPass = true;
+            const variableModule = variable.module;
+            if (variableModule && variableModule !== this && variableModule instanceof Module) {
+                if (!variableModule.isExecuted) {
+                    markModuleAndImpureDependenciesAsExecuted(variableModule);
+                }
+                const sideEffectModules = getAndExtendSideEffectModules(variable, this);
+                for (const module of sideEffectModules) {
+                    if (!module.isExecuted) {
+                        markModuleAndImpureDependenciesAsExecuted(module);
+                    }
+                }
+            }
         }
+    }
+    includeVariableInModule(variable) {
+        this.includeVariable(variable);
+        const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
             this.imports.add(variable);
         }
@@ -10445,6 +10562,23 @@ class Module {
         this.exports[name] = MISSING_EXPORT_SHIM_DESCRIPTION;
     }
 }
+// if there is a cyclic import in the reexport chain, we should not
+// import from the original module but from the cyclic module to not
+// mess up execution order.
+function setAlternativeExporterIfCyclic(variable, importer, reexporter) {
+    if (variable.module instanceof Module && variable.module !== reexporter) {
+        const exporterCycles = variable.module.cycles;
+        if (exporterCycles.size > 0) {
+            const importerCycles = reexporter.cycles;
+            for (const cycleSymbol of importerCycles) {
+                if (exporterCycles.has(cycleSymbol)) {
+                    importer.alternativeReexportModules.set(variable, reexporter);
+                    break;
+                }
+            }
+        }
+    }
+}
 
 class Source {
     constructor(filename, content) {
@@ -10731,68 +10865,6 @@ function escapeId(id) {
     return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
 }
 
-const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
-function sortByExecutionOrder(units) {
-    units.sort(compareExecIndex);
-}
-function analyseModuleExecution(entryModules) {
-    let nextExecIndex = 0;
-    const cyclePaths = [];
-    const analysedModules = new Set();
-    const dynamicImports = new Set();
-    const parents = new Map();
-    const orderedModules = [];
-    const analyseModule = (module) => {
-        if (module instanceof Module) {
-            for (const dependency of module.dependencies) {
-                if (parents.has(dependency)) {
-                    if (!analysedModules.has(dependency)) {
-                        cyclePaths.push(getCyclePath(dependency, module, parents));
-                    }
-                    continue;
-                }
-                parents.set(dependency, module);
-                analyseModule(dependency);
-            }
-            for (const dependency of module.implicitlyLoadedBefore) {
-                dynamicImports.add(dependency);
-            }
-            for (const { resolution } of module.dynamicImports) {
-                if (resolution instanceof Module) {
-                    dynamicImports.add(resolution);
-                }
-            }
-            orderedModules.push(module);
-        }
-        module.execIndex = nextExecIndex++;
-        analysedModules.add(module);
-    };
-    for (const curEntry of entryModules) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
-        }
-    }
-    for (const curEntry of dynamicImports) {
-        if (!parents.has(curEntry)) {
-            parents.set(curEntry, null);
-            analyseModule(curEntry);
-        }
-    }
-    return { orderedModules, cyclePaths };
-}
-function getCyclePath(module, parent, parents) {
-    const path = [relativeId(module.id)];
-    let nextModule = parent;
-    while (nextModule !== module) {
-        path.push(relativeId(nextModule.id));
-        nextModule = parents.get(nextModule);
-    }
-    path.push(path[0]);
-    path.reverse();
-    return path;
-}
-
 function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
     let nameIndex = 0;
     for (const variable of exports) {
@@ -10884,6 +10956,44 @@ function getIndentString(modules, options) {
     return '\t';
 }
 
+function getStaticDependencies(chunk, orderedModules, chunkByModule) {
+    const staticDependencyBlocks = [];
+    const handledDependencies = new Set();
+    for (let modulePos = orderedModules.length - 1; modulePos >= 0; modulePos--) {
+        const module = orderedModules[modulePos];
+        if (!handledDependencies.has(module)) {
+            const staticDependencies = [];
+            addStaticDependencies(module, staticDependencies, handledDependencies, chunk, chunkByModule);
+            staticDependencyBlocks.unshift(staticDependencies);
+        }
+    }
+    const dependencies = new Set();
+    for (const block of staticDependencyBlocks) {
+        for (const dependency of block) {
+            dependencies.add(dependency);
+        }
+    }
+    return dependencies;
+}
+function addStaticDependencies(module, staticDependencies, handledModules, chunk, chunkByModule) {
+    const dependencies = module.getDependenciesToBeIncluded();
+    for (const dependency of dependencies) {
+        if (dependency instanceof ExternalModule) {
+            staticDependencies.push(dependency);
+            continue;
+        }
+        const dependencyChunk = chunkByModule.get(dependency);
+        if (dependencyChunk !== chunk) {
+            staticDependencies.push(dependencyChunk);
+            continue;
+        }
+        if (!handledModules.has(dependency)) {
+            handledModules.add(dependency);
+            addStaticDependencies(dependency, staticDependencies, handledModules, chunk, chunkByModule);
+        }
+    }
+}
+
 function decodedSourcemap(map) {
     if (!map)
         return null;
@@ -11139,7 +11249,6 @@ class Chunk$1 {
                     this.facadeChunkByModule.set(module, this);
                     if (module.preserveSignature) {
                         this.strictFacade = needsStrictFacade;
-                        this.ensureReexportsAreAvailableForModule(module);
                     }
                     this.assignFacadeName(requiredFacades.shift(), module);
                 }
@@ -11277,8 +11386,8 @@ class Chunk$1 {
         return this.exportNamesByVariable.get(variable)[0];
     }
     link() {
+        this.dependencies = getStaticDependencies(this, this.orderedModules, this.chunkByModule);
         for (const module of this.orderedModules) {
-            this.addDependenciesToChunk(module.getDependenciesToBeIncluded(), this.dependencies);
             this.addDependenciesToChunk(module.dynamicDependencies, this.dynamicDependencies);
             this.addDependenciesToChunk(module.implicitlyLoadedBefore, this.implicitlyLoadedBefore);
             this.setUpChunkImportsAndExportsForModule(module);
@@ -11311,9 +11420,6 @@ class Chunk$1 {
                     this.inlineChunkDependencies(dep);
             }
         }
-        const sortedDependencies = [...this.dependencies];
-        sortByExecutionOrder(sortedDependencies);
-        this.dependencies = new Set(sortedDependencies);
         this.prepareDynamicImportsAndImportMetas();
         this.setIdentifierRenderResolutions(options);
         let hoistedSource = '';
@@ -11505,6 +11611,23 @@ class Chunk$1 {
             this.name = sanitizeFileName(name || facadedModule.chunkName || getAliasName(facadedModule.id));
         }
     }
+    checkCircularDependencyImport(variable, importingModule) {
+        const variableModule = variable.module;
+        if (variableModule instanceof Module) {
+            const exportChunk = this.chunkByModule.get(variableModule);
+            let alternativeReexportModule;
+            do {
+                alternativeReexportModule = importingModule.alternativeReexportModules.get(variable);
+                if (alternativeReexportModule) {
+                    const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
+                    if (exportingChunk && exportingChunk !== exportChunk) {
+                        this.inputOptions.onwarn(errCyclicCrossChunkReexport(variableModule.getExportNamesByVariable().get(variable)[0], variableModule.id, alternativeReexportModule.id, importingModule.id));
+                    }
+                    importingModule = alternativeReexportModule;
+                }
+            } while (alternativeReexportModule);
+        }
+    }
     computeContentHashWithDependencies(addons, options, existingNames) {
         const hash = createHash();
         hash.update([addons.intro, addons.outro, addons.banner, addons.footer].map(addon => addon || '').join(':'));
@@ -11534,6 +11657,7 @@ class Chunk$1 {
                 ? exportedVariable.getBaseVariable()
                 : exportedVariable;
             if (!(importedVariable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+                this.checkCircularDependencyImport(importedVariable, module);
                 const exportingModule = importedVariable.module;
                 if (exportingModule instanceof Module) {
                     const chunk = this.chunkByModule.get(exportingModule);
@@ -11929,6 +12053,7 @@ class Chunk$1 {
                 if (!(variable instanceof NamespaceVariable && this.outputOptions.preserveModules) &&
                     variable.module instanceof Module) {
                     chunk.exports.add(variable);
+                    this.checkCircularDependencyImport(variable, module);
                 }
             }
         }
@@ -12132,6 +12257,71 @@ function commondir(files) {
     return commonSegments.length > 1 ? commonSegments.join('/') : '/';
 }
 
+const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
+function sortByExecutionOrder(units) {
+    units.sort(compareExecIndex);
+}
+function analyseModuleExecution(entryModules) {
+    let nextExecIndex = 0;
+    const cyclePaths = [];
+    const analysedModules = new Set();
+    const dynamicImports = new Set();
+    const parents = new Map();
+    const orderedModules = [];
+    const analyseModule = (module) => {
+        if (module instanceof Module) {
+            for (const dependency of module.dependencies) {
+                if (parents.has(dependency)) {
+                    if (!analysedModules.has(dependency)) {
+                        cyclePaths.push(getCyclePath(dependency, module, parents));
+                    }
+                    continue;
+                }
+                parents.set(dependency, module);
+                analyseModule(dependency);
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                dynamicImports.add(dependency);
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module) {
+                    dynamicImports.add(resolution);
+                }
+            }
+            orderedModules.push(module);
+        }
+        module.execIndex = nextExecIndex++;
+        analysedModules.add(module);
+    };
+    for (const curEntry of entryModules) {
+        if (!parents.has(curEntry)) {
+            parents.set(curEntry, null);
+            analyseModule(curEntry);
+        }
+    }
+    for (const curEntry of dynamicImports) {
+        if (!parents.has(curEntry)) {
+            parents.set(curEntry, null);
+            analyseModule(curEntry);
+        }
+    }
+    return { orderedModules, cyclePaths };
+}
+function getCyclePath(module, parent, parents) {
+    const cycleSymbol = Symbol(module.id);
+    const path = [relativeId(module.id)];
+    let nextModule = parent;
+    module.cycles.add(cycleSymbol);
+    while (nextModule !== module) {
+        nextModule.cycles.add(cycleSymbol);
+        path.push(relativeId(nextModule.id));
+        nextModule = parents.get(nextModule);
+    }
+    path.push(path[0]);
+    path.reverse();
+    return path;
+}
+
 var BuildPhase;
 (function (BuildPhase) {
     BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
@@ -19258,160 +19448,6 @@ var acornClassFields = function(Parser) {
   }
 };
 
-function withoutAcornBigInt(acorn, Parser) {
-  return class extends Parser {
-    readInt(radix, len) {
-      // Hack: len is only != null for unicode escape sequences,
-      // where numeric separators are not allowed
-      if (len != null) return super.readInt(radix, len)
-
-      let start = this.pos, total = 0, acceptUnderscore = false;
-      for (;;) {
-        let code = this.input.charCodeAt(this.pos), val;
-        if (code >= 97) val = code - 97 + 10; // a
-        else if (code == 95) {
-          if (!acceptUnderscore) this.raise(this.pos, "Invalid numeric separator");
-          ++this.pos;
-          acceptUnderscore = false;
-          continue
-        } else if (code >= 65) val = code - 65 + 10; // A
-        else if (code >= 48 && code <= 57) val = code - 48; // 0-9
-        else val = Infinity;
-        if (val >= radix) break
-        ++this.pos;
-        total = total * radix + val;
-        acceptUnderscore = true;
-      }
-      if (this.pos === start) return null
-      if (!acceptUnderscore) this.raise(this.pos - 1, "Invalid numeric separator");
-
-      return total
-    }
-
-    readNumber(startsWithDot) {
-      const token = super.readNumber(startsWithDot);
-      let octal = this.end - this.start >= 2 && this.input.charCodeAt(this.start) === 48;
-      const stripped = this.getNumberInput(this.start, this.end);
-      if (stripped.length < this.end - this.start) {
-        if (octal) this.raise(this.start, "Invalid number");
-        this.value = parseFloat(stripped);
-      }
-      return token
-    }
-
-    // This is used by acorn-bigint
-    getNumberInput(start, end) {
-      return this.input.slice(start, end).replace(/_/g, "")
-    }
-  }
-}
-
-function withAcornBigInt(acorn, Parser) {
-  return class extends Parser {
-    readInt(radix, len) {
-      // Hack: len is only != null for unicode escape sequences,
-      // where numeric separators are not allowed
-      if (len != null) return super.readInt(radix, len)
-
-      let start = this.pos, total = 0, acceptUnderscore = false;
-      for (;;) {
-        let code = this.input.charCodeAt(this.pos), val;
-        if (code >= 97) val = code - 97 + 10; // a
-        else if (code == 95) {
-          if (!acceptUnderscore) this.raise(this.pos, "Invalid numeric separator");
-          ++this.pos;
-          acceptUnderscore = false;
-          continue
-        } else if (code >= 65) val = code - 65 + 10; // A
-        else if (code >= 48 && code <= 57) val = code - 48; // 0-9
-        else val = Infinity;
-        if (val >= radix) break
-        ++this.pos;
-        total = total * radix + val;
-        acceptUnderscore = true;
-      }
-      if (this.pos === start) return null
-      if (!acceptUnderscore) this.raise(this.pos - 1, "Invalid numeric separator");
-
-      return total
-    }
-
-    readNumber(startsWithDot) {
-      let start = this.pos;
-      if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
-      let octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
-      let octalLike = false;
-      if (octal && this.strict) this.raise(start, "Invalid number");
-      let next = this.input.charCodeAt(this.pos);
-      if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
-        let str = this.getNumberInput(start, this.pos);
-        // eslint-disable-next-line node/no-unsupported-features/es-builtins
-        let val = typeof BigInt !== "undefined" ? BigInt(str) : null;
-        ++this.pos;
-        if (acorn.isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-        return this.finishToken(acorn.tokTypes.num, val)
-      }
-      if (octal && /[89]/.test(this.input.slice(start, this.pos))) {
-        octal = false;
-        octalLike = true;
-      }
-      if (next === 46 && !octal) { // '.'
-        ++this.pos;
-        this.readInt(10);
-        next = this.input.charCodeAt(this.pos);
-      }
-      if ((next === 69 || next === 101) && !octal) { // 'eE'
-        next = this.input.charCodeAt(++this.pos);
-        if (next === 43 || next === 45) ++this.pos; // '+-'
-        if (this.readInt(10) === null) this.raise(start, "Invalid number");
-      }
-      if (acorn.isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
-      let str = this.getNumberInput(start, this.pos);
-      if ((octal || octalLike) && str.length < this.pos - start) {
-        this.raise(start, "Invalid number");
-      }
-
-      let val = octal ? parseInt(str, 8) : parseFloat(str);
-      return this.finishToken(acorn.tokTypes.num, val)
-    }
-
-    parseLiteral(value) {
-      const ret = super.parseLiteral(value);
-      if (ret.bigint) ret.bigint = ret.bigint.replace(/_/g, "");
-      return ret
-    }
-
-    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.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
-        let str = this.getNumberInput(start, this.pos);
-        // eslint-disable-next-line node/no-unsupported-features/es-builtins
-        val = typeof BigInt !== "undefined" ? BigInt(str) : null;
-        ++this.pos;
-      } else if (acorn.isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
-      return this.finishToken(acorn.tokTypes.num, val)
-    }
-
-    // This is used by acorn-bigint, which theoretically could be used with acorn@6.2 || acorn@7
-    getNumberInput(start, end) {
-      return this.input.slice(start, end).replace(/_/g, "")
-    }
-  }
-}
-
-// eslint-disable-next-line node/no-unsupported-features/es-syntax
-function numericSeparator(Parser) {
-  const acorn = Parser.acorn || require$$0;
-  const withAcornBigIntSupport = (acorn.version.startsWith("6.") && !(acorn.version.startsWith("6.0.") || acorn.version.startsWith("6.1."))) || acorn.version.startsWith("7.");
-
-  return withAcornBigIntSupport ? withAcornBigInt(acorn, Parser) : withoutAcornBigInt(acorn, Parser)
-}
-
-var acornNumericSeparator = numericSeparator;
-
 var acornStaticClassFeatures = function(Parser) {
   const ExtendedParser = acornPrivateClassElements(Parser);
 
@@ -19552,7 +19588,6 @@ const getAcorn$1 = (config) => ({
 const getAcornInjectPlugins = (config) => [
     acornClassFields,
     acornStaticClassFeatures,
-    acornNumericSeparator,
     ...ensureArray(config.acornInjectPlugins)
 ];
 const getCache = (config) => {