rollup 2.75.2 → 2.75.5

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.75.2
-	Sun, 29 May 2022 13:58:04 GMT - commit a971f09f6c34c65e71470249783d0dcce02a9468
+	Rollup.js v2.75.5
+	Wed, 01 Jun 2022 12:43:56 GMT - commit 14dedb52b4d799deebd8b711c1e14759fc0213d9
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.75.2";
+var version$1 = "2.75.5";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -5335,6 +5335,11 @@ const INCLUDE_PARAMETERS = 'variables';
 class NodeBase extends ExpressionEntity {
     constructor(esTreeNode, parent, parentScope) {
         super();
+        // Nodes can apply custom deoptimizations once they become part of the
+        // executed code. To do this, they must initialize this as false, implement
+        // applyDeoptimizations and call this from include and hasEffects if they
+        // have custom handlers
+        this.deoptimized = false;
         this.esTreeNode = esTreeNode;
         this.keys = keys[esTreeNode.type] || getAndCreateKeys(esTreeNode);
         this.parent = parent;
@@ -5372,7 +5377,7 @@ class NodeBase extends ExpressionEntity {
         this.scope = parentScope;
     }
     hasEffects(context) {
-        if (this.deoptimized === false)
+        if (!this.deoptimized)
             this.applyDeoptimizations();
         for (const key of this.keys) {
             const value = this[key];
@@ -5390,7 +5395,7 @@ class NodeBase extends ExpressionEntity {
         return false;
     }
     include(context, includeChildrenRecursively, _options) {
-        if (this.deoptimized === false)
+        if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
         for (const key of this.keys) {
@@ -5489,10 +5494,6 @@ class NodeBase extends ExpressionEntity {
 }
 
 class SpreadElement extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
         if (path.length > 0) {
             this.argument.deoptimizeThisOnEventAtPath(event, [UnknownKey, ...path], thisParameter, recursionTracker);
@@ -6171,7 +6172,6 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
 class ArrayExpression extends NodeBase {
     constructor() {
         super(...arguments);
-        this.deoptimized = false;
         this.objectEntity = null;
     }
     deoptimizePath(path) {
@@ -6200,8 +6200,8 @@ class ArrayExpression extends NodeBase {
         let hasSpread = false;
         for (let index = 0; index < this.elements.length; index++) {
             const element = this.elements[index];
-            if (hasSpread || element instanceof SpreadElement) {
-                if (element) {
+            if (element) {
+                if (hasSpread || element instanceof SpreadElement) {
                     hasSpread = true;
                     element.deoptimizePath(UNKNOWN_PATH);
                 }
@@ -6643,629 +6643,87 @@ class ReturnValueScope extends ParameterScope {
     }
 }
 
-class AssignmentPattern extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
-    addExportedVariables(variables, exportNamesByVariable) {
-        this.left.addExportedVariables(variables, exportNamesByVariable);
-    }
-    declare(kind, init) {
-        return this.left.declare(kind, init);
-    }
-    deoptimizePath(path) {
-        path.length === 0 && this.left.deoptimizePath(path);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
-    }
-    // Note that FunctionBase may directly include .left and .right without
-    // including the pattern itself. This is how default parameter tree-shaking
-    // works at the moment.
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        this.left.include(context, includeChildrenRecursively);
-        this.right.include(context, includeChildrenRecursively);
-    }
-    markDeclarationReached() {
-        this.left.markDeclarationReached();
-    }
-    render(code, options, { isShorthandProperty } = BLANK) {
-        this.left.render(code, options, { isShorthandProperty });
-        if (this.right.included) {
-            this.right.render(code, options);
-        }
-        else {
-            code.remove(this.left.end, this.end);
-        }
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.left.deoptimizePath(EMPTY_PATH);
-        this.right.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
-}
+//@ts-check
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
 
-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);
-        }
-    }
-}
+/**
+ *
+ * @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);
+	}
 
-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;
+	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;
 }
-// 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);
-        }
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const PURE = {
+    hasEffectsWhenCalled() {
+        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];
+};
+const IMPURE = {
+    hasEffectsWhenCalled() {
+        return true;
     }
-    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);
-        }
-    }
-    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);
-        this.deoptimized = false;
-        this.declarationInit = null;
-    }
-    addExportedVariables(variables, exportNamesByVariable) {
-        this.argument.addExportedVariables(variables, exportNamesByVariable);
-    }
-    declare(kind, init) {
-        this.declarationInit = init;
-        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
-    }
-    deoptimizePath(path) {
-        path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
-    }
-    markDeclarationReached() {
-        this.argument.markDeclarationReached();
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.declarationInit !== null) {
-            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
-            this.context.requestTreeshakingPass();
-        }
-    }
-}
-
-class FunctionBase extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.objectEntity = null;
-        this.deoptimizedReturn = false;
-        this.forceIncludeParameters = false;
-    }
-    deoptimizeCache() {
-        this.forceIncludeParameters = true;
-    }
-    deoptimizePath(path) {
-        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.forceIncludeParameters = true;
-            this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-        }
-    }
-    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) {
-                this.deoptimizedReturn = true;
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-                this.context.requestTreeshakingPass();
-            }
-            return UNKNOWN_EXPRESSION;
-        }
-        return this.scope.getReturnExpression();
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        var _a;
-        if (path.length > 0) {
-            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
-        }
-        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 (let position = 0; position < this.params.length; position++) {
-            const parameter = this.params[position];
-            if (parameter instanceof AssignmentPattern) {
-                if (parameter.left.hasEffects(context)) {
-                    return true;
-                }
-                const argumentValue = (_a = callOptions.args[position]) === null || _a === void 0 ? void 0 : _a.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if ((argumentValue === undefined || argumentValue === UnknownValue) &&
-                    parameter.right.hasEffects(context)) {
-                    return true;
-                }
-            }
-            else if (parameter.hasEffects(context)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    include(context, includeChildrenRecursively, { includeWithoutParameterDefaults } = BLANK) {
-        this.included = true;
-        const { brokenFlow } = context;
-        context.brokenFlow = BROKEN_FLOW_NONE;
-        this.body.include(context, includeChildrenRecursively);
-        context.brokenFlow = brokenFlow;
-        if (!includeWithoutParameterDefaults ||
-            includeChildrenRecursively ||
-            this.forceIncludeParameters) {
-            for (const param of this.params) {
-                param.include(context, includeChildrenRecursively);
-            }
-        }
-    }
-    includeCallArguments(context, args) {
-        var _a;
-        for (let position = 0; position < this.params.length; position++) {
-            const parameter = this.params[position];
-            if (parameter instanceof AssignmentPattern) {
-                if (parameter.left.shouldBeIncluded(context)) {
-                    parameter.left.include(context, false);
-                }
-                const argumentValue = (_a = args[position]) === null || _a === void 0 ? void 0 : _a.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                // If argumentValue === UnknownTruthyValue, then we do not need to
-                // include the default
-                if ((argumentValue === undefined || argumentValue === UnknownValue) &&
-                    (this.parameterVariables[position].some(variable => variable.included) ||
-                        parameter.right.shouldBeIncluded(context))) {
-                    parameter.right.include(context, false);
-                }
-            }
-            else if (parameter.shouldBeIncluded(context)) {
-                parameter.include(context, false);
-            }
-        }
-        this.scope.includeCallArguments(context, args);
-    }
-    initialise() {
-        this.parameterVariables = this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION));
-        this.scope.addParameterVariables(this.parameterVariables, this.params[this.params.length - 1] instanceof RestElement);
-        if (this.body instanceof BlockStatement) {
-            this.body.addImplicitReturnExpressionToScope();
-        }
-        else {
-            this.scope.addReturnExpression(this.body);
-        }
-    }
-    parseNode(esTreeNode) {
-        if (esTreeNode.body.type === BlockStatement$1) {
-            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
-        }
-        super.parseNode(esTreeNode);
-    }
-}
-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;
-    }
-    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 &&
-        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
-        const variable = exportedVariables[0];
-        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
-    }
-    else {
-        const fields = [];
-        for (const variable of exportedVariables) {
-            for (const exportName of exportNamesByVariable.get(variable)) {
-                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
-            }
-        }
-        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
-    }
-}
-function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
-    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
-    code.appendLeft(expressionEnd, ')');
-}
-function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getDirectReturnIifeLeft } = options.snippets;
-    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
-    code.appendLeft(expressionEnd, ')');
-}
-function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getPropertyAccess } = options.snippets;
-    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
-    }
-}
-function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
-    const { _ } = options.snippets;
-    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
-    }
-}
-
-//@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 = {
-    hasEffectsWhenCalled() {
-        return false;
-    }
-};
-const IMPURE = {
-    hasEffectsWhenCalled() {
-        return true;
-    }
-};
-// 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));
+};
+// 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));
         }
     }
 };
@@ -8082,222 +7540,688 @@ 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];
+}
+
+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;
+    }
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        return getGlobalAtPath([this.name, ...path]) ? UnknownTruthyValue : UnknownValue;
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        if (path.length === 0) {
+            // Technically, "undefined" is a global variable of sorts
+            return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+        }
+        return !getGlobalAtPath([this.name, ...path].slice(0, -1));
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return !globalAtPath || globalAtPath.hasEffectsWhenCalled(callOptions, context);
+    }
+}
+
+const tdzVariableKinds = {
+    __proto__: null,
+    class: true,
+    const: true,
+    let: true,
+    var: true
+};
+class Identifier extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.isTDZAccess = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (!this.variable && 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) {
+        var _a;
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        // We keep conditional chaining because an unknown Node could have an
+        // Identifier as property that might be deoptimized by default
+        (_a = this.variable) === null || _a === void 0 ? void 0 : _a.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 (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsWhenAssignedAtPath(path, context);
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        return 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.variable.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 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;
         }
-        currentGlobal = currentGlobal[pathSegment];
-        if (!currentGlobal) {
-            return null;
+        else {
+            return super.addDeclaration(identifier, context, init, false);
         }
     }
-    return currentGlobal[ValueProperties];
 }
 
-class GlobalVariable extends Variable {
+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);
+    }
+    applyDeoptimizations() { }
+}
+
+class BlockStatement extends NodeBase {
     constructor() {
         super(...arguments);
-        // Ensure we use live-bindings for globals as we do not know if they have
-        // been reassigned
-        this.isReassigned = true;
+        this.directlyIncluded = false;
     }
-    getLiteralValueAtPath(path, _recursionTracker, _origin) {
-        return getGlobalAtPath([this.name, ...path]) ? UnknownTruthyValue : UnknownValue;
+    addImplicitReturnExpressionToScope() {
+        const lastStatement = this.body[this.body.length - 1];
+        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
+            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
+        }
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (path.length === 0) {
-            // Technically, "undefined" is a global variable of sorts
-            return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+    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 !getGlobalAtPath([this.name, ...path].slice(0, -1));
+        return false;
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        const globalAtPath = getGlobalAtPath([this.name, ...path]);
-        return !globalAtPath || globalAtPath.hasEffectsWhenCalled(callOptions, context);
+    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);
+        }
     }
 }
 
-const tdzVariableKinds = {
-    __proto__: null,
-    class: true,
-    const: true,
-    let: true,
-    var: true
-};
-class Identifier extends NodeBase {
+class RestElement extends NodeBase {
     constructor() {
         super(...arguments);
-        this.variable = null;
-        this.deoptimized = false;
-        this.isTDZAccess = null;
+        this.declarationInit = null;
     }
     addExportedVariables(variables, exportNamesByVariable) {
-        if (exportNamesByVariable.has(this.variable)) {
-            variables.push(this.variable);
-        }
-    }
-    bind() {
-        if (!this.variable && is_reference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-        }
+        this.argument.addExportedVariables(variables, exportNamesByVariable);
     }
     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}.`);
+        this.declarationInit = init;
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return path.length > 0 || this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
+    }
+    markDeclarationReached() {
+        this.argument.markDeclarationReached();
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.context.requestTreeshakingPass();
         }
-        variable.kind = kind;
-        return [(this.variable = variable)];
+    }
+}
+
+class FunctionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+        this.deoptimizedReturn = false;
     }
     deoptimizePath(path) {
-        if (path.length === 0 && !this.scope.contains(this.name)) {
-            this.disallowImportReassignment();
+        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);
         }
-        this.variable.deoptimizePath(path);
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        if (path.length > 0) {
+            this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+        return this.getObjectEntity().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;
+        if (path.length > 0) {
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
         }
-        return (this.context.options.treeshake.unknownGlobalSideEffects &&
-            this.variable instanceof GlobalVariable &&
-            this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
+        if (this.async) {
+            if (!this.deoptimizedReturn) {
+                this.deoptimizedReturn = true;
+                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+                this.context.requestTreeshakingPass();
+            }
+            return UNKNOWN_EXPRESSION;
+        }
+        return this.scope.getReturnExpression();
     }
     hasEffectsWhenAccessedAtPath(path, context) {
-        return (this.variable !== null &&
-            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
+        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsWhenAssignedAtPath(path, context);
+        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context);
+        if (path.length > 0) {
+            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+        }
+        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;
+        }
+        return false;
     }
-    include() {
+    include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.context.includeVariableInModule(this.variable);
-            }
-        }
+        this.included = true;
+        const { brokenFlow } = context;
+        context.brokenFlow = BROKEN_FLOW_NONE;
+        this.body.include(context, includeChildrenRecursively);
+        context.brokenFlow = brokenFlow;
     }
     includeCallArguments(context, args) {
-        this.variable.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);
+        this.scope.includeCallArguments(context, args);
+    }
+    initialise() {
+        this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
+        if (this.body instanceof BlockStatement) {
+            this.body.addImplicitReturnExpressionToScope();
         }
-        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);
+        else {
+            this.scope.addReturnExpression(this.body);
         }
-        if (!this.variable.initReached) {
-            // Either a const/let TDZ violation or
-            // var use before declaration was encountered.
-            return (this.isTDZAccess = true);
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.body.type === BlockStatement$1) {
+            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
         }
-        return (this.isTDZAccess = false);
+        super.parseNode(esTreeNode);
     }
-    markDeclarationReached() {
-        this.variable.initReached = true;
+    applyDeoptimizations() { }
+}
+FunctionBase.prototype.preventChildBlockScope = true;
+
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
     }
-    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, ');
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, this.context);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        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);
             }
         }
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.variable instanceof LocalVariable) {
-            this.variable.consolidateInitializers();
-            this.context.requestTreeshakingPass();
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
         }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
     }
-    disallowImportReassignment() {
-        return this.context.error({
-            code: 'ILLEGAL_REASSIGNMENT',
-            message: `Illegal reassignment to import '${this.name}'`
-        }, this.start);
+}
+
+function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
+    if (exportedVariables.length === 1 &&
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        const variable = exportedVariables[0];
+        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
     }
-    getVariableRespectingTDZ() {
-        if (this.isPossibleTDZ()) {
-            return UNKNOWN_EXPRESSION;
+    else {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
         }
-        return this.variable;
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
     }
 }
-function closestParentFunctionOrProgram(node) {
-    while (node && !/^Program|Function/.test(node.type)) {
-        node = node.parent;
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
+    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getDirectReturnIifeLeft } = options.snippets;
+    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getPropertyAccess } = options.snippets;
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const { _ } = options.snippets;
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
     }
-    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
-    return node;
 }
 
 class ObjectPattern extends NodeBase {
@@ -8342,10 +8266,6 @@ class ObjectPattern extends NodeBase {
 }
 
 class AssignmentExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -8426,6 +8346,46 @@ class AssignmentExpression extends NodeBase {
     }
 }
 
+class AssignmentPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        return this.left.declare(kind, init);
+    }
+    deoptimizePath(path) {
+        path.length === 0 && this.left.deoptimizePath(path);
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return path.length > 0 || this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.left.include(context, includeChildrenRecursively);
+        this.right.include(context, includeChildrenRecursively);
+    }
+    markDeclarationReached() {
+        this.left.markDeclarationReached();
+    }
+    render(code, options, { isShorthandProperty } = BLANK) {
+        this.left.render(code, options, { isShorthandProperty });
+        if (this.right.included) {
+            this.right.render(code, options);
+        }
+        else {
+            code.remove(this.left.end, this.end);
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.context.requestTreeshakingPass();
+    }
+}
+
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
         super('arguments', null, UNKNOWN_EXPRESSION, context);
@@ -8534,6 +8494,8 @@ class FunctionNode extends FunctionBase {
     }
     hasEffects() {
         var _a;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         return !!((_a = this.id) === null || _a === void 0 ? void 0 : _a.hasEffects());
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
@@ -8562,12 +8524,16 @@ class FunctionNode extends FunctionBase {
         context.ignore = ignore;
         return false;
     }
-    include(context, includeChildrenRecursively, { includeWithoutParameterDefaults } = BLANK) {
+    include(context, includeChildrenRecursively) {
         var _a;
+        super.include(context, includeChildrenRecursively);
         (_a = this.id) === null || _a === void 0 ? void 0 : _a.include();
-        super.include(context, includeChildrenRecursively, {
-            includeWithoutParameterDefaults: includeWithoutParameterDefaults && !this.scope.argumentsVariable.included
-        });
+        const hasArguments = this.scope.argumentsVariable.included;
+        for (const param of this.params) {
+            if (!(param instanceof Identifier) || hasArguments) {
+                param.include(context, includeChildrenRecursively);
+            }
+        }
     }
     initialise() {
         var _a;
@@ -8589,10 +8555,6 @@ class FunctionNode extends FunctionBase {
 }
 
 class AwaitExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     hasEffects() {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -8700,6 +8662,31 @@ class BreakStatement extends NodeBase {
     }
 }
 
+function renderCallArguments(code, options, node) {
+    if (node.arguments.length > 0) {
+        if (node.arguments[node.arguments.length - 1].included) {
+            for (const arg of node.arguments) {
+                arg.render(code, options);
+            }
+        }
+        else {
+            let lastIncludedIndex = node.arguments.length - 2;
+            while (lastIncludedIndex >= 0 && !node.arguments[lastIncludedIndex].included) {
+                lastIncludedIndex--;
+            }
+            if (lastIncludedIndex >= 0) {
+                for (let index = 0; index <= lastIncludedIndex; index++) {
+                    node.arguments[index].render(code, options);
+                }
+                code.remove(findFirstOccurrenceOutsideComment(code.original, ',', node.arguments[lastIncludedIndex].end), node.end - 1);
+            }
+            else {
+                code.remove(findFirstOccurrenceOutsideComment(code.original, '(', node.callee.end) + 1, node.end - 1);
+            }
+        }
+    }
+}
+
 class Literal extends NodeBase {
     deoptimizeThisOnEventAtPath() { }
     getLiteralValueAtPath(path) {
@@ -8786,7 +8773,6 @@ class MemberExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.variable = null;
-        this.deoptimized = false;
         this.bound = false;
         this.expressionsToBeDeoptimized = [];
         this.replacement = null;
@@ -9036,7 +9022,6 @@ class MemberExpression extends NodeBase {
 class CallExpressionBase extends NodeBase {
     constructor() {
         super(...arguments);
-        this.deoptimized = false;
         this.returnExpression = null;
         this.deoptimizableDependentExpressions = [];
         this.expressionsToBeDeoptimized = new Set();
@@ -9165,7 +9150,7 @@ class CallExpression extends CallExpressionBase {
         }
         else {
             this.included = true;
-            this.callee.include(context, false, { includeWithoutParameterDefaults: true });
+            this.callee.include(context, false);
         }
         this.callee.includeCallArguments(context, this.arguments);
         const returnExpression = this.getReturnExpression();
@@ -9178,28 +9163,7 @@ class CallExpression extends CallExpressionBase {
             isCalleeOfRenderedParent: true,
             renderedSurroundingElement
         });
-        if (this.arguments.length > 0) {
-            if (this.arguments[this.arguments.length - 1].included) {
-                for (const arg of this.arguments) {
-                    arg.render(code, options);
-                }
-            }
-            else {
-                let lastIncludedIndex = this.arguments.length - 2;
-                while (lastIncludedIndex >= 0 && !this.arguments[lastIncludedIndex].included) {
-                    lastIncludedIndex--;
-                }
-                if (lastIncludedIndex >= 0) {
-                    for (let index = 0; index <= lastIncludedIndex; index++) {
-                        this.arguments[index].render(code, options);
-                    }
-                    code.remove(findFirstOccurrenceOutsideComment(code.original, ',', this.arguments[lastIncludedIndex].end), this.end - 1);
-                }
-                else {
-                    code.remove(findFirstOccurrenceOutsideComment(code.original, '(', this.callee.end) + 1, this.end - 1);
-                }
-            }
-        }
+        renderCallArguments(code, options, this);
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -9287,6 +9251,7 @@ class ClassBody extends NodeBase {
         }
         super.parseNode(esTreeNode);
     }
+    applyDeoptimizations() { }
 }
 
 class MethodBase extends NodeBase {
@@ -9338,6 +9303,7 @@ class MethodBase extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getAccessedValue().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    applyDeoptimizations() { }
     getAccessedValue() {
         if (this.accessedValue === null) {
             if (this.kind === 'get') {
@@ -9353,6 +9319,7 @@ class MethodBase extends NodeBase {
 }
 
 class MethodDefinition extends MethodBase {
+    applyDeoptimizations() { }
 }
 
 class ObjectMember extends ExpressionEntity {
@@ -9387,7 +9354,6 @@ class ObjectMember extends ExpressionEntity {
 class ClassNode extends NodeBase {
     constructor() {
         super(...arguments);
-        this.deoptimized = false;
         this.objectEntity = null;
     }
     createScope(parentScope) {
@@ -9397,14 +9363,7 @@ class ClassNode extends NodeBase {
         this.getObjectEntity().deoptimizeAllProperties();
     }
     deoptimizePath(path) {
-        var _a, _b;
         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 constructor needs to be reassigned
-            (_a = this.classConstructor) === null || _a === void 0 ? void 0 : _a.deoptimizePath(UNKNOWN_PATH);
-            (_b = this.superClass) === null || _b === void 0 ? void 0 : _b.deoptimizePath(UNKNOWN_PATH);
-        }
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
         this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
@@ -9802,13 +9761,11 @@ class ExportAllDeclaration extends NodeBase {
     render(code, _options, nodeRenderOptions) {
         code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
     }
+    applyDeoptimizations() { }
 }
 ExportAllDeclaration.prototype.needsBoundaries = true;
 
 class FunctionDeclaration extends FunctionNode {
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively, { includeWithoutParameterDefaults: true });
-    }
     initialise() {
         super.initialise();
         if (this.id !== null) {
@@ -9879,6 +9836,7 @@ class ExportDefaultDeclaration extends NodeBase {
         }
         this.declaration.render(code, options);
     }
+    applyDeoptimizations() { }
     renderNamedDeclaration(code, declarationStart, declarationKeyword, endMarker, needsId, options) {
         const { exportNamesByVariable, format, snippets: { getPropertyAccess } } = options;
         const name = this.variable.getName(getPropertyAccess);
@@ -9933,17 +9891,15 @@ class ExportNamedDeclaration extends NodeBase {
             this.declaration.render(code, options, { end, start });
         }
     }
+    applyDeoptimizations() { }
 }
 ExportNamedDeclaration.prototype.needsBoundaries = true;
 
 class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
 
 class ForInStatement extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     createScope(parentScope) {
         this.scope = new BlockScope(parentScope);
     }
@@ -9992,10 +9948,6 @@ class ForInStatement extends NodeBase {
 }
 
 class ForOfStatement extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     createScope(parentScope) {
         this.scope = new BlockScope(parentScope);
     }
@@ -10190,6 +10142,7 @@ class IfStatement extends NodeBase {
         }
         this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
     }
+    applyDeoptimizations() { }
     getTestValue() {
         if (this.testValue === unset) {
             return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
@@ -10275,10 +10228,12 @@ class ImportDeclaration extends NodeBase {
     render(code, _options, nodeRenderOptions) {
         code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
     }
+    applyDeoptimizations() { }
 }
 ImportDeclaration.prototype.needsBoundaries = true;
 
 class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
 
 const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
@@ -10537,6 +10492,7 @@ class ImportExpression extends NodeBase {
     setInternalResolution(inlineNamespace) {
         this.inlineNamespace = inlineNamespace;
     }
+    applyDeoptimizations() { }
     getDynamicImportMechanismAndHelper(resolution, exportMode, { compact, dynamicImportFunction, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver) {
         const mechanism = pluginDriver.hookFirstSync('renderDynamicImport', [
             {
@@ -10645,9 +10601,11 @@ const accessedImportGlobals = {
 };
 
 class ImportNamespaceSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
 
 class ImportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
 }
 
 class LabeledStatement extends NodeBase {
@@ -10693,13 +10651,16 @@ class LogicalExpression extends NodeBase {
         this.usedBranch = null;
     }
     deoptimizeCache() {
-        if (this.usedBranch !== null) {
+        if (this.usedBranch) {
             const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
             for (const expression of this.expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
+            // Request another pass because we need to ensure "include" runs again if
+            // it is rendered
+            this.context.requestTreeshakingPass();
         }
     }
     deoptimizePath(path) {
@@ -10993,10 +10954,6 @@ const importMetaMechanisms = {
 };
 
 class NewExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     hasEffects(context) {
         try {
             for (const argument of this.arguments) {
@@ -11036,6 +10993,10 @@ class NewExpression extends NodeBase {
             withNew: true
         };
     }
+    render(code, options) {
+        this.callee.render(code, options);
+        renderCallArguments(code, options, this);
+    }
     applyDeoptimizations() {
         this.deoptimized = true;
         for (const argument of this.arguments) {
@@ -11083,6 +11044,7 @@ class ObjectExpression extends NodeBase {
             code.prependLeft(this.end, ')');
         }
     }
+    applyDeoptimizations() { }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -11159,12 +11121,12 @@ class Program extends NodeBase {
             super.render(code, options);
         }
     }
+    applyDeoptimizations() { }
 }
 
 class Property extends MethodBase {
     constructor() {
         super(...arguments);
-        this.deoptimized = false;
         this.declarationInit = null;
     }
     declare(kind, init) {
@@ -11230,6 +11192,7 @@ class PropertyDefinition extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return !this.value || this.value.hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    applyDeoptimizations() { }
 }
 
 class ReturnStatement extends NodeBase {
@@ -11826,10 +11789,6 @@ const unaryOperators = {
     '~': value => ~value
 };
 class UnaryExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (path.length > 0)
             return UnknownValue;
@@ -11872,10 +11831,6 @@ class UnknownNode extends NodeBase {
 }
 
 class UpdateExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -11977,6 +11932,7 @@ class VariableDeclaration extends NodeBase {
             this.renderReplacedDeclarations(code, options);
         }
     }
+    applyDeoptimizations() { }
     renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
         if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
             code.remove(this.end - 1, this.end);
@@ -12107,9 +12063,7 @@ class VariableDeclarator extends NodeBase {
     include(context, includeChildrenRecursively) {
         var _a;
         this.included = true;
-        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively, {
-            includeWithoutParameterDefaults: true
-        });
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         this.id.markDeclarationReached();
         if (includeChildrenRecursively || this.id.shouldBeIncluded(context)) {
             this.id.include(context, includeChildrenRecursively);
@@ -12133,6 +12087,7 @@ class VariableDeclarator extends NodeBase {
             code.appendLeft(this.end, `${_}=${_}void 0`);
         }
     }
+    applyDeoptimizations() { }
 }
 
 class WhileStatement extends NodeBase {
@@ -12159,15 +12114,11 @@ class WhileStatement extends NodeBase {
 }
 
 class YieldExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
     hasEffects(context) {
         var _a;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        return !context.ignore.returnYield || !!((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
+        return !(context.ignore.returnYield && !((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context)));
     }
     render(code, options) {
         if (this.argument) {