rollup 2.58.3 → 2.60.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.58.3
-	Mon, 25 Oct 2021 13:49:07 GMT - commit 0b8d4c668683c7702f20fcf480db077dbe2be774
+	Rollup.js v2.60.0
+	Fri, 12 Nov 2021 05:12:41 GMT - commit 8d98341bf746d4baa57bbd730b1fa6449555cfca
 
 
 	https://github.com/rollup/rollup
@@ -13,7 +13,7 @@ import { createHash as createHash$1 } from 'crypto';
 import fs, { lstatSync, realpathSync, readdirSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.58.3";
+var version$1 = "2.60.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -4592,13 +4592,11 @@ class NodeBase extends ExpressionEntity {
                 for (const child of value) {
                     this[key].push(child === null
                         ? null
-                        : new (this.context.nodeConstructors[child.type] ||
-                            this.context.nodeConstructors.UnknownNode)(child, this, this.scope));
+                        : new (this.context.getNodeConstructor(child.type))(child, this, this.scope));
                 }
             }
             else {
-                this[key] = new (this.context.nodeConstructors[value.type] ||
-                    this.context.nodeConstructors.UnknownNode)(value, this, this.scope);
+                this[key] = new (this.context.getNodeConstructor(value.type))(value, this, this.scope);
             }
         }
     }
@@ -4836,576 +4834,83 @@ function renderSystemExportSequenceBeforeExpression(exportedVariable, expression
     }
 }
 
-const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
-const base = 64;
-function toBase64(num) {
-    let outStr = '';
-    do {
-        const curDigit = num % base;
-        num = Math.floor(num / base);
-        outStr = chars[curDigit] + outStr;
-    } while (num !== 0);
-    return outStr;
-}
+//@ts-check
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
 
-const RESERVED_NAMES = {
-    __proto__: null,
-    await: true,
-    break: true,
-    case: true,
-    catch: true,
-    class: true,
-    const: true,
-    continue: true,
-    debugger: true,
-    default: true,
-    delete: true,
-    do: true,
-    else: true,
-    enum: true,
-    eval: true,
-    export: true,
-    extends: true,
-    false: true,
-    finally: true,
-    for: true,
-    function: true,
-    if: true,
-    implements: true,
-    import: true,
-    in: true,
-    instanceof: true,
-    interface: true,
-    let: true,
-    new: true,
-    null: true,
-    package: true,
-    private: true,
-    protected: true,
-    public: true,
-    return: true,
-    static: true,
-    super: true,
-    switch: true,
-    this: true,
-    throw: true,
-    true: true,
-    try: true,
-    typeof: true,
-    undefined: true,
-    var: true,
-    void: true,
-    while: true,
-    with: true,
-    yield: true
-};
+/**
+ *
+ * @param {NodeWithPropertyDefinition} node
+ * @param {NodeWithPropertyDefinition} parent
+ * @returns boolean
+ */
+function is_reference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
 
-function getSafeName(baseName, usedNames) {
-    let safeName = baseName;
-    let count = 1;
-    while (usedNames.has(safeName) || RESERVED_NAMES[safeName]) {
-        safeName = `${baseName}$${toBase64(count++)}`;
-    }
-    usedNames.add(safeName);
-    return safeName;
-}
+	if (node.type === 'Identifier') {
+		if (!parent) return true;
 
-const NO_ARGS = [];
+		switch (parent.type) {
+			// disregard `bar` in `foo.bar`
+			case 'MemberExpression': return parent.computed || node === parent.object;
 
-function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
-    return Object.create(inheritedDescriptions, memberDescriptions);
+			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+			case 'MethodDefinition': return parent.computed;
+
+			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+			case 'PropertyDefinition': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+			case 'Property': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `export { foo as bar }` or
+			// the foo in `import { foo as bar }`
+			case 'ExportSpecifier':
+			case 'ImportSpecifier': return node === parent.local;
+
+			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+			case 'LabeledStatement':
+			case 'BreakStatement':
+			case 'ContinueStatement': return false;
+			default: return true;
+		}
+	}
+
+	return false;
 }
-const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
-    getLiteralValueAtPath() {
-        return undefined;
-    }
-})();
-const returnsUnknown = {
-    value: {
-        callsArgs: null,
-        returns: UNKNOWN_EXPRESSION
-    }
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const PURE = { pure: true };
+const IMPURE = { pure: false };
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
 };
-const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
-        }
-        return UNKNOWN_EXPRESSION;
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], callOptions, context);
-        }
-        return true;
-    }
-})();
-const returnsBoolean = {
-    value: {
-        callsArgs: null,
-        returns: UNKNOWN_LITERAL_BOOLEAN
-    }
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
 };
-const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
-        }
-        return UNKNOWN_EXPRESSION;
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], callOptions, context);
-        }
-        return true;
-    }
-})();
-const returnsNumber = {
-    value: {
-        callsArgs: null,
-        returns: UNKNOWN_LITERAL_NUMBER
-    }
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
 };
-const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length === 1) {
-            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
-        }
-        return UNKNOWN_EXPRESSION;
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalStringMembers, path[0], callOptions, context);
-        }
-        return true;
-    }
-})();
-const returnsString = {
-    value: {
-        callsArgs: null,
-        returns: UNKNOWN_LITERAL_STRING
-    }
-};
-const objectMembers = assembleMemberDescriptions({
-    hasOwnProperty: returnsBoolean,
-    isPrototypeOf: returnsBoolean,
-    propertyIsEnumerable: returnsBoolean,
-    toLocaleString: returnsString,
-    toString: returnsString,
-    valueOf: returnsUnknown
-});
-const literalBooleanMembers = assembleMemberDescriptions({
-    valueOf: returnsBoolean
-}, objectMembers);
-const literalNumberMembers = assembleMemberDescriptions({
-    toExponential: returnsString,
-    toFixed: returnsString,
-    toLocaleString: returnsString,
-    toPrecision: returnsString,
-    valueOf: returnsNumber
-}, objectMembers);
-const literalStringMembers = assembleMemberDescriptions({
-    charAt: returnsString,
-    charCodeAt: returnsNumber,
-    codePointAt: returnsNumber,
-    concat: returnsString,
-    endsWith: returnsBoolean,
-    includes: returnsBoolean,
-    indexOf: returnsNumber,
-    lastIndexOf: returnsNumber,
-    localeCompare: returnsNumber,
-    match: returnsBoolean,
-    normalize: returnsString,
-    padEnd: returnsString,
-    padStart: returnsString,
-    repeat: returnsString,
-    replace: {
-        value: {
-            callsArgs: [1],
-            returns: UNKNOWN_LITERAL_STRING
-        }
-    },
-    search: returnsNumber,
-    slice: returnsString,
-    split: returnsUnknown,
-    startsWith: returnsBoolean,
-    substr: returnsString,
-    substring: returnsString,
-    toLocaleLowerCase: returnsString,
-    toLocaleUpperCase: returnsString,
-    toLowerCase: returnsString,
-    toUpperCase: returnsString,
-    trim: returnsString,
-    valueOf: returnsString
-}, objectMembers);
-function getLiteralMembersForValue(value) {
-    switch (typeof value) {
-        case 'boolean':
-            return literalBooleanMembers;
-        case 'number':
-            return literalNumberMembers;
-        case 'string':
-            return literalStringMembers;
-        default:
-            return Object.create(null);
-    }
-}
-function hasMemberEffectWhenCalled(members, memberName, callOptions, context) {
-    if (typeof memberName !== 'string' || !members[memberName]) {
-        return true;
-    }
-    if (!members[memberName].callsArgs)
-        return false;
-    for (const argIndex of members[memberName].callsArgs) {
-        if (callOptions.args[argIndex] &&
-            callOptions.args[argIndex].hasEffectsWhenCalledAtPath(EMPTY_PATH, {
-                args: NO_ARGS,
-                thisParam: null,
-                withNew: false
-            }, context))
-            return true;
-    }
-    return false;
-}
-function getMemberReturnExpressionWhenCalled(members, memberName) {
-    if (typeof memberName !== 'string' || !members[memberName])
-        return UNKNOWN_EXPRESSION;
-    return members[memberName].returns;
-}
-
-class LocalVariable extends Variable {
-    constructor(name, declarator, init, context) {
-        super(name);
-        this.calledFromTryStatement = false;
-        this.additionalInitializers = null;
-        this.expressionsToBeDeoptimized = [];
-        this.declarations = declarator ? [declarator] : [];
-        this.init = init;
-        this.deoptimizationTracker = context.deoptimizationTracker;
-        this.module = context.module;
-    }
-    addDeclaration(identifier, init) {
-        this.declarations.push(identifier);
-        const additionalInitializers = this.markInitializersForDeoptimization();
-        if (init !== null) {
-            additionalInitializers.push(init);
-        }
-    }
-    consolidateInitializers() {
-        if (this.additionalInitializers !== null) {
-            for (const initializer of this.additionalInitializers) {
-                initializer.deoptimizePath(UNKNOWN_PATH);
-            }
-            this.additionalInitializers = null;
-        }
-    }
-    deoptimizePath(path) {
-        var _a, _b;
-        if (this.isReassigned ||
-            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
-            return;
-        }
-        if (path.length === 0) {
-            if (!this.isReassigned) {
-                this.isReassigned = true;
-                const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
-                this.expressionsToBeDeoptimized = [];
-                for (const expression of expressionsToBeDeoptimized) {
-                    expression.deoptimizeCache();
-                }
-                (_a = this.init) === null || _a === void 0 ? void 0 : _a.deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-        else {
-            (_b = this.init) === null || _b === void 0 ? void 0 : _b.deoptimizePath(path);
-        }
-    }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        if (this.isReassigned || !this.init) {
-            return thisParameter.deoptimizePath(UNKNOWN_PATH);
-        }
-        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker), undefined);
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned || !this.init) {
-            return UnknownValue;
-        }
-        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
-        }, UnknownValue);
-    }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        if (this.isReassigned || !this.init) {
-            return UNKNOWN_EXPRESSION;
-        }
-        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
-        }, UNKNOWN_EXPRESSION);
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.init.hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (this.included)
-            return true;
-        if (path.length === 0)
-            return false;
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.init.hasEffectsWhenAssignedAtPath(path, context));
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
-            this.init.hasEffectsWhenCalledAtPath(path, callOptions, context));
-    }
-    include() {
-        if (!this.included) {
-            this.included = true;
-            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)
-                    declaration.include(createInclusionContext(), false);
-                let node = declaration.parent;
-                while (!node.included) {
-                    // We do not want to properly include parents in case they are part of a dead branch
-                    // in which case .include() might pull in more dead code
-                    node.included = true;
-                    if (node.type === Program$1)
-                        break;
-                    node = node.parent;
-                }
-            }
-        }
-    }
-    includeCallArguments(context, args) {
-        if (this.isReassigned || (this.init && context.includedCallArguments.has(this.init))) {
-            for (const arg of args) {
-                arg.include(context, false);
-            }
-        }
-        else if (this.init) {
-            context.includedCallArguments.add(this.init);
-            this.init.includeCallArguments(context, args);
-            context.includedCallArguments.delete(this.init);
-        }
-    }
-    markCalledFromTryStatement() {
-        this.calledFromTryStatement = true;
-    }
-    markInitializersForDeoptimization() {
-        if (this.additionalInitializers === null) {
-            this.additionalInitializers = this.init === null ? [] : [this.init];
-            this.init = UNKNOWN_EXPRESSION;
-            this.isReassigned = true;
-        }
-        return this.additionalInitializers;
-    }
-}
-
-class Scope$1 {
-    constructor() {
-        this.children = [];
-        this.variables = new Map();
-    }
-    addDeclaration(identifier, context, init, _isHoisted) {
-        const name = identifier.name;
-        let variable = this.variables.get(name);
-        if (variable) {
-            variable.addDeclaration(identifier, init);
-        }
-        else {
-            variable = new LocalVariable(identifier.name, identifier, init || UNDEFINED_EXPRESSION, context);
-            this.variables.set(name, variable);
-        }
-        return variable;
-    }
-    contains(name) {
-        return this.variables.has(name);
-    }
-    findVariable(_name) {
-        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
-    }
-}
-
-class ChildScope extends Scope$1 {
-    constructor(parent) {
-        super();
-        this.accessedOutsideVariables = new Map();
-        this.parent = parent;
-        parent.children.push(this);
-    }
-    addAccessedDynamicImport(importExpression) {
-        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
-        if (this.parent instanceof ChildScope) {
-            this.parent.addAccessedDynamicImport(importExpression);
-        }
-    }
-    addAccessedGlobals(globals, accessedGlobalsByScope) {
-        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
-        for (const name of globals) {
-            accessedGlobals.add(name);
-        }
-        accessedGlobalsByScope.set(this, accessedGlobals);
-        if (this.parent instanceof ChildScope) {
-            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
-        }
-    }
-    addNamespaceMemberAccess(name, variable) {
-        this.accessedOutsideVariables.set(name, variable);
-        this.parent.addNamespaceMemberAccess(name, variable);
-    }
-    addReturnExpression(expression) {
-        this.parent instanceof ChildScope && this.parent.addReturnExpression(expression);
-    }
-    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
-        for (const variable of this.accessedOutsideVariables.values()) {
-            if (variable.included) {
-                usedNames.add(variable.getBaseVariableName());
-                if (format === 'system' && exportNamesByVariable.has(variable)) {
-                    usedNames.add('exports');
-                }
-            }
-        }
-        const accessedGlobals = accessedGlobalsByScope.get(this);
-        if (accessedGlobals) {
-            for (const name of accessedGlobals) {
-                usedNames.add(name);
-            }
-        }
-    }
-    contains(name) {
-        return this.variables.has(name) || this.parent.contains(name);
-    }
-    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
-        const usedNames = new Set();
-        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
-        if (this.accessedDynamicImports) {
-            for (const importExpression of this.accessedDynamicImports) {
-                if (importExpression.inlineNamespace) {
-                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
-                }
-            }
-        }
-        for (const [name, variable] of this.variables) {
-            if (variable.included || variable.alwaysRendered) {
-                variable.setRenderNames(null, getSafeName(name, usedNames));
-            }
-        }
-        for (const scope of this.children) {
-            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
-        }
-    }
-    findLexicalBoundary() {
-        return this.parent.findLexicalBoundary();
-    }
-    findVariable(name) {
-        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
-        if (knownVariable) {
-            return knownVariable;
-        }
-        const variable = this.parent.findVariable(name);
-        this.accessedOutsideVariables.set(name, variable);
-        return variable;
-    }
-}
-
-//@ts-check
-/** @typedef { import('estree').Node} Node */
-/** @typedef {Node | {
- *   type: 'PropertyDefinition';
- *   computed: boolean;
- *   value: Node
- * }} NodeWithPropertyDefinition */
-
-/**
- *
- * @param {NodeWithPropertyDefinition} node
- * @param {NodeWithPropertyDefinition} parent
- * @returns boolean
- */
-function is_reference (node, parent) {
-	if (node.type === 'MemberExpression') {
-		return !node.computed && is_reference(node.object, node);
-	}
-
-	if (node.type === 'Identifier') {
-		if (!parent) return true;
-
-		switch (parent.type) {
-			// disregard `bar` in `foo.bar`
-			case 'MemberExpression': return parent.computed || node === parent.object;
-
-			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
-			case 'MethodDefinition': return parent.computed;
-
-			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
-			case 'PropertyDefinition': return parent.computed || node === parent.value;
-
-			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-			case 'Property': return parent.computed || node === parent.value;
-
-			// disregard the `bar` in `export { foo as bar }` or
-			// the foo in `import { foo as bar }`
-			case 'ExportSpecifier':
-			case 'ImportSpecifier': return node === parent.local;
-
-			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
-			case 'LabeledStatement':
-			case 'BreakStatement':
-			case 'ContinueStatement': return false;
-			default: return true;
-		}
-	}
-
-	return false;
-}
-
-/* eslint sort-keys: "off" */
-const ValueProperties = Symbol('Value Properties');
-const PURE = { pure: true };
-const IMPURE = { pure: false };
-// We use shortened variables to reduce file size here
-/* OBJECT */
-const O = {
-    __proto__: null,
-    [ValueProperties]: IMPURE
-};
-/* PURE FUNCTION */
-const PF = {
-    __proto__: null,
-    [ValueProperties]: PURE
-};
-/* CONSTRUCTOR */
-const C = {
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    prototype: O
-};
-/* PURE CONSTRUCTOR */
-const PC = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    prototype: O
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
 };
 const ARRAY_TYPE = {
     __proto__: null,
@@ -6202,226 +5707,719 @@ const knownGlobals = {
 for (const global of ['window', 'global', 'self', 'globalThis']) {
     knownGlobals[global] = knownGlobals;
 }
-function getGlobalAtPath(path) {
-    let currentGlobal = knownGlobals;
-    for (const pathSegment of path) {
-        if (typeof pathSegment !== 'string') {
-            return null;
+function getGlobalAtPath(path) {
+    let currentGlobal = knownGlobals;
+    for (const pathSegment of path) {
+        if (typeof pathSegment !== 'string') {
+            return null;
+        }
+        currentGlobal = currentGlobal[pathSegment];
+        if (!currentGlobal) {
+            return null;
+        }
+    }
+    return currentGlobal[ValueProperties];
+}
+function isPureGlobal(path) {
+    const globalAtPath = getGlobalAtPath(path);
+    return globalAtPath !== null && globalAtPath.pure;
+}
+function isGlobalMember(path) {
+    if (path.length === 1) {
+        return path[0] === 'undefined' || getGlobalAtPath(path) !== null;
+    }
+    return getGlobalAtPath(path.slice(0, -1)) !== null;
+}
+
+class GlobalVariable extends Variable {
+    constructor() {
+        super(...arguments);
+        this.isReassigned = true;
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        return !isGlobalMember([this.name, ...path]);
+    }
+    hasEffectsWhenCalledAtPath(path) {
+        return !isPureGlobal([this.name, ...path]);
+    }
+}
+
+class LocalVariable extends Variable {
+    constructor(name, declarator, init, context) {
+        super(name);
+        this.calledFromTryStatement = false;
+        this.additionalInitializers = null;
+        this.expressionsToBeDeoptimized = [];
+        this.declarations = declarator ? [declarator] : [];
+        this.init = init;
+        this.deoptimizationTracker = context.deoptimizationTracker;
+        this.module = context.module;
+    }
+    addDeclaration(identifier, init) {
+        this.declarations.push(identifier);
+        const additionalInitializers = this.markInitializersForDeoptimization();
+        if (init !== null) {
+            additionalInitializers.push(init);
+        }
+    }
+    consolidateInitializers() {
+        if (this.additionalInitializers !== null) {
+            for (const initializer of this.additionalInitializers) {
+                initializer.deoptimizePath(UNKNOWN_PATH);
+            }
+            this.additionalInitializers = null;
+        }
+    }
+    deoptimizePath(path) {
+        var _a, _b;
+        if (this.isReassigned ||
+            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        if (path.length === 0) {
+            if (!this.isReassigned) {
+                this.isReassigned = true;
+                const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+                this.expressionsToBeDeoptimized = [];
+                for (const expression of expressionsToBeDeoptimized) {
+                    expression.deoptimizeCache();
+                }
+                (_a = this.init) === null || _a === void 0 ? void 0 : _a.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        else {
+            (_b = this.init) === null || _b === void 0 ? void 0 : _b.deoptimizePath(path);
+        }
+    }
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        if (this.isReassigned || !this.init) {
+            return thisParameter.deoptimizePath(UNKNOWN_PATH);
+        }
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker), undefined);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned || !this.init) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+        if (this.isReassigned || !this.init) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+        }, UNKNOWN_EXPRESSION);
+    }
+    hasEffectsWhenAccessedAtPath(path, context) {
+        if (this.isReassigned)
+            return true;
+        return (this.init &&
+            !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+            this.init.hasEffectsWhenAccessedAtPath(path, context));
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        if (this.included)
+            return true;
+        if (path.length === 0)
+            return false;
+        if (this.isReassigned)
+            return true;
+        return (this.init &&
+            !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+            this.init.hasEffectsWhenAssignedAtPath(path, context));
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (this.isReassigned)
+            return true;
+        return (this.init &&
+            !(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
+            this.init.hasEffectsWhenCalledAtPath(path, callOptions, context));
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            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)
+                    declaration.include(createInclusionContext(), false);
+                let node = declaration.parent;
+                while (!node.included) {
+                    // We do not want to properly include parents in case they are part of a dead branch
+                    // in which case .include() might pull in more dead code
+                    node.included = true;
+                    if (node.type === Program$1)
+                        break;
+                    node = node.parent;
+                }
+            }
+        }
+    }
+    includeCallArguments(context, args) {
+        if (this.isReassigned || (this.init && context.includedCallArguments.has(this.init))) {
+            for (const arg of args) {
+                arg.include(context, false);
+            }
+        }
+        else if (this.init) {
+            context.includedCallArguments.add(this.init);
+            this.init.includeCallArguments(context, args);
+            context.includedCallArguments.delete(this.init);
+        }
+    }
+    markCalledFromTryStatement() {
+        this.calledFromTryStatement = true;
+    }
+    markInitializersForDeoptimization() {
+        if (this.additionalInitializers === null) {
+            this.additionalInitializers = this.init === null ? [] : [this.init];
+            this.init = UNKNOWN_EXPRESSION;
+            this.isReassigned = true;
+        }
+        return this.additionalInitializers;
+    }
+}
+
+const tdzVariableKinds = {
+    __proto__: null,
+    class: true,
+    const: true,
+    let: true,
+    var: true
+};
+class Identifier extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.deoptimized = false;
+        this.isTDZAccess = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (this.variable !== null && exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (this.variable === null && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+        }
+    }
+    declare(kind, init) {
+        let variable;
+        const { treeshake } = this.context.options;
+        switch (kind) {
+            case 'var':
+                variable = this.scope.addDeclaration(this, this.context, init, true);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
+            case 'function':
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.context, init, false);
+                break;
+            case 'let':
+            case 'const':
+            case 'class':
+                variable = this.scope.addDeclaration(this, this.context, init, false);
+                break;
+            case 'parameter':
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            /* istanbul ignore next */
+            default:
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+        }
+        variable.kind = kind;
+        return [(this.variable = variable)];
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        this.variable.deoptimizePath(path);
+    }
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
+        }
+        return (this.context.options.treeshake.unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
+    }
+    hasEffectsWhenAccessedAtPath(path, context) {
+        return (this.variable !== null &&
+            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return (!this.variable ||
+            (path.length > 0
+                ? this.getVariableRespectingTDZ()
+                : this.variable).hasEffectsWhenAssignedAtPath(path, context));
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        return (!this.variable ||
+            this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context));
+    }
+    include() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
+    includeCallArguments(context, args) {
+        this.getVariableRespectingTDZ().includeCallArguments(context, args);
+    }
+    isPossibleTDZ() {
+        // return cached value to avoid issues with the next tree-shaking pass
+        if (this.isTDZAccess !== null)
+            return this.isTDZAccess;
+        if (!(this.variable instanceof LocalVariable) ||
+            !this.variable.kind ||
+            !(this.variable.kind in tdzVariableKinds)) {
+            return (this.isTDZAccess = false);
+        }
+        let decl_id;
+        if (this.variable.declarations &&
+            this.variable.declarations.length === 1 &&
+            (decl_id = this.variable.declarations[0]) &&
+            this.start < decl_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            // a variable accessed before its declaration
+            // in the same function or at top level of module
+            return (this.isTDZAccess = true);
+        }
+        if (!this.variable.initReached) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
+        }
+        return (this.isTDZAccess = false);
+    }
+    markDeclarationReached() {
+        this.variable.initReached = true;
+    }
+    render(code, { snippets: { getPropertyAccess } }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = BLANK) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, `${this.name}: `);
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === CallExpression$1 &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable !== null && this.variable instanceof LocalVariable) {
+            this.variable.consolidateInitializers();
+            this.context.requestTreeshakingPass();
         }
-        currentGlobal = currentGlobal[pathSegment];
-        if (!currentGlobal) {
-            return null;
+    }
+    disallowImportReassignment() {
+        return this.context.error({
+            code: 'ILLEGAL_REASSIGNMENT',
+            message: `Illegal reassignment to import '${this.name}'`
+        }, this.start);
+    }
+    getVariableRespectingTDZ() {
+        if (this.isPossibleTDZ()) {
+            return UNKNOWN_EXPRESSION;
         }
+        return this.variable;
     }
-    return currentGlobal[ValueProperties];
 }
-function isPureGlobal(path) {
-    const globalAtPath = getGlobalAtPath(path);
-    return globalAtPath !== null && globalAtPath.pure;
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
 }
-function isGlobalMember(path) {
-    if (path.length === 1) {
-        return path[0] === 'undefined' || getGlobalAtPath(path) !== null;
+
+const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const base = 64;
+function toBase64(num) {
+    let outStr = '';
+    do {
+        const curDigit = num % base;
+        num = Math.floor(num / base);
+        outStr = chars[curDigit] + outStr;
+    } while (num !== 0);
+    return outStr;
+}
+
+const RESERVED_NAMES = {
+    __proto__: null,
+    await: true,
+    break: true,
+    case: true,
+    catch: true,
+    class: true,
+    const: true,
+    continue: true,
+    debugger: true,
+    default: true,
+    delete: true,
+    do: true,
+    else: true,
+    enum: true,
+    eval: true,
+    export: true,
+    extends: true,
+    false: true,
+    finally: true,
+    for: true,
+    function: true,
+    if: true,
+    implements: true,
+    import: true,
+    in: true,
+    instanceof: true,
+    interface: true,
+    let: true,
+    new: true,
+    null: true,
+    package: true,
+    private: true,
+    protected: true,
+    public: true,
+    return: true,
+    static: true,
+    super: true,
+    switch: true,
+    this: true,
+    throw: true,
+    true: true,
+    try: true,
+    typeof: true,
+    undefined: true,
+    var: true,
+    void: true,
+    while: true,
+    with: true,
+    yield: true
+};
+
+function getSafeName(baseName, usedNames) {
+    let safeName = baseName;
+    let count = 1;
+    while (usedNames.has(safeName) || RESERVED_NAMES[safeName]) {
+        safeName = `${baseName}$${toBase64(count++)}`;
     }
-    return getGlobalAtPath(path.slice(0, -1)) !== null;
+    usedNames.add(safeName);
+    return safeName;
 }
 
-class GlobalVariable extends Variable {
-    constructor() {
-        super(...arguments);
-        this.isReassigned = true;
+const NO_ARGS = [];
+
+function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
+    return Object.create(inheritedDescriptions, memberDescriptions);
+}
+const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+})();
+const returnsUnknown = {
+    value: {
+        callsArgs: null,
+        returns: UNKNOWN_EXPRESSION
+    }
+};
+const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
+        }
+        return UNKNOWN_EXPRESSION;
     }
     hasEffectsWhenAccessedAtPath(path) {
-        return !isGlobalMember([this.name, ...path]);
+        return path.length > 1;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length === 1) {
+            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], callOptions, context);
+        }
+        return true;
+    }
+})();
+const returnsBoolean = {
+    value: {
+        callsArgs: null,
+        returns: UNKNOWN_LITERAL_BOOLEAN
+    }
+};
+const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
+        }
+        return UNKNOWN_EXPRESSION;
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        return path.length > 1;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length === 1) {
+            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], callOptions, context);
+        }
+        return true;
+    }
+})();
+const returnsNumber = {
+    value: {
+        callsArgs: null,
+        returns: UNKNOWN_LITERAL_NUMBER
+    }
+};
+const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+        }
+        return UNKNOWN_EXPRESSION;
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        return path.length > 1;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], callOptions, context);
+        }
+        return true;
+    }
+})();
+const returnsString = {
+    value: {
+        callsArgs: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const objectMembers = assembleMemberDescriptions({
+    hasOwnProperty: returnsBoolean,
+    isPrototypeOf: returnsBoolean,
+    propertyIsEnumerable: returnsBoolean,
+    toLocaleString: returnsString,
+    toString: returnsString,
+    valueOf: returnsUnknown
+});
+const literalBooleanMembers = assembleMemberDescriptions({
+    valueOf: returnsBoolean
+}, objectMembers);
+const literalNumberMembers = assembleMemberDescriptions({
+    toExponential: returnsString,
+    toFixed: returnsString,
+    toLocaleString: returnsString,
+    toPrecision: returnsString,
+    valueOf: returnsNumber
+}, objectMembers);
+const literalStringMembers = assembleMemberDescriptions({
+    charAt: returnsString,
+    charCodeAt: returnsNumber,
+    codePointAt: returnsNumber,
+    concat: returnsString,
+    endsWith: returnsBoolean,
+    includes: returnsBoolean,
+    indexOf: returnsNumber,
+    lastIndexOf: returnsNumber,
+    localeCompare: returnsNumber,
+    match: returnsBoolean,
+    normalize: returnsString,
+    padEnd: returnsString,
+    padStart: returnsString,
+    repeat: returnsString,
+    replace: {
+        value: {
+            callsArgs: [1],
+            returns: UNKNOWN_LITERAL_STRING
+        }
+    },
+    search: returnsNumber,
+    slice: returnsString,
+    split: returnsUnknown,
+    startsWith: returnsBoolean,
+    substr: returnsString,
+    substring: returnsString,
+    toLocaleLowerCase: returnsString,
+    toLocaleUpperCase: returnsString,
+    toLowerCase: returnsString,
+    toUpperCase: returnsString,
+    trim: returnsString,
+    valueOf: returnsString
+}, objectMembers);
+function getLiteralMembersForValue(value) {
+    switch (typeof value) {
+        case 'boolean':
+            return literalBooleanMembers;
+        case 'number':
+            return literalNumberMembers;
+        case 'string':
+            return literalStringMembers;
+        default:
+            return Object.create(null);
+    }
+}
+function hasMemberEffectWhenCalled(members, memberName, callOptions, context) {
+    if (typeof memberName !== 'string' || !members[memberName]) {
+        return true;
     }
-    hasEffectsWhenCalledAtPath(path) {
-        return !isPureGlobal([this.name, ...path]);
+    if (!members[memberName].callsArgs)
+        return false;
+    for (const argIndex of members[memberName].callsArgs) {
+        if (callOptions.args[argIndex] &&
+            callOptions.args[argIndex].hasEffectsWhenCalledAtPath(EMPTY_PATH, {
+                args: NO_ARGS,
+                thisParam: null,
+                withNew: false
+            }, context))
+            return true;
     }
+    return false;
+}
+function getMemberReturnExpressionWhenCalled(members, memberName) {
+    if (typeof memberName !== 'string' || !members[memberName])
+        return UNKNOWN_EXPRESSION;
+    return members[memberName].returns;
 }
 
-const tdzVariableKinds = {
-    __proto__: null,
-    class: true,
-    const: true,
-    let: true,
-    var: true
-};
-class Identifier extends NodeBase {
+class Scope$1 {
     constructor() {
-        super(...arguments);
-        this.variable = null;
-        this.deoptimized = false;
-        this.isTDZAccess = null;
-    }
-    addExportedVariables(variables, exportNamesByVariable) {
-        if (this.variable !== null && exportNamesByVariable.has(this.variable)) {
-            variables.push(this.variable);
-        }
-    }
-    bind() {
-        if (this.variable === null && is_reference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-        }
+        this.children = [];
+        this.variables = new Map();
     }
-    declare(kind, init) {
-        let variable;
-        const { treeshake } = this.context.options;
-        switch (kind) {
-            case 'var':
-                variable = this.scope.addDeclaration(this, this.context, init, true);
-                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
-                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
-                    variable.markInitializersForDeoptimization();
-                }
-                break;
-            case 'function':
-                // in strict mode, functions are only hoisted within a scope but not across block scopes
-                variable = this.scope.addDeclaration(this, this.context, init, false);
-                break;
-            case 'let':
-            case 'const':
-            case 'class':
-                variable = this.scope.addDeclaration(this, this.context, init, false);
-                break;
-            case 'parameter':
-                variable = this.scope.addParameterDeclaration(this);
-                break;
-            /* istanbul ignore next */
-            default:
-                /* istanbul ignore next */
-                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+    addDeclaration(identifier, context, init, _isHoisted) {
+        const name = identifier.name;
+        let variable = this.variables.get(name);
+        if (variable) {
+            variable.addDeclaration(identifier, init);
         }
-        variable.kind = kind;
-        return [(this.variable = variable)];
-    }
-    deoptimizePath(path) {
-        if (path.length === 0 && !this.scope.contains(this.name)) {
-            this.disallowImportReassignment();
+        else {
+            variable = new LocalVariable(identifier.name, identifier, init || UNDEFINED_EXPRESSION, context);
+            this.variables.set(name, variable);
         }
-        this.variable.deoptimizePath(path);
+        return variable;
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    contains(name) {
+        return this.variables.has(name);
     }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    findVariable(_name) {
+        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+}
+
+class ChildScope extends Scope$1 {
+    constructor(parent) {
+        super();
+        this.accessedOutsideVariables = new Map();
+        this.parent = parent;
+        parent.children.push(this);
     }
-    hasEffects() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
-            return true;
+    addAccessedDynamicImport(importExpression) {
+        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedDynamicImport(importExpression);
         }
-        return (this.context.options.treeshake.unknownGlobalSideEffects &&
-            this.variable instanceof GlobalVariable &&
-            this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (this.variable !== null &&
-            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
+    addAccessedGlobals(globals, accessedGlobalsByScope) {
+        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
+        for (const name of globals) {
+            accessedGlobals.add(name);
+        }
+        accessedGlobalsByScope.set(this, accessedGlobals);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
+        }
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return (!this.variable ||
-            (path.length > 0
-                ? this.getVariableRespectingTDZ()
-                : this.variable).hasEffectsWhenAssignedAtPath(path, context));
+    addNamespaceMemberAccess(name, variable) {
+        this.accessedOutsideVariables.set(name, variable);
+        this.parent.addNamespaceMemberAccess(name, variable);
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return (!this.variable ||
-            this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context));
+    addReturnExpression(expression) {
+        this.parent instanceof ChildScope && this.parent.addReturnExpression(expression);
     }
-    include() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.context.includeVariableInModule(this.variable);
+    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
+        for (const variable of this.accessedOutsideVariables.values()) {
+            if (variable.included) {
+                usedNames.add(variable.getBaseVariableName());
+                if (format === 'system' && exportNamesByVariable.has(variable)) {
+                    usedNames.add('exports');
+                }
             }
         }
-    }
-    includeCallArguments(context, args) {
-        this.getVariableRespectingTDZ().includeCallArguments(context, args);
-    }
-    isPossibleTDZ() {
-        // return cached value to avoid issues with the next tree-shaking pass
-        if (this.isTDZAccess !== null)
-            return this.isTDZAccess;
-        if (!(this.variable instanceof LocalVariable) ||
-            !this.variable.kind ||
-            !(this.variable.kind in tdzVariableKinds)) {
-            return (this.isTDZAccess = false);
-        }
-        let decl_id;
-        if (this.variable.declarations &&
-            this.variable.declarations.length === 1 &&
-            (decl_id = this.variable.declarations[0]) &&
-            this.start < decl_id.start &&
-            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
-            // a variable accessed before its declaration
-            // in the same function or at top level of module
-            return (this.isTDZAccess = true);
-        }
-        if (!this.variable.initReached) {
-            // Either a const/let TDZ violation or
-            // var use before declaration was encountered.
-            return (this.isTDZAccess = true);
+        const accessedGlobals = accessedGlobalsByScope.get(this);
+        if (accessedGlobals) {
+            for (const name of accessedGlobals) {
+                usedNames.add(name);
+            }
         }
-        return (this.isTDZAccess = false);
     }
-    markDeclarationReached() {
-        this.variable.initReached = true;
+    contains(name) {
+        return this.variables.has(name) || this.parent.contains(name);
     }
-    render(code, { snippets: { getPropertyAccess } }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = BLANK) {
-        if (this.variable) {
-            const name = this.variable.getName(getPropertyAccess);
-            if (name !== this.name) {
-                code.overwrite(this.start, this.end, name, {
-                    contentOnly: true,
-                    storeName: true
-                });
-                if (isShorthandProperty) {
-                    code.prependRight(this.start, `${this.name}: `);
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        const usedNames = new Set();
+        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+        if (this.accessedDynamicImports) {
+            for (const importExpression of this.accessedDynamicImports) {
+                if (importExpression.inlineNamespace) {
+                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
                 }
             }
-            // In strict mode, any variable named "eval" must be the actual "eval" function
-            if (name === 'eval' &&
-                renderedParentType === CallExpression$1 &&
-                isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
+        }
+        for (const [name, variable] of this.variables) {
+            if (variable.included || variable.alwaysRendered) {
+                variable.setRenderNames(null, getSafeName(name, usedNames));
             }
         }
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.variable !== null && this.variable instanceof LocalVariable) {
-            this.variable.consolidateInitializers();
-            this.context.requestTreeshakingPass();
+        for (const scope of this.children) {
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
         }
     }
-    disallowImportReassignment() {
-        return this.context.error({
-            code: 'ILLEGAL_REASSIGNMENT',
-            message: `Illegal reassignment to import '${this.name}'`
-        }, this.start);
+    findLexicalBoundary() {
+        return this.parent.findLexicalBoundary();
     }
-    getVariableRespectingTDZ() {
-        if (this.isPossibleTDZ()) {
-            return UNKNOWN_EXPRESSION;
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
         }
-        return this.variable;
-    }
-}
-function closestParentFunctionOrProgram(node) {
-    while (node && !/^Program|Function/.test(node.type)) {
-        node = node.parent;
-    }
-    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
-    return node;
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
 }
 
 const EVENT_ACCESSED = 0;
@@ -7117,7 +7115,7 @@ class ClassDeclaration extends ClassNode {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
-            this.id = new this.context.nodeConstructors.Identifier(esTreeNode.id, this, this.scope.parent);
+            this.id = new Identifier(esTreeNode.id, this, this.scope.parent);
         }
         super.parseNode(esTreeNode);
     }
@@ -7353,6 +7351,101 @@ class FunctionScope extends ReturnValueScope {
     }
 }
 
+class BlockScope extends ChildScope {
+    addDeclaration(identifier, context, init, isHoisted) {
+        if (isHoisted) {
+            const variable = this.parent.addDeclaration(identifier, context, init, isHoisted);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            variable.markInitializersForDeoptimization();
+            return variable;
+        }
+        else {
+            return super.addDeclaration(identifier, context, init, false);
+        }
+    }
+}
+
+class ExpressionStatement extends NodeBase {
+    initialise() {
+        if (this.directive &&
+            this.directive !== 'use strict' &&
+            this.parent.type === Program$1) {
+            this.context.warn(
+            // This is necessary, because either way (deleting or not) can lead to errors.
+            {
+                code: 'MODULE_LEVEL_DIRECTIVE',
+                message: `Module level directives cause errors when bundled, '${this.directive}' was ignored.`
+            }, this.start);
+        }
+    }
+    render(code, options) {
+        super.render(code, options);
+        if (this.included)
+            this.insertSemicolon(code);
+    }
+    shouldBeIncluded(context) {
+        if (this.directive && this.directive !== 'use strict')
+            return this.parent.type !== Program$1;
+        return super.shouldBeIncluded(context);
+    }
+}
+
+class BlockStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.directlyIncluded = false;
+    }
+    addImplicitReturnExpressionToScope() {
+        const lastStatement = this.body[this.body.length - 1];
+        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
+            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
+        }
+    }
+    createScope(parentScope) {
+        this.scope = this.parent.preventChildBlockScope
+            ? parentScope
+            : new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.deoptimizeBody)
+            return true;
+        for (const node of this.body) {
+            if (context.brokenFlow)
+                break;
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!(this.deoptimizeBody && this.directlyIncluded)) {
+            this.included = true;
+            this.directlyIncluded = true;
+            if (this.deoptimizeBody)
+                includeChildrenRecursively = true;
+            for (const node of this.body) {
+                if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                    node.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        const firstBodyStatement = this.body[0];
+        this.deoptimizeBody =
+            firstBodyStatement instanceof ExpressionStatement &&
+                firstBodyStatement.directive === 'use asm';
+    }
+    render(code, options) {
+        if (this.body.length) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
 class RestElement extends NodeBase {
     constructor() {
         super(...arguments);
@@ -7512,7 +7605,7 @@ class FunctionNode extends NodeBase {
         this.body.addImplicitReturnExpressionToScope();
     }
     parseNode(esTreeNode) {
-        this.body = new this.context.nodeConstructors.BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
+        this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
         super.parseNode(esTreeNode);
     }
 }
@@ -7527,7 +7620,7 @@ class FunctionDeclaration extends FunctionNode {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
-            this.id = new this.context.nodeConstructors.Identifier(esTreeNode.id, this, this.scope.parent);
+            this.id = new Identifier(esTreeNode.id, this, this.scope.parent);
         }
         super.parseNode(esTreeNode);
     }
@@ -8118,101 +8211,6 @@ class ArrayPattern extends NodeBase {
     }
 }
 
-class BlockScope extends ChildScope {
-    addDeclaration(identifier, context, init, isHoisted) {
-        if (isHoisted) {
-            const variable = this.parent.addDeclaration(identifier, context, init, isHoisted);
-            // Necessary to make sure the init is deoptimized for conditional declarations.
-            // We cannot call deoptimizePath here.
-            variable.markInitializersForDeoptimization();
-            return variable;
-        }
-        else {
-            return super.addDeclaration(identifier, context, init, false);
-        }
-    }
-}
-
-class ExpressionStatement extends NodeBase {
-    initialise() {
-        if (this.directive &&
-            this.directive !== 'use strict' &&
-            this.parent.type === Program$1) {
-            this.context.warn(
-            // This is necessary, because either way (deleting or not) can lead to errors.
-            {
-                code: 'MODULE_LEVEL_DIRECTIVE',
-                message: `Module level directives cause errors when bundled, '${this.directive}' was ignored.`
-            }, this.start);
-        }
-    }
-    render(code, options) {
-        super.render(code, options);
-        if (this.included)
-            this.insertSemicolon(code);
-    }
-    shouldBeIncluded(context) {
-        if (this.directive && this.directive !== 'use strict')
-            return this.parent.type !== Program$1;
-        return super.shouldBeIncluded(context);
-    }
-}
-
-class BlockStatement extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.directlyIncluded = false;
-    }
-    addImplicitReturnExpressionToScope() {
-        const lastStatement = this.body[this.body.length - 1];
-        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
-            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
-        }
-    }
-    createScope(parentScope) {
-        this.scope = this.parent.preventChildBlockScope
-            ? parentScope
-            : new BlockScope(parentScope);
-    }
-    hasEffects(context) {
-        if (this.deoptimizeBody)
-            return true;
-        for (const node of this.body) {
-            if (node.hasEffects(context))
-                return true;
-            if (context.brokenFlow)
-                break;
-        }
-        return false;
-    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimizeBody || !this.directlyIncluded) {
-            this.included = true;
-            this.directlyIncluded = true;
-            if (this.deoptimizeBody)
-                includeChildrenRecursively = true;
-            for (const node of this.body) {
-                if (includeChildrenRecursively || node.shouldBeIncluded(context))
-                    node.include(context, includeChildrenRecursively);
-            }
-        }
-    }
-    initialise() {
-        const firstBodyStatement = this.body[0];
-        this.deoptimizeBody =
-            firstBodyStatement instanceof ExpressionStatement &&
-                firstBodyStatement.directive === 'use asm';
-    }
-    render(code, options) {
-        if (this.body.length) {
-            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
-        }
-        else {
-            super.render(code, options);
-        }
-    }
-}
-
 class ArrowFunctionExpression extends NodeBase {
     constructor() {
         super(...arguments);
@@ -8310,7 +8308,7 @@ class ArrowFunctionExpression extends NodeBase {
     }
     parseNode(esTreeNode) {
         if (esTreeNode.body.type === BlockStatement$1) {
-            this.body = new this.context.nodeConstructors.BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
+            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
         }
         super.parseNode(esTreeNode);
     }
@@ -9086,8 +9084,7 @@ class CatchClause extends NodeBase {
         // name instead of the variable
         const { param } = esTreeNode;
         if (param) {
-            this.param = new (this.context.nodeConstructors[param.type] ||
-                this.context.nodeConstructors.UnknownNode)(param, this, this.scope);
+            this.param = new (this.context.getNodeConstructor(param.type))(param, this, this.scope);
             this.param.declare('parameter', UNKNOWN_EXPRESSION);
         }
         super.parseNode(esTreeNode);
@@ -9123,7 +9120,7 @@ class ClassBody extends NodeBase {
     parseNode(esTreeNode) {
         const body = (this.body = []);
         for (const definition of esTreeNode.body) {
-            body.push(new this.context.nodeConstructors[definition.type](definition, this, definition.static ? this.scope : this.scope.instanceScope));
+            body.push(new (this.context.getNodeConstructor(definition.type))(definition, this, definition.static ? this.scope : this.scope.instanceScope));
         }
         super.parseNode(esTreeNode);
     }
@@ -9614,12 +9611,10 @@ class IfStatement extends NodeBase {
     }
     parseNode(esTreeNode) {
         this.consequentScope = new TrackingScope(this.scope);
-        this.consequent = new (this.context.nodeConstructors[esTreeNode.consequent.type] ||
-            this.context.nodeConstructors.UnknownNode)(esTreeNode.consequent, this, this.consequentScope);
+        this.consequent = new (this.context.getNodeConstructor(esTreeNode.consequent.type))(esTreeNode.consequent, this, this.consequentScope);
         if (esTreeNode.alternate) {
             this.alternateScope = new TrackingScope(this.scope);
-            this.alternate = new (this.context.nodeConstructors[esTreeNode.alternate.type] ||
-                this.context.nodeConstructors.UnknownNode)(esTreeNode.alternate, this, this.alternateScope);
+            this.alternate = new (this.context.getNodeConstructor(esTreeNode.alternate.type))(esTreeNode.alternate, this, this.alternateScope);
         }
         super.parseNode(esTreeNode);
     }
@@ -9851,13 +9846,18 @@ const HELPER_GENERATORS = {
             `}${n}${n}`);
     },
     [MERGE_NAMESPACES_VARIABLE](t, snippets, liveBindings, freeze) {
-        const { _, n } = snippets;
+        const { _, cnst, n } = snippets;
+        const useForEach = cnst === 'var' && liveBindings;
         return (`function ${MERGE_NAMESPACES_VARIABLE}(n, m)${_}{${n}` +
             `${t}${loopOverNamespaces(`{${n}` +
                 `${t}${t}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!(k in n))${_}{${n}` +
-                (liveBindings ? copyPropertyLiveBinding : copyPropertyStatic)(t, t + t + t + t, snippets) +
+                (liveBindings
+                    ? useForEach
+                        ? copyOwnPropertyLiveBinding
+                        : copyPropertyLiveBinding
+                    : copyPropertyStatic)(t, t + t + t + t, snippets) +
                 `${t}${t}${t}}${n}` +
-                `${t}${t}}`, !liveBindings, t, snippets)}${n}` +
+                `${t}${t}}`, useForEach, t, snippets)}${n}` +
             `${t}return ${getFrozen('n', freeze)};${n}` +
             `}${n}${n}`);
     }
@@ -9867,7 +9867,7 @@ const getDefaultStatic = ({ _, getPropertyAccess }) => `e${getPropertyAccess('de
 const createNamespaceObject = (t, i, snippets, liveBindings, freeze, namespaceToStringTag) => {
     const { _, cnst, getPropertyAccess, n, s } = snippets;
     const copyProperty = `{${n}` +
-        (liveBindings ? copyNonDefaultPropertyLiveBinding : copyPropertyStatic)(t, i + t + t, snippets) +
+        (liveBindings ? copyNonDefaultOwnPropertyLiveBinding : copyPropertyStatic)(t, i + t + t, snippets) +
         `${i}${t}}`;
     return (`${i}${cnst} n${_}=${_}${namespaceToStringTag
         ? `{__proto__:${_}null,${_}[Symbol.toStringTag]:${_}'Module'}`
@@ -9884,30 +9884,30 @@ const loopOverKeys = (body, allowVarLoopVariable, { _, cnst, getFunctionIntro, s
         isAsync: false,
         name: null
     })}${body})${s}`;
-const loopOverNamespaces = (body, allowVarLoopVariable, t, { _, cnst, getDirectReturnFunction, getFunctionIntro, n }) => {
-    if (cnst !== 'var' || allowVarLoopVariable) {
-        return (`for${_}(var i${_}=${_}0;${_}i${_}<${_}m.length;${_}i++)${_}{${n}` +
-            `${t}${t}${cnst} e${_}=${_}m[i];${n}` +
-            `${t}${t}if${_}(typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e))${_}{${_}for${_}(${cnst} k in e)${_}${body}${_}}${n}${t}}`);
-    }
-    const [left, right] = getDirectReturnFunction(['e'], {
-        functionReturn: false,
-        lineBreakIndent: { base: t, t },
-        name: null
-    });
-    return (`m.forEach(${left}` +
-        `e${_}&&${_}typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e)${_}&&${_}Object.keys(e).forEach(${getFunctionIntro(['k'], {
-            isAsync: false,
+const loopOverNamespaces = (body, useForEach, t, { _, cnst, getDirectReturnFunction, getFunctionIntro, n }) => {
+    if (useForEach) {
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: false,
+            lineBreakIndent: { base: t, t },
             name: null
-        })}${body})${right});`);
+        });
+        return (`m.forEach(${left}` +
+            `e${_}&&${_}typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e)${_}&&${_}Object.keys(e).forEach(${getFunctionIntro(['k'], {
+                isAsync: false,
+                name: null
+            })}${body})${right});`);
+    }
+    return (`for${_}(var i${_}=${_}0;${_}i${_}<${_}m.length;${_}i++)${_}{${n}` +
+        `${t}${t}${cnst} e${_}=${_}m[i];${n}` +
+        `${t}${t}if${_}(typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e))${_}{${_}for${_}(${cnst} k in e)${_}${body}${_}}${n}${t}}`);
 };
-const copyNonDefaultPropertyLiveBinding = (t, i, snippets) => {
+const copyNonDefaultOwnPropertyLiveBinding = (t, i, snippets) => {
     const { _, n } = snippets;
     return (`${i}if${_}(k${_}!==${_}'default')${_}{${n}` +
-        copyPropertyLiveBinding(t, i + t, snippets) +
+        copyOwnPropertyLiveBinding(t, i + t, snippets) +
         `${i}}${n}`);
 };
-const copyPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n }) => {
+const copyOwnPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n }) => {
     const [left, right] = getDirectReturnFunction([], {
         functionReturn: true,
         lineBreakIndent: null,
@@ -9919,6 +9919,20 @@ const copyPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n })
         `${i}${t}get:${_}${left}e[k]${right}${n}` +
         `${i}});${n}`);
 };
+const copyPropertyLiveBinding = (t, i, { _, cnst, getDirectReturnFunction, n }) => {
+    const [left, right] = getDirectReturnFunction([], {
+        functionReturn: true,
+        lineBreakIndent: null,
+        name: null
+    });
+    return (`${i}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${i}if${_}(d)${_}{${n}` +
+        `${i}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${i}${t}${t}enumerable:${_}true,${n}` +
+        `${i}${t}${t}get:${_}${left}e[k]${right}${n}` +
+        `${i}${t}});${n}` +
+        `${i}}${n}`);
+};
 const copyPropertyStatic = (_t, i, { _, n }) => `${i}n[k]${_}=${_}e[k];${n}`;
 const getFrozen = (fragment, freeze) => freeze ? `Object.freeze(${fragment})` : fragment;
 const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
@@ -11110,6 +11124,34 @@ class SequenceExpression extends NodeBase {
     }
 }
 
+class StaticBlock extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        if (this.body.length) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
 class Super extends NodeBase {
     bind() {
         this.variable = this.scope.findVariable('this');
@@ -11742,6 +11784,7 @@ const nodeConstructors = {
     ReturnStatement,
     SequenceExpression,
     SpreadElement,
+    StaticBlock,
     Super,
     SwitchCase,
     SwitchStatement,
@@ -12140,7 +12183,6 @@ class Module {
         this.isExecuted = false;
         this.isUserDefinedEntryPoint = false;
         this.needsExportShim = false;
-        this.preserveSignature = this.options.preserveEntrySignatures;
         this.reexportDescriptions = Object.create(null);
         this.sideEffectDependenciesByVariable = new Map();
         this.sources = new Set();
@@ -12158,6 +12200,7 @@ class Module {
         this.transitiveReexports = null;
         this.excludeFromSourcemap = /\0/.test(id);
         this.context = options.moduleContext(id);
+        this.preserveSignature = this.options.preserveEntrySignatures;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const module = this;
         this.info = {
@@ -12184,7 +12227,7 @@ class Module {
                 return Array.from(module.implicitlyLoadedBefore, getId);
             },
             get importedIds() {
-                return Array.from(module.sources, source => module.resolvedIds[source].id);
+                return Array.from(module.sources, source => { var _a; return (_a = module.resolvedIds[source]) === null || _a === void 0 ? void 0 : _a.id; }).filter(Boolean);
             },
             get importers() {
                 return module.importers.sort();
@@ -12535,6 +12578,7 @@ class Module {
             getExports: this.getExports.bind(this),
             getModuleExecIndex: () => this.execIndex,
             getModuleName: this.basename.bind(this),
+            getNodeConstructor: (name) => nodeConstructors[name] || nodeConstructors.UnknownNode,
             getReexports: this.getReexports.bind(this),
             importDescriptions: this.importDescriptions,
             includeAllExports: () => this.includeAllExports(true),
@@ -12543,7 +12587,6 @@ class Module {
             magicString: this.magicString,
             module: this,
             moduleContext: this.context,
-            nodeConstructors,
             options: this.options,
             requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
             traceExport: this.getVariableForExportName.bind(this),
@@ -21847,6 +21890,7 @@ class ModuleLoader {
         this.implicitEntryModules = new Set();
         this.indexedEntryModules = [];
         this.latestLoadModulesPromise = Promise.resolve();
+        this.moduleLoadPromises = new Map();
         this.nextEntryModuleIndex = 0;
         this.readQueue = new Queue();
         this.resolveId = async (source, importer, customOptions, isEntry, skip = null) => {
@@ -21908,6 +21952,9 @@ class ModuleLoader {
         }
         return module;
     }
+    preloadModule(resolvedId) {
+        return this.fetchModule(this.addDefaultsToResolvedId(resolvedId), undefined, false, true).then(module => module.info);
+    }
     addDefaultsToResolvedId(resolvedId) {
         var _a, _b;
         if (!resolvedId) {
@@ -22008,39 +22055,45 @@ class ModuleLoader {
             }
         }
     }
-    async fetchModule({ id, meta, moduleSideEffects, syntheticNamedExports }, importer, isEntry) {
+    // If this is a preload, then this method always waits for the dependencies of the module to be resolved.
+    // Otherwise if the module does not exist, it waits for the module and all its dependencies to be loaded.
+    // Otherwise it returns immediately.
+    async fetchModule({ id, meta, moduleSideEffects, syntheticNamedExports }, importer, isEntry, isPreload) {
         const existingModule = this.modulesById.get(id);
         if (existingModule instanceof Module) {
-            if (isEntry) {
-                existingModule.info.isEntry = true;
-                this.implicitEntryModules.delete(existingModule);
-                for (const dependant of existingModule.implicitlyLoadedAfter) {
-                    dependant.implicitlyLoadedBefore.delete(existingModule);
-                }
-                existingModule.implicitlyLoadedAfter.clear();
-            }
+            await this.handleExistingModule(existingModule, isEntry, isPreload);
             return existingModule;
         }
         const module = new Module(this.graph, id, this.options, isEntry, moduleSideEffects, syntheticNamedExports, meta);
         this.modulesById.set(id, module);
         this.graph.watchFiles[id] = true;
-        await this.addModuleSource(id, importer, module);
-        const resolveStaticDependencyPromises = this.getResolveStaticDependencyPromises(module);
-        const resolveDynamicImportPromises = this.getResolveDynamicImportPromises(module);
-        Promise.all([
-            ...resolveStaticDependencyPromises,
-            ...resolveDynamicImportPromises
-        ])
-            .then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]))
-            .catch(() => {
-            /* rejections thrown here are also handled within PluginDriver - they are safe to ignore */
+        const loadPromise = this.addModuleSource(id, importer, module).then(() => [
+            this.getResolveStaticDependencyPromises(module),
+            this.getResolveDynamicImportPromises(module)
+        ]);
+        const loadAndResolveDependenciesPromise = loadPromise
+            .then(([resolveStaticDependencyPromises, resolveDynamicImportPromises]) => Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]))
+            .then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
+        loadAndResolveDependenciesPromise.catch(() => {
+            /* avoid unhandled promise rejections */
         });
+        if (isPreload) {
+            this.moduleLoadPromises.set(module, loadPromise);
+            await loadPromise;
+        }
+        else {
+            await this.fetchModuleDependencies(module, ...(await loadPromise));
+            // To handle errors when resolving dependencies or in moduleParsed
+            await loadAndResolveDependenciesPromise;
+        }
+        return module;
+    }
+    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises) {
         await Promise.all([
             this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
-            this.fetchDynamicDependencies(module, resolveDynamicImportPromises)
+            this.fetchDynamicDependencies(module, resolveDynamicDependencyPromises)
         ]);
         module.linkImports();
-        return module;
     }
     fetchResolvedDependency(source, importer, resolvedId) {
         if (resolvedId.external) {
@@ -22055,7 +22108,7 @@ class ModuleLoader {
             return Promise.resolve(externalModule);
         }
         else {
-            return this.fetchModule(resolvedId, importer, false);
+            return this.fetchModule(resolvedId, importer, false, false);
         }
     }
     async fetchStaticDependencies(module, resolveStaticDependencyPromises) {
@@ -22126,6 +22179,26 @@ class ModuleLoader {
                     this.handleResolveId(await this.resolveId(source, module.id, EMPTY_OBJECT, false), source, module.id))
         ]);
     }
+    async handleExistingModule(module, isEntry, isPreload) {
+        const loadPromise = this.moduleLoadPromises.get(module);
+        if (isPreload) {
+            await loadPromise;
+            return;
+        }
+        if (isEntry) {
+            module.info.isEntry = true;
+            this.implicitEntryModules.delete(module);
+            for (const dependant of module.implicitlyLoadedAfter) {
+                dependant.implicitlyLoadedBefore.delete(module);
+            }
+            module.implicitlyLoadedAfter.clear();
+        }
+        if (loadPromise) {
+            this.moduleLoadPromises.delete(module);
+            await this.fetchModuleDependencies(module, ...(await loadPromise));
+        }
+        return;
+    }
     handleResolveId(resolvedId, source, importer) {
         if (resolvedId === null) {
             if (isRelative(source)) {
@@ -22162,7 +22235,7 @@ class ModuleLoader {
         }
         return this.fetchModule(this.addDefaultsToResolvedId(typeof resolveIdResult === 'object'
             ? resolveIdResult
-            : { id: resolveIdResult }), undefined, isEntry);
+            : { id: resolveIdResult }), undefined, isEntry, false);
     }
     async resolveDynamicImport(module, specifier, importer) {
         const resolution = await this.pluginDriver.hookFirst('resolveDynamicImport', [
@@ -22290,12 +22363,16 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
         getModuleInfo: graph.getModuleInfo,
         getWatchFiles: () => Object.keys(graph.watchFiles),
         isExternal: getDeprecatedContextHandler((id, parentId, isResolved = false) => options.external(id, parentId, isResolved), 'isExternal', 'resolve', plugin.name, true, options),
+        load(resolvedId) {
+            return graph.moduleLoader.preloadModule(resolvedId);
+        },
         meta: {
             rollupVersion: version$1,
             watchMode: graph.watchMode
         },
         get moduleIds() {
             function* wrappedModuleIds() {
+                // We are wrapping this in a generator to only show the message once we are actually iterating
                 warnDeprecation({
                     message: `Accessing "this.moduleIds" on the plugin context by plugin ${plugin.name} is deprecated. The "this.getModuleIds" plugin context function should be used instead.`,
                     plugin: plugin.name
@@ -23007,12 +23084,15 @@ const getHasModuleSideEffects = (moduleSideEffectsOption, pureExternalModules) =
     return (id, external) => !(external && isPureExternalModule(id));
 };
 
+// https://datatracker.ietf.org/doc/html/rfc2396
+// eslint-disable-next-line no-control-regex
+const INVALID_CHAR_RE = /[\x00-\x1F\x7F<>*#"{}|^[\]`;?:&=+$,]/g;
 function sanitizeFileName(name) {
     const match = /^[a-z]:/i.exec(name);
     const driveLetter = match ? match[0] : '';
     // A `:` is only allowed as part of a windows drive letter (ex: C:\foo)
     // Otherwise, avoid them because they can refer to NTFS alternate data streams.
-    return driveLetter + name.substr(driveLetter.length).replace(/[\0?*:]/g, '_');
+    return driveLetter + name.substr(driveLetter.length).replace(INVALID_CHAR_RE, '_');
 }
 
 function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {