rollup 2.72.1 → 2.74.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.72.1
-	Sat, 07 May 2022 19:04:43 GMT - commit 8c6e0f319b792ea52fe979888593b6523315ae93
+	Rollup.js v2.74.1
+	Thu, 19 May 2022 17:50:11 GMT - commit e823eded9920d6082cc8c1afcf591b716ab6b160
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.72.1";
+var version$1 = "2.74.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -2155,9 +2155,16 @@ function getOrCreate(map, key, init) {
 }
 
 const UnknownKey = Symbol('Unknown Key');
+const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
 const UnknownInteger = Symbol('Unknown Integer');
 const EMPTY_PATH = [];
 const UNKNOWN_PATH = [UnknownKey];
+// For deoptimizations, this means we are modifying an unknown property but did
+// not lose track of the object or are creating a setter/getter;
+// For assignment effects it means we do not check for setter/getter effects
+// but only if something is mutated that is included, which is relevant for
+// Object.defineProperty
+const UNKNOWN_NON_ACCESSOR_PATH = [UnknownNonAccessorKey];
 const UNKNOWN_INTEGER_PATH = [UnknownInteger];
 const EntitiesKey = Symbol('Entities');
 class PathTracker {
@@ -4711,7 +4718,7 @@ const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEn
 })();
 const returnsUnknown = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_EXPRESSION
     }
 };
@@ -4734,7 +4741,7 @@ const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEnti
 })();
 const returnsBoolean = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_BOOLEAN
     }
 };
@@ -4757,7 +4764,7 @@ const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity
 })();
 const returnsNumber = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_NUMBER
     }
 };
@@ -4780,7 +4787,24 @@ const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity
 })();
 const returnsString = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const stringReplace = {
+    value: {
+        hasEffectsWhenCalled(callOptions, context) {
+            const arg1 = callOptions.args[1];
+            return (callOptions.args.length < 2 ||
+                (arg1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                    deoptimizeCache() { }
+                }) === UnknownValue &&
+                    arg1.hasEffectsWhenCalledAtPath(EMPTY_PATH, {
+                        args: NO_ARGS,
+                        thisParam: null,
+                        withNew: false
+                    }, context)));
+        },
         returns: UNKNOWN_LITERAL_STRING
     }
 };
@@ -4828,18 +4852,8 @@ const literalStringMembers = assembleMemberDescriptions({
     padEnd: returnsString,
     padStart: returnsString,
     repeat: returnsString,
-    replace: {
-        value: {
-            callsArgs: [1],
-            returns: UNKNOWN_LITERAL_STRING
-        }
-    },
-    replaceAll: {
-        value: {
-            callsArgs: [1],
-            returns: UNKNOWN_LITERAL_STRING
-        }
-    },
+    replace: stringReplace,
+    replaceAll: stringReplace,
     search: returnsNumber,
     slice: returnsString,
     small: returnsString,
@@ -4874,21 +4888,11 @@ function getLiteralMembersForValue(value) {
     return Object.create(null);
 }
 function hasMemberEffectWhenCalled(members, memberName, callOptions, context) {
+    var _a, _b;
     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;
+    return ((_b = (_a = members[memberName]).hasEffectsWhenCalled) === null || _b === void 0 ? void 0 : _b.call(_a, callOptions, context)) || false;
 }
 function getMemberReturnExpressionWhenCalled(members, memberName) {
     if (typeof memberName !== 'string' || !members[memberName])
@@ -5595,6 +5599,7 @@ class ObjectEntity extends ExpressionEntity {
         this.deoptimizedPaths = Object.create(null);
         this.expressionsToBeDeoptimizedByKey = Object.create(null);
         this.gettersByKey = Object.create(null);
+        this.hasLostTrack = false;
         this.hasUnknownDeoptimizedInteger = false;
         this.hasUnknownDeoptimizedProperty = false;
         this.propertiesAndGettersByKey = Object.create(null);
@@ -5615,12 +5620,18 @@ class ObjectEntity extends ExpressionEntity {
             }
         }
     }
-    deoptimizeAllProperties() {
+    deoptimizeAllProperties(noAccessors) {
         var _a;
-        if (this.hasUnknownDeoptimizedProperty) {
+        const isDeoptimized = this.hasLostTrack || this.hasUnknownDeoptimizedProperty;
+        if (noAccessors) {
+            this.hasUnknownDeoptimizedProperty = true;
+        }
+        else {
+            this.hasLostTrack = true;
+        }
+        if (isDeoptimized) {
             return;
         }
-        this.hasUnknownDeoptimizedProperty = true;
         for (const properties of Object.values(this.propertiesAndGettersByKey).concat(Object.values(this.settersByKey))) {
             for (const property of properties) {
                 property.deoptimizePath(UNKNOWN_PATH);
@@ -5631,7 +5642,9 @@ class ObjectEntity extends ExpressionEntity {
         this.deoptimizeCachedEntities();
     }
     deoptimizeIntegerProperties() {
-        if (this.hasUnknownDeoptimizedProperty || this.hasUnknownDeoptimizedInteger) {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            this.hasUnknownDeoptimizedInteger) {
             return;
         }
         this.hasUnknownDeoptimizedInteger = true;
@@ -5644,17 +5657,19 @@ class ObjectEntity extends ExpressionEntity {
         }
         this.deoptimizeCachedIntegerEntities();
     }
+    // Assumption: If only a specific path is deoptimized, no accessors are created
     deoptimizePath(path) {
         var _a;
-        if (this.hasUnknownDeoptimizedProperty || this.immutable)
+        if (this.hasLostTrack || this.immutable) {
             return;
+        }
         const key = path[0];
         if (path.length === 1) {
             if (typeof key !== 'string') {
                 if (key === UnknownInteger) {
                     return this.deoptimizeIntegerProperties();
                 }
-                return this.deoptimizeAllProperties();
+                return this.deoptimizeAllProperties(key === UnknownNonAccessorKey);
             }
             if (!this.deoptimizedPaths[key]) {
                 this.deoptimizedPaths[key] = true;
@@ -5679,11 +5694,11 @@ class ObjectEntity extends ExpressionEntity {
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
         var _a;
         const [key, ...subPath] = path;
-        if (this.hasUnknownDeoptimizedProperty ||
+        if (this.hasLostTrack ||
             // single paths that are deoptimized will not become getters or setters
             ((event === EVENT_CALLED || path.length > 1) &&
-                typeof key === 'string' &&
-                this.deoptimizedPaths[key])) {
+                (this.hasUnknownDeoptimizedProperty ||
+                    (typeof key === 'string' && this.deoptimizedPaths[key])))) {
             thisParameter.deoptimizePath(UNKNOWN_PATH);
             return;
         }
@@ -5781,7 +5796,7 @@ class ObjectEntity extends ExpressionEntity {
             }
             return true;
         }
-        if (this.hasUnknownDeoptimizedProperty)
+        if (this.hasLostTrack)
             return true;
         if (typeof key === 'string') {
             if (this.propertiesAndGettersByKey[key]) {
@@ -5828,9 +5843,10 @@ class ObjectEntity extends ExpressionEntity {
             }
             return true;
         }
-        if (this.hasUnknownDeoptimizedProperty)
+        if (key === UnknownNonAccessorKey)
+            return false;
+        if (this.hasLostTrack)
             return true;
-        // We do not need to test for unknown properties as in that case, hasUnknownDeoptimizedProperty is true
         if (typeof key === 'string') {
             if (this.propertiesAndSettersByKey[key]) {
                 const setters = this.settersByKey[key];
@@ -5848,6 +5864,14 @@ class ObjectEntity extends ExpressionEntity {
                 }
             }
         }
+        else {
+            for (const setters of Object.values(this.settersByKey).concat([this.unmatchableSetters])) {
+                for (const setter of setters) {
+                    if (setter.hasEffectsWhenAssignedAtPath(subPath, context))
+                        return true;
+                }
+            }
+        }
         if (this.prototypeExpression) {
             return this.prototypeExpression.hasEffectsWhenAssignedAtPath(path, context);
         }
@@ -5931,7 +5955,8 @@ class ObjectEntity extends ExpressionEntity {
         }
     }
     getMemberExpression(key) {
-        if (this.hasUnknownDeoptimizedProperty ||
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
             typeof key !== 'string' ||
             (this.hasUnknownDeoptimizedInteger && INTEGER_REG_EXP.test(key)) ||
             this.deoptimizedPaths[key]) {
@@ -6597,323 +6622,89 @@ class ReturnValueScope extends ParameterScope {
     }
 }
 
-function treeshakeNode(node, code, start, end) {
-    code.remove(start, end);
-    if (node.annotations) {
-        for (const annotation of node.annotations) {
-            if (annotation.start < start) {
-                code.remove(annotation.start, annotation.end);
-            }
-            else {
-                return;
-            }
-        }
-    }
-}
-function removeAnnotations(node, code) {
-    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
-        node = node.parent;
-    }
-    if (node.annotations) {
-        for (const annotation of node.annotations) {
-            code.remove(annotation.start, annotation.end);
-        }
-    }
-}
+//@ts-check
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
 
-const NO_SEMICOLON = { isNoStatement: true };
-// This assumes there are only white-space and comments between start and the string we are looking for
-function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
-    let searchPos, charCodeAfterSlash;
-    searchPos = code.indexOf(searchString, start);
-    while (true) {
-        start = code.indexOf('/', start);
-        if (start === -1 || start >= searchPos)
-            return searchPos;
-        charCodeAfterSlash = code.charCodeAt(++start);
-        ++start;
-        // With our assumption, '/' always starts a comment. Determine comment type:
-        start =
-            charCodeAfterSlash === 47 /*"/"*/
-                ? code.indexOf('\n', start) + 1
-                : code.indexOf('*/', start) + 2;
-        if (start > searchPos) {
-            searchPos = code.indexOf(searchString, start);
-        }
-    }
-}
-const NON_WHITESPACE = /\S/g;
-function findNonWhiteSpace(code, 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
-function findFirstLineBreakOutsideComment(code) {
-    let lineBreakPos, charCodeAfterSlash, start = 0;
-    lineBreakPos = code.indexOf('\n', start);
-    while (true) {
-        start = code.indexOf('/', start);
-        if (start === -1 || start > lineBreakPos)
-            return [lineBreakPos, lineBreakPos + 1];
-        // With our assumption, '/' always starts a comment. Determine comment type:
-        charCodeAfterSlash = code.charCodeAt(start + 1);
-        if (charCodeAfterSlash === 47 /*"/"*/)
-            return [start, lineBreakPos + 1];
-        start = code.indexOf('*/', start + 3) + 2;
-        if (start > lineBreakPos) {
-            lineBreakPos = code.indexOf('\n', start);
-        }
-    }
+/**
+ *
+ * @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;
 }
-function renderStatementList(statements, code, start, end, options) {
-    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
-    let nextNode = statements[0];
-    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
-    if (nextNodeNeedsBoundaries) {
-        nextNodeStart =
-            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
-    }
-    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
-        currentNode = nextNode;
-        currentNodeStart = nextNodeStart;
-        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
-        nextNode = statements[nextIndex];
-        nextNodeNeedsBoundaries =
-            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
-        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
-            nextNodeStart =
-                currentNode.end +
-                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
-            if (currentNode.included) {
-                currentNodeNeedsBoundaries
-                    ? currentNode.render(code, options, {
-                        end: nextNodeStart,
-                        start: currentNodeStart
-                    })
-                    : currentNode.render(code, options);
-            }
-            else {
-                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
-            }
-        }
-        else {
-            currentNode.render(code, options);
-        }
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const PURE = {
+    hasEffectsWhenCalled() {
+        return false;
     }
-}
-// This assumes that the first character is not part of the first node
-function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
-    const splitUpNodes = [];
-    let node, nextNode, nextNodeStart, contentEnd, char;
-    let separator = start - 1;
-    for (let nextIndex = 0; nextIndex < nodes.length; nextIndex++) {
-        nextNode = nodes[nextIndex];
-        if (node !== undefined) {
-            separator =
-                node.end +
-                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
-        }
-        nextNodeStart = contentEnd =
-            separator +
-                1 +
-                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
-        while (((char = code.original.charCodeAt(nextNodeStart)),
-            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
-            nextNodeStart++;
-        if (node !== undefined) {
-            splitUpNodes.push({
-                contentEnd,
-                end: nextNodeStart,
-                node,
-                separator,
-                start
-            });
-        }
-        node = nextNode;
-        start = nextNodeStart;
+};
+const IMPURE = {
+    hasEffectsWhenCalled() {
+        return true;
     }
-    splitUpNodes.push({
-        contentEnd: end,
-        end,
-        node: node,
-        separator: null,
-        start
-    });
-    return splitUpNodes;
-}
-// This assumes there are only white-space and comments between start and end
-function removeLineBreaks(code, start, end) {
-    while (true) {
-        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
-        if (removeStart === -1) {
-            break;
+};
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
+};
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
+};
+/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
+const MUTATES_ARG_WITHOUT_ACCESSOR = {
+    __proto__: null,
+    [ValueProperties]: {
+        hasEffectsWhenCalled(callOptions, context) {
+            return (!callOptions.args.length ||
+                callOptions.args[0].hasEffectsWhenAssignedAtPath(UNKNOWN_NON_ACCESSOR_PATH, context));
         }
-        code.remove(start + removeStart, (start += removeEnd));
     }
-}
-
-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);
-        }
-    }
-}
-
-//@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 = {
@@ -7053,6 +6844,11 @@ const knownGlobals = {
         __proto__: null,
         [ValueProperties]: PURE,
         create: PF,
+        // Technically those can throw in certain situations, but we ignore this as
+        // code that relies on this will hopefully wrap this in a try-catch, which
+        // deoptimizes everything anyway
+        defineProperty: MUTATES_ARG_WITHOUT_ACCESSOR,
+        defineProperties: MUTATES_ARG_WITHOUT_ACCESSOR,
         getOwnPropertyDescriptor: PF,
         getOwnPropertyNames: PF,
         getOwnPropertySymbols: PF,
@@ -7736,27 +7532,24 @@ function getGlobalAtPath(path) {
     }
     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);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
         this.isReassigned = true;
     }
     hasEffectsWhenAccessedAtPath(path) {
-        return !isGlobalMember([this.name, ...path]);
+        if (path.length === 0) {
+            // Technically, "undefined" is a global variable of sorts
+            return this.name !== 'undefined' && getGlobalAtPath([this.name]) === null;
+        }
+        return getGlobalAtPath([this.name, ...path].slice(0, -1)) === null;
     }
-    hasEffectsWhenCalledAtPath(path) {
-        return !isPureGlobal([this.name, ...path]);
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return globalAtPath === null || globalAtPath.hasEffectsWhenCalled(callOptions, context);
     }
 }
 
@@ -7892,57 +7685,309 @@ class Identifier extends NodeBase {
             // var use before declaration was encountered.
             return (this.isTDZAccess = true);
         }
-        return (this.isTDZAccess = false);
+        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();
+        }
+    }
+    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;
+    }
+}
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
+}
+
+function treeshakeNode(node, code, start, end) {
+    code.remove(start, end);
+    if (node.annotations) {
+        for (const annotation of node.annotations) {
+            if (annotation.start < start) {
+                code.remove(annotation.start, annotation.end);
+            }
+            else {
+                return;
+            }
+        }
+    }
+}
+function removeAnnotations(node, code) {
+    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
+        node = node.parent;
+    }
+    if (node.annotations) {
+        for (const annotation of node.annotations) {
+            code.remove(annotation.start, annotation.end);
+        }
+    }
+}
+
+const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
+function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
+    let searchPos, charCodeAfterSlash;
+    searchPos = code.indexOf(searchString, start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start >= searchPos)
+            return searchPos;
+        charCodeAfterSlash = code.charCodeAt(++start);
+        ++start;
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
+        }
+    }
+}
+const NON_WHITESPACE = /\S/g;
+function findNonWhiteSpace(code, 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
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
+    lineBreakPos = code.indexOf('\n', start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start > lineBreakPos)
+            return [lineBreakPos, lineBreakPos + 1];
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        charCodeAfterSlash = code.charCodeAt(start + 1);
+        if (charCodeAfterSlash === 47 /*"/"*/)
+            return [start, lineBreakPos + 1];
+        start = code.indexOf('*/', start + 3) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
+        }
+    }
+}
+function renderStatementList(statements, code, start, end, options) {
+    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
+    let nextNode = statements[0];
+    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
+    if (nextNodeNeedsBoundaries) {
+        nextNodeStart =
+            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
+    }
+    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
+        currentNode = nextNode;
+        currentNodeStart = nextNodeStart;
+        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
+        nextNode = statements[nextIndex];
+        nextNodeNeedsBoundaries =
+            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
+        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
+            nextNodeStart =
+                currentNode.end +
+                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
+            if (currentNode.included) {
+                currentNodeNeedsBoundaries
+                    ? currentNode.render(code, options, {
+                        end: nextNodeStart,
+                        start: currentNodeStart
+                    })
+                    : currentNode.render(code, options);
+            }
+            else {
+                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
+            }
+        }
+        else {
+            currentNode.render(code, options);
+        }
+    }
+}
+// This assumes that the first character is not part of the first node
+function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
+    const splitUpNodes = [];
+    let node, nextNode, nextNodeStart, contentEnd, char;
+    let separator = start - 1;
+    for (let nextIndex = 0; nextIndex < nodes.length; nextIndex++) {
+        nextNode = nodes[nextIndex];
+        if (node !== undefined) {
+            separator =
+                node.end +
+                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
+        }
+        nextNodeStart = contentEnd =
+            separator +
+                1 +
+                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
+        while (((char = code.original.charCodeAt(nextNodeStart)),
+            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
+            nextNodeStart++;
+        if (node !== undefined) {
+            splitUpNodes.push({
+                contentEnd,
+                end: nextNodeStart,
+                node,
+                separator,
+                start
+            });
+        }
+        node = nextNode;
+        start = nextNodeStart;
+    }
+    splitUpNodes.push({
+        contentEnd: end,
+        end,
+        node: node,
+        separator: null,
+        start
+    });
+    return splitUpNodes;
+}
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (removeStart === -1) {
+            break;
+        }
+        code.remove(start + removeStart, (start += removeEnd));
+    }
+}
+
+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);
+        }
     }
-    markDeclarationReached() {
-        this.variable.initReached = true;
+    createScope(parentScope) {
+        this.scope = this.parent.preventChildBlockScope
+            ? parentScope
+            : new BlockScope(parentScope);
     }
-    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, ');
-            }
+    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;
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.variable !== null && this.variable instanceof LocalVariable) {
-            this.variable.consolidateInitializers();
-            this.context.requestTreeshakingPass();
+    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);
+            }
         }
     }
-    disallowImportReassignment() {
-        return this.context.error({
-            code: 'ILLEGAL_REASSIGNMENT',
-            message: `Illegal reassignment to import '${this.name}'`
-        }, this.start);
+    initialise() {
+        const firstBodyStatement = this.body[0];
+        this.deoptimizeBody =
+            firstBodyStatement instanceof ExpressionStatement &&
+                firstBodyStatement.directive === 'use asm';
     }
-    getVariableRespectingTDZ() {
-        if (this.isPossibleTDZ()) {
-            return UNKNOWN_EXPRESSION;
+    render(code, options) {
+        if (this.body.length) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
         }
-        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;
 }
 
 class RestElement extends NodeBase {
@@ -7976,26 +8021,31 @@ class RestElement extends NodeBase {
     }
 }
 
-class ArrowFunctionExpression extends NodeBase {
+class FunctionBase extends NodeBase {
     constructor() {
         super(...arguments);
+        this.objectEntity = null;
         this.deoptimizedReturn = false;
     }
-    createScope(parentScope) {
-        this.scope = new ReturnValueScope(parentScope, this.context);
-    }
     deoptimizePath(path) {
-        // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
-        // which means the return expression needs to be reassigned
+        this.getObjectEntity().deoptimizePath(path);
         if (path.length === 1 && path[0] === UnknownKey) {
+            // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
+            // which means the return expression needs to be reassigned
             this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
         }
     }
-    // Arrow functions do not mutate their context
-    deoptimizeThisOnEventAtPath() { }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 0) {
-            return UNKNOWN_EXPRESSION;
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        if (path.length > 0) {
+            this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+        if (path.length > 0) {
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
         }
         if (this.async) {
             if (!this.deoptimizedReturn) {
@@ -8007,18 +8057,16 @@ class ArrowFunctionExpression extends NodeBase {
         }
         return this.scope.getReturnExpression();
     }
-    hasEffects() {
-        return false;
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
+    hasEffectsWhenAccessedAtPath(path, context) {
+        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
     }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 1;
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
     }
-    hasEffectsWhenCalledAtPath(path, _callOptions, context) {
-        if (path.length > 0)
-            return true;
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length > 0) {
+            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+        }
         if (this.async) {
             const { propertyReadSideEffects } = this.context.options
                 .treeshake;
@@ -8034,26 +8082,10 @@ class ArrowFunctionExpression extends NodeBase {
             if (param.hasEffects(context))
                 return true;
         }
-        const { ignore, brokenFlow } = context;
-        context.ignore = {
-            breaks: false,
-            continues: false,
-            labels: new Set(),
-            returnYield: true
-        };
-        if (this.body.hasEffects(context))
-            return true;
-        context.ignore = ignore;
-        context.brokenFlow = brokenFlow;
         return false;
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
-        for (const param of this.params) {
-            if (!(param instanceof Identifier)) {
-                param.include(context, includeChildrenRecursively);
-            }
-        }
         const { brokenFlow } = context;
         context.brokenFlow = BROKEN_FLOW_NONE;
         this.body.include(context, includeChildrenRecursively);
@@ -8078,7 +8110,50 @@ class ArrowFunctionExpression extends NodeBase {
         super.parseNode(esTreeNode);
     }
 }
-ArrowFunctionExpression.prototype.preventChildBlockScope = true;
+FunctionBase.prototype.preventChildBlockScope = true;
+
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, this.context);
+    }
+    hasEffects() {
+        return false;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (super.hasEffectsWhenCalledAtPath(path, callOptions, context))
+            return true;
+        const { ignore, brokenFlow } = context;
+        context.ignore = {
+            breaks: false,
+            continues: false,
+            labels: new Set(),
+            returnYield: true
+        };
+        if (this.body.hasEffects(context))
+            return true;
+        context.ignore = ignore;
+        context.brokenFlow = brokenFlow;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        for (const param of this.params) {
+            if (!(param instanceof Identifier)) {
+                param.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
 
 function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
     if (exportedVariables.length === 1 &&
@@ -8372,85 +8447,26 @@ class FunctionScope extends ReturnValueScope {
     }
 }
 
-class FunctionNode extends NodeBase {
+class FunctionNode extends FunctionBase {
     constructor() {
         super(...arguments);
-        this.deoptimizedReturn = false;
-        this.isPrototypeDeoptimized = false;
+        this.objectEntity = null;
     }
     createScope(parentScope) {
         this.scope = new FunctionScope(parentScope, this.context);
     }
-    deoptimizePath(path) {
-        if (path.length === 1) {
-            if (path[0] === 'prototype') {
-                this.isPrototypeDeoptimized = true;
-            }
-            else if (path[0] === UnknownKey) {
-                this.isPrototypeDeoptimized = true;
-                // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
-                // which means the return expression needs to be reassigned as well
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-    }
-    // TODO for completeness, we should also track other events here
-    deoptimizeThisOnEventAtPath(event, path, thisParameter) {
-        if (event === EVENT_CALLED) {
-            if (path.length > 0) {
-                thisParameter.deoptimizePath(UNKNOWN_PATH);
-            }
-            else {
-                this.scope.thisVariable.addEntityToBeDeoptimized(thisParameter);
-            }
-        }
-    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 0) {
-            return UNKNOWN_EXPRESSION;
-        }
-        if (this.async) {
-            if (!this.deoptimizedReturn) {
-                this.deoptimizedReturn = true;
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-                this.context.requestTreeshakingPass();
-            }
-            return UNKNOWN_EXPRESSION;
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        super.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        if (event === EVENT_CALLED && path.length === 0) {
+            this.scope.thisVariable.addEntityToBeDeoptimized(thisParameter);
         }
-        return this.scope.getReturnExpression();
     }
     hasEffects() {
         return this.id !== null && this.id.hasEffects();
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (path.length <= 1)
-            return false;
-        return path.length > 2 || path[0] !== 'prototype' || this.isPrototypeDeoptimized;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        if (path.length <= 1) {
-            return false;
-        }
-        return path.length > 2 || path[0] !== 'prototype' || this.isPrototypeDeoptimized;
-    }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length > 0)
+        if (super.hasEffectsWhenCalledAtPath(path, callOptions, context))
             return true;
-        if (this.async) {
-            const { propertyReadSideEffects } = this.context.options
-                .treeshake;
-            const returnExpression = this.scope.getReturnExpression();
-            if (returnExpression.hasEffectsWhenCalledAtPath(['then'], { args: NO_ARGS, thisParam: null, withNew: false }, context) ||
-                (propertyReadSideEffects &&
-                    (propertyReadSideEffects === 'always' ||
-                        returnExpression.hasEffectsWhenAccessedAtPath(['then'], context)))) {
-                return true;
-            }
-        }
-        for (const param of this.params) {
-            if (param.hasEffects(context))
-                return true;
-        }
         const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
         context.replacedVariableInits.set(this.scope.thisVariable, callOptions.withNew
             ? new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE)
@@ -8475,7 +8491,7 @@ class FunctionNode extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
-        this.included = true;
+        super.include(context, includeChildrenRecursively);
         if (this.id)
             this.id.include();
         const hasArguments = this.scope.argumentsVariable.included;
@@ -8484,27 +8500,25 @@ class FunctionNode extends NodeBase {
                 param.include(context, includeChildrenRecursively);
             }
         }
-        const { brokenFlow } = context;
-        context.brokenFlow = BROKEN_FLOW_NONE;
-        this.body.include(context, includeChildrenRecursively);
-        context.brokenFlow = brokenFlow;
-    }
-    includeCallArguments(context, args) {
-        this.scope.includeCallArguments(context, args);
     }
     initialise() {
-        if (this.id !== null) {
-            this.id.declare('function', this);
-        }
-        this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
-        this.body.addImplicitReturnExpressionToScope();
+        var _a;
+        super.initialise();
+        (_a = this.id) === null || _a === void 0 ? void 0 : _a.declare('function', this);
     }
-    parseNode(esTreeNode) {
-        this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
-        super.parseNode(esTreeNode);
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([
+            {
+                key: 'prototype',
+                kind: 'init',
+                property: new ObjectEntity([], OBJECT_PROTOTYPE)
+            }
+        ], OBJECT_PROTOTYPE));
     }
 }
-FunctionNode.prototype.preventChildBlockScope = true;
 
 class AwaitExpression extends NodeBase {
     constructor() {
@@ -8754,7 +8768,11 @@ class MemberExpression extends NodeBase {
         }
         else if (!this.replacement) {
             if (path.length < MAX_PATH_DEPTH) {
-                this.object.deoptimizePath([this.getPropertyKey(), ...path]);
+                const propertyKey = this.getPropertyKey();
+                this.object.deoptimizePath([
+                    propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                    ...path
+                ]);
             }
         }
     }
@@ -12434,8 +12452,8 @@ class Module {
         this.importMetas = [];
         this.importedFromNotTreeshaken = false;
         this.importers = [];
-        this.imports = new Set();
         this.includedDynamicImporters = [];
+        this.includedImports = new Set();
         this.isExecuted = false;
         this.isUserDefinedEntryPoint = false;
         this.needsExportShim = false;
@@ -12564,7 +12582,7 @@ class Module {
         this.relevantDependencies = new Set();
         const necessaryDependencies = new Set();
         const alwaysCheckedDependencies = new Set();
-        const dependencyVariables = new Set(this.imports);
+        const dependencyVariables = new Set(this.includedImports);
         if (this.info.isEntry ||
             this.includedDynamicImporters.length > 0 ||
             this.namespace.included ||
@@ -13142,13 +13160,13 @@ class Module {
             if (module instanceof ExternalModule) {
                 const [externalVariable] = module.getVariableForExportName('*');
                 externalVariable.include();
-                this.imports.add(externalVariable);
+                this.includedImports.add(externalVariable);
                 externalNamespaces.add(externalVariable);
             }
             else if (module.info.syntheticNamedExports) {
                 const syntheticNamespace = module.getSyntheticNamespace();
                 syntheticNamespace.include();
-                this.imports.add(syntheticNamespace);
+                this.includedImports.add(syntheticNamespace);
                 syntheticNamespaces.add(syntheticNamespace);
             }
         }
@@ -13185,7 +13203,7 @@ class Module {
         this.includeVariable(variable);
         const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
-            this.imports.add(variable);
+            this.includedImports.add(variable);
         }
     }
     shimMissingExport(name) {
@@ -14517,6 +14535,7 @@ class Chunk {
         this.implicitEntryModules = [];
         this.implicitlyLoadedBefore = new Set();
         this.imports = new Set();
+        this.includedReexportsByModule = new Map();
         this.indentString = undefined;
         // This may only be updated in the constructor
         this.isEmpty = true;
@@ -14688,6 +14707,9 @@ class Chunk {
                 this.exports.add(module.namespace);
             }
         }
+        if (!this.outputOptions.preserveModules) {
+            this.addNecessaryImportsForFacades();
+        }
         return facades;
     }
     generateId(addons, options, existingNames, includeHash) {
@@ -15030,6 +15052,15 @@ class Chunk {
             }
         }
     }
+    addNecessaryImportsForFacades() {
+        for (const [module, variables] of this.includedReexportsByModule) {
+            if (this.includedNamespaces.has(module)) {
+                for (const variable of variables) {
+                    this.imports.add(variable);
+                }
+            }
+        }
+    }
     assignFacadeName({ fileName, name }, facadedModule) {
         if (fileName) {
             this.fileName = fileName;
@@ -15077,6 +15108,7 @@ class Chunk {
         return hash.digest('hex').substr(0, 8);
     }
     ensureReexportsAreAvailableForModule(module) {
+        const includedReexports = [];
         const map = module.getExportNamesByVariable();
         for (const exportedVariable of map.keys()) {
             const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
@@ -15090,6 +15122,7 @@ class Chunk {
                     const chunk = this.chunkByModule.get(exportingModule);
                     if (chunk && chunk !== this) {
                         chunk.exports.add(importedVariable);
+                        includedReexports.push(importedVariable);
                         if (isSynthetic) {
                             this.imports.add(importedVariable);
                         }
@@ -15097,6 +15130,9 @@ class Chunk {
                 }
             }
         }
+        if (includedReexports.length) {
+            this.includedReexportsByModule.set(module, includedReexports);
+        }
     }
     finaliseDynamicImports(options, snippets) {
         const stripKnownJsExtensions = options.format === 'amd';
@@ -15452,7 +15488,7 @@ class Chunk {
         deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, this.outputOptions.preserveModules, this.outputOptions.externalLiveBindings, this.chunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
     }
     setUpChunkImportsAndExportsForModule(module) {
-        const moduleImports = new Set(module.imports);
+        const moduleImports = new Set(module.includedImports);
         // when we are not preserving modules, we need to make all namespace variables available for
         // rendering the namespace object
         if (!this.outputOptions.preserveModules) {
@@ -23119,6 +23155,12 @@ function formatAction([pluginName, hookName, args]) {
     }
     return action;
 }
+// We do not directly listen on process to avoid max listeners warnings for
+// complicated build processes
+const beforeExitEvent = 'beforeExit';
+const beforeExitEmitter = new require$$0$2.EventEmitter();
+beforeExitEmitter.setMaxListeners(0);
+process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
 async function catchUnfinishedHookActions(pluginDriver, callback) {
     let handleEmptyEventLoop;
     const emptyEventLoopPromise = new Promise((_, reject) => {
@@ -23127,10 +23169,10 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
             reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
                 [...unfulfilledActions].map(formatAction).join('\n')));
         };
-        process$1.once('beforeExit', handleEmptyEventLoop);
+        beforeExitEmitter.once(beforeExitEvent, handleEmptyEventLoop);
     });
     const result = await Promise.race([callback(), emptyEventLoopPromise]);
-    process$1.off('beforeExit', handleEmptyEventLoop);
+    beforeExitEmitter.off(beforeExitEvent, handleEmptyEventLoop);
     return result;
 }