rollup 2.74.1 → 2.75.0

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.74.1
-	Thu, 19 May 2022 17:50:11 GMT - commit e823eded9920d6082cc8c1afcf591b716ab6b160
+	Rollup.js v2.75.0
+	Fri, 27 May 2022 08:24:10 GMT - commit c1d62262beb6e743a1b507aecad99cb03f446741
 
 	https://github.com/rollup/rollup
 
@@ -14,7 +14,7 @@ import { createHash as createHash$1 } from 'crypto';
 import { promises } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.74.1";
+var version$1 = "2.75.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1588,6 +1588,7 @@ class DiscriminatedPathTracker {
 }
 
 const UnknownValue = Symbol('Unknown Value');
+const UnknownTruthyValue = Symbol('Unknown Truthy Value');
 class ExpressionEntity {
     constructor() {
         this.included = false;
@@ -1616,7 +1617,7 @@ class ExpressionEntity {
     hasEffectsWhenCalledAtPath(_path, _callOptions, _context) {
         return true;
     }
-    include(_context, _includeChildrenRecursively) {
+    include(_context, _includeChildrenRecursively, _options) {
         this.included = true;
     }
     includeCallArguments(context, args) {
@@ -1624,6 +1625,9 @@ class ExpressionEntity {
             arg.include(context, false);
         }
     }
+    shouldBeIncluded(_context) {
+        return true;
+    }
 }
 const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
 })();
@@ -4665,9 +4669,9 @@ const stringReplace = {
         hasEffectsWhenCalled(callOptions, context) {
             const arg1 = callOptions.args[1];
             return (callOptions.args.length < 2 ||
-                (arg1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                (typeof arg1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
                     deoptimizeCache() { }
-                }) === UnknownValue &&
+                }) === 'symbol' &&
                     arg1.hasEffectsWhenCalledAtPath(EMPTY_PATH, {
                         args: NO_ARGS,
                         thisParam: null,
@@ -5222,8 +5226,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.bind();
+                    child === null || child === void 0 ? void 0 : child.bind();
                 }
             }
             else {
@@ -5246,7 +5249,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null && child.hasEffects(context))
+                    if (child === null || child === void 0 ? void 0 : child.hasEffects(context))
                         return true;
                 }
             }
@@ -5255,7 +5258,7 @@ class NodeBase extends ExpressionEntity {
         }
         return false;
     }
-    include(context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively, _options) {
         if (this.deoptimized === false)
             this.applyDeoptimizations();
         this.included = true;
@@ -5265,8 +5268,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.include(context, includeChildrenRecursively);
+                    child === null || child === void 0 ? void 0 : child.include(context, includeChildrenRecursively);
                 }
             }
             else {
@@ -5274,9 +5276,6 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
-    includeAsSingleStatement(context, includeChildrenRecursively) {
-        this.include(context, includeChildrenRecursively);
-    }
     /**
      * Override to perform special initialisation steps after the scope is initialised
      */
@@ -5323,8 +5322,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.render(code, options);
+                    child === null || child === void 0 ? void 0 : child.render(code, options);
                 }
             }
             else {
@@ -5335,7 +5333,28 @@ class NodeBase extends ExpressionEntity {
     shouldBeIncluded(context) {
         return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
     }
-    applyDeoptimizations() { }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const key of this.keys) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child === null || child === void 0 ? void 0 : child.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
 }
 
 class SpreadElement extends NodeBase {
@@ -5417,11 +5436,6 @@ class Method extends ExpressionEntity {
         }
         return false;
     }
-    includeCallArguments(context, args) {
-        for (const arg of args) {
-            arg.include(context, false);
-        }
-    }
 }
 const METHOD_RETURNS_BOOLEAN = [
     new Method({
@@ -5621,7 +5635,7 @@ class ObjectEntity extends ExpressionEntity {
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (path.length === 0) {
-            return UnknownValue;
+            return UnknownTruthyValue;
         }
         const key = path[0];
         const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
@@ -6026,6 +6040,7 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
 class ArrayExpression extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     deoptimizePath(path) {
@@ -6049,6 +6064,20 @@ class ArrayExpression extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (hasSpread || element instanceof SpreadElement) {
+                if (element) {
+                    hasSpread = true;
+                    element.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -6059,7 +6088,7 @@ class ArrayExpression extends NodeBase {
         let hasSpread = false;
         for (let index = 0; index < this.elements.length; index++) {
             const element = this.elements[index];
-            if (element instanceof SpreadElement || hasSpread) {
+            if (hasSpread || element instanceof SpreadElement) {
                 if (element) {
                     hasSpread = true;
                     properties.unshift({ key: UnknownInteger, kind: 'init', property: element });
@@ -6079,9 +6108,7 @@ class ArrayExpression extends NodeBase {
 class ArrayPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         for (const element of this.elements) {
-            if (element !== null) {
-                element.addExportedVariables(variables, exportNamesByVariable);
-            }
+            element === null || element === void 0 ? void 0 : element.addExportedVariables(variables, exportNamesByVariable);
         }
     }
     declare(kind) {
@@ -6093,29 +6120,23 @@ class ArrayPattern extends NodeBase {
         }
         return variables;
     }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            for (const element of this.elements) {
-                if (element !== null) {
-                    element.deoptimizePath(path);
-                }
-            }
+    // Patterns can only be deoptimized at the empty path at the moment
+    deoptimizePath() {
+        for (const element of this.elements) {
+            element === null || element === void 0 ? void 0 : element.deoptimizePath(EMPTY_PATH);
         }
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length > 0)
-            return true;
+    // Patterns are only checked at the emtpy path at the moment
+    hasEffectsWhenAssignedAtPath(_path, context) {
         for (const element of this.elements) {
-            if (element !== null && element.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
+            if (element === null || element === void 0 ? void 0 : element.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
                 return true;
         }
         return false;
     }
     markDeclarationReached() {
         for (const element of this.elements) {
-            if (element !== null) {
-                element.markDeclarationReached();
-            }
+            element === null || element === void 0 ? void 0 : element.markDeclarationReached();
         }
     }
 }
@@ -6491,1579 +6512,1661 @@ class ReturnValueScope extends ParameterScope {
     }
 }
 
-//@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;
+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();
+    }
 }
 
-/* eslint sort-keys: "off" */
-const ValueProperties = Symbol('Value Properties');
-const PURE = {
-    hasEffectsWhenCalled() {
-        return false;
+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;
+            }
+        }
     }
-};
-const IMPURE = {
-    hasEffectsWhenCalled() {
-        return true;
+}
+function removeAnnotations(node, code) {
+    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
+        node = node.parent;
     }
-};
-// 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));
+    if (node.annotations) {
+        for (const annotation of node.annotations) {
+            code.remove(annotation.start, annotation.end);
         }
     }
-};
-/* CONSTRUCTOR */
-const C = {
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    prototype: O
-};
-/* PURE CONSTRUCTOR */
-const PC = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    prototype: O
-};
-const ARRAY_TYPE = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    from: PF,
-    of: PF,
-    prototype: O
-};
-const INTL_MEMBER = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    supportedLocalesOf: PC
-};
-const knownGlobals = {
-    // Placeholders for global objects to avoid shape mutations
-    global: O,
-    globalThis: O,
-    self: O,
-    window: O,
-    // Common globals
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    Array: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        from: O,
-        isArray: PF,
-        of: PF,
-        prototype: O
-    },
-    ArrayBuffer: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        isView: PF,
-        prototype: O
-    },
-    Atomics: O,
-    BigInt: C,
-    BigInt64Array: C,
-    BigUint64Array: C,
-    Boolean: PC,
-    constructor: C,
-    DataView: PC,
-    Date: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        now: PF,
-        parse: PF,
-        prototype: O,
-        UTC: PF
-    },
-    decodeURI: PF,
-    decodeURIComponent: PF,
-    encodeURI: PF,
-    encodeURIComponent: PF,
-    Error: PC,
-    escape: PF,
-    eval: O,
-    EvalError: PC,
-    Float32Array: ARRAY_TYPE,
-    Float64Array: ARRAY_TYPE,
-    Function: C,
-    hasOwnProperty: O,
-    Infinity: O,
-    Int16Array: ARRAY_TYPE,
-    Int32Array: ARRAY_TYPE,
-    Int8Array: ARRAY_TYPE,
-    isFinite: PF,
-    isNaN: PF,
-    isPrototypeOf: O,
-    JSON: O,
-    Map: PC,
-    Math: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        abs: PF,
-        acos: PF,
-        acosh: PF,
-        asin: PF,
-        asinh: PF,
-        atan: PF,
-        atan2: PF,
-        atanh: PF,
-        cbrt: PF,
-        ceil: PF,
-        clz32: PF,
-        cos: PF,
-        cosh: PF,
-        exp: PF,
-        expm1: PF,
-        floor: PF,
-        fround: PF,
-        hypot: PF,
-        imul: PF,
-        log: PF,
-        log10: PF,
-        log1p: PF,
-        log2: PF,
-        max: PF,
-        min: PF,
-        pow: PF,
-        random: PF,
-        round: PF,
-        sign: PF,
-        sin: PF,
-        sinh: PF,
-        sqrt: PF,
-        tan: PF,
-        tanh: PF,
-        trunc: PF
-    },
-    NaN: O,
-    Number: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        isFinite: PF,
-        isInteger: PF,
-        isNaN: PF,
-        isSafeInteger: PF,
-        parseFloat: PF,
-        parseInt: PF,
-        prototype: O
-    },
-    Object: {
-        __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,
-        getPrototypeOf: PF,
-        hasOwn: PF,
-        is: PF,
-        isExtensible: PF,
-        isFrozen: PF,
-        isSealed: PF,
-        keys: PF,
-        fromEntries: PF,
-        entries: PF,
-        prototype: O
-    },
-    parseFloat: PF,
-    parseInt: PF,
-    Promise: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        all: O,
-        prototype: O,
-        race: O,
-        reject: O,
-        resolve: O
-    },
-    propertyIsEnumerable: O,
-    Proxy: O,
-    RangeError: PC,
-    ReferenceError: PC,
-    Reflect: O,
-    RegExp: PC,
-    Set: PC,
-    SharedArrayBuffer: C,
-    String: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        fromCharCode: PF,
-        fromCodePoint: PF,
-        prototype: O,
-        raw: PF
-    },
-    Symbol: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        for: PF,
-        keyFor: PF,
-        prototype: O
-    },
-    SyntaxError: PC,
-    toLocaleString: O,
-    toString: O,
-    TypeError: PC,
-    Uint16Array: ARRAY_TYPE,
-    Uint32Array: ARRAY_TYPE,
-    Uint8Array: ARRAY_TYPE,
-    Uint8ClampedArray: ARRAY_TYPE,
-    // Technically, this is a global, but it needs special handling
-    // undefined: ?,
-    unescape: PF,
-    URIError: PC,
-    valueOf: O,
-    WeakMap: PC,
-    WeakSet: PC,
-    // Additional globals shared by Node and Browser that are not strictly part of the language
-    clearInterval: C,
-    clearTimeout: C,
-    console: O,
-    Intl: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        Collator: INTL_MEMBER,
-        DateTimeFormat: INTL_MEMBER,
-        ListFormat: INTL_MEMBER,
-        NumberFormat: INTL_MEMBER,
-        PluralRules: INTL_MEMBER,
-        RelativeTimeFormat: INTL_MEMBER
-    },
-    setInterval: C,
-    setTimeout: C,
-    TextDecoder: C,
-    TextEncoder: C,
-    URL: C,
-    URLSearchParams: C,
-    // Browser specific globals
-    AbortController: C,
-    AbortSignal: C,
-    addEventListener: O,
-    alert: O,
-    AnalyserNode: C,
-    Animation: C,
-    AnimationEvent: C,
-    applicationCache: O,
-    ApplicationCache: C,
-    ApplicationCacheErrorEvent: C,
-    atob: O,
-    Attr: C,
-    Audio: C,
-    AudioBuffer: C,
-    AudioBufferSourceNode: C,
-    AudioContext: C,
-    AudioDestinationNode: C,
-    AudioListener: C,
-    AudioNode: C,
-    AudioParam: C,
-    AudioProcessingEvent: C,
-    AudioScheduledSourceNode: C,
-    AudioWorkletNode: C,
-    BarProp: C,
-    BaseAudioContext: C,
-    BatteryManager: C,
-    BeforeUnloadEvent: C,
-    BiquadFilterNode: C,
-    Blob: C,
-    BlobEvent: C,
-    blur: O,
-    BroadcastChannel: C,
-    btoa: O,
-    ByteLengthQueuingStrategy: C,
-    Cache: C,
-    caches: O,
-    CacheStorage: C,
-    cancelAnimationFrame: O,
-    cancelIdleCallback: O,
-    CanvasCaptureMediaStreamTrack: C,
-    CanvasGradient: C,
-    CanvasPattern: C,
-    CanvasRenderingContext2D: C,
-    ChannelMergerNode: C,
-    ChannelSplitterNode: C,
-    CharacterData: C,
-    clientInformation: O,
-    ClipboardEvent: C,
-    close: O,
-    closed: O,
-    CloseEvent: C,
-    Comment: C,
-    CompositionEvent: C,
-    confirm: O,
-    ConstantSourceNode: C,
-    ConvolverNode: C,
-    CountQueuingStrategy: C,
-    createImageBitmap: O,
-    Credential: C,
-    CredentialsContainer: C,
-    crypto: O,
-    Crypto: C,
-    CryptoKey: C,
-    CSS: C,
-    CSSConditionRule: C,
-    CSSFontFaceRule: C,
-    CSSGroupingRule: C,
-    CSSImportRule: C,
-    CSSKeyframeRule: C,
-    CSSKeyframesRule: C,
-    CSSMediaRule: C,
-    CSSNamespaceRule: C,
-    CSSPageRule: C,
-    CSSRule: C,
-    CSSRuleList: C,
-    CSSStyleDeclaration: C,
-    CSSStyleRule: C,
-    CSSStyleSheet: C,
-    CSSSupportsRule: C,
-    CustomElementRegistry: C,
-    customElements: O,
-    CustomEvent: C,
-    DataTransfer: C,
-    DataTransferItem: C,
-    DataTransferItemList: C,
-    defaultstatus: O,
-    defaultStatus: O,
-    DelayNode: C,
-    DeviceMotionEvent: C,
-    DeviceOrientationEvent: C,
-    devicePixelRatio: O,
-    dispatchEvent: O,
-    document: O,
-    Document: C,
-    DocumentFragment: C,
-    DocumentType: C,
-    DOMError: C,
-    DOMException: C,
-    DOMImplementation: C,
-    DOMMatrix: C,
-    DOMMatrixReadOnly: C,
-    DOMParser: C,
-    DOMPoint: C,
-    DOMPointReadOnly: C,
-    DOMQuad: C,
-    DOMRect: C,
-    DOMRectReadOnly: C,
-    DOMStringList: C,
-    DOMStringMap: C,
-    DOMTokenList: C,
-    DragEvent: C,
-    DynamicsCompressorNode: C,
-    Element: C,
-    ErrorEvent: C,
-    Event: C,
-    EventSource: C,
-    EventTarget: C,
-    external: O,
-    fetch: O,
-    File: C,
-    FileList: C,
-    FileReader: C,
-    find: O,
-    focus: O,
-    FocusEvent: C,
-    FontFace: C,
-    FontFaceSetLoadEvent: C,
-    FormData: C,
-    frames: O,
-    GainNode: C,
-    Gamepad: C,
-    GamepadButton: C,
-    GamepadEvent: C,
-    getComputedStyle: O,
-    getSelection: O,
-    HashChangeEvent: C,
-    Headers: C,
-    history: O,
-    History: C,
-    HTMLAllCollection: C,
-    HTMLAnchorElement: C,
-    HTMLAreaElement: C,
-    HTMLAudioElement: C,
-    HTMLBaseElement: C,
-    HTMLBodyElement: C,
-    HTMLBRElement: C,
-    HTMLButtonElement: C,
-    HTMLCanvasElement: C,
-    HTMLCollection: C,
-    HTMLContentElement: C,
-    HTMLDataElement: C,
-    HTMLDataListElement: C,
-    HTMLDetailsElement: C,
-    HTMLDialogElement: C,
-    HTMLDirectoryElement: C,
-    HTMLDivElement: C,
-    HTMLDListElement: C,
-    HTMLDocument: C,
-    HTMLElement: C,
-    HTMLEmbedElement: C,
-    HTMLFieldSetElement: C,
-    HTMLFontElement: C,
-    HTMLFormControlsCollection: C,
-    HTMLFormElement: C,
-    HTMLFrameElement: C,
-    HTMLFrameSetElement: C,
-    HTMLHeadElement: C,
-    HTMLHeadingElement: C,
-    HTMLHRElement: C,
-    HTMLHtmlElement: C,
-    HTMLIFrameElement: C,
-    HTMLImageElement: C,
-    HTMLInputElement: C,
-    HTMLLabelElement: C,
-    HTMLLegendElement: C,
-    HTMLLIElement: C,
-    HTMLLinkElement: C,
-    HTMLMapElement: C,
-    HTMLMarqueeElement: C,
-    HTMLMediaElement: C,
-    HTMLMenuElement: C,
-    HTMLMetaElement: C,
-    HTMLMeterElement: C,
-    HTMLModElement: C,
-    HTMLObjectElement: C,
-    HTMLOListElement: C,
-    HTMLOptGroupElement: C,
-    HTMLOptionElement: C,
-    HTMLOptionsCollection: C,
-    HTMLOutputElement: C,
-    HTMLParagraphElement: C,
-    HTMLParamElement: C,
-    HTMLPictureElement: C,
-    HTMLPreElement: C,
-    HTMLProgressElement: C,
-    HTMLQuoteElement: C,
-    HTMLScriptElement: C,
-    HTMLSelectElement: C,
-    HTMLShadowElement: C,
-    HTMLSlotElement: C,
-    HTMLSourceElement: C,
-    HTMLSpanElement: C,
-    HTMLStyleElement: C,
-    HTMLTableCaptionElement: C,
-    HTMLTableCellElement: C,
-    HTMLTableColElement: C,
-    HTMLTableElement: C,
-    HTMLTableRowElement: C,
-    HTMLTableSectionElement: C,
-    HTMLTemplateElement: C,
-    HTMLTextAreaElement: C,
-    HTMLTimeElement: C,
-    HTMLTitleElement: C,
-    HTMLTrackElement: C,
-    HTMLUListElement: C,
-    HTMLUnknownElement: C,
-    HTMLVideoElement: C,
-    IDBCursor: C,
-    IDBCursorWithValue: C,
-    IDBDatabase: C,
-    IDBFactory: C,
-    IDBIndex: C,
-    IDBKeyRange: C,
-    IDBObjectStore: C,
-    IDBOpenDBRequest: C,
-    IDBRequest: C,
-    IDBTransaction: C,
-    IDBVersionChangeEvent: C,
-    IdleDeadline: C,
-    IIRFilterNode: C,
-    Image: C,
-    ImageBitmap: C,
-    ImageBitmapRenderingContext: C,
-    ImageCapture: C,
-    ImageData: C,
-    indexedDB: O,
-    innerHeight: O,
-    innerWidth: O,
-    InputEvent: C,
-    IntersectionObserver: C,
-    IntersectionObserverEntry: C,
-    isSecureContext: O,
-    KeyboardEvent: C,
-    KeyframeEffect: C,
-    length: O,
-    localStorage: O,
-    location: O,
-    Location: C,
-    locationbar: O,
-    matchMedia: O,
-    MediaDeviceInfo: C,
-    MediaDevices: C,
-    MediaElementAudioSourceNode: C,
-    MediaEncryptedEvent: C,
-    MediaError: C,
-    MediaKeyMessageEvent: C,
-    MediaKeySession: C,
-    MediaKeyStatusMap: C,
-    MediaKeySystemAccess: C,
-    MediaList: C,
-    MediaQueryList: C,
-    MediaQueryListEvent: C,
-    MediaRecorder: C,
-    MediaSettingsRange: C,
-    MediaSource: C,
-    MediaStream: C,
-    MediaStreamAudioDestinationNode: C,
-    MediaStreamAudioSourceNode: C,
-    MediaStreamEvent: C,
-    MediaStreamTrack: C,
-    MediaStreamTrackEvent: C,
-    menubar: O,
-    MessageChannel: C,
-    MessageEvent: C,
-    MessagePort: C,
-    MIDIAccess: C,
-    MIDIConnectionEvent: C,
-    MIDIInput: C,
-    MIDIInputMap: C,
-    MIDIMessageEvent: C,
-    MIDIOutput: C,
-    MIDIOutputMap: C,
-    MIDIPort: C,
-    MimeType: C,
-    MimeTypeArray: C,
-    MouseEvent: C,
-    moveBy: O,
-    moveTo: O,
-    MutationEvent: C,
-    MutationObserver: C,
-    MutationRecord: C,
-    name: O,
-    NamedNodeMap: C,
-    NavigationPreloadManager: C,
-    navigator: O,
-    Navigator: C,
-    NetworkInformation: C,
-    Node: C,
-    NodeFilter: O,
-    NodeIterator: C,
-    NodeList: C,
-    Notification: C,
-    OfflineAudioCompletionEvent: C,
-    OfflineAudioContext: C,
-    offscreenBuffering: O,
-    OffscreenCanvas: C,
-    open: O,
-    openDatabase: O,
-    Option: C,
-    origin: O,
-    OscillatorNode: C,
-    outerHeight: O,
-    outerWidth: O,
-    PageTransitionEvent: C,
-    pageXOffset: O,
-    pageYOffset: O,
-    PannerNode: C,
-    parent: O,
-    Path2D: C,
-    PaymentAddress: C,
-    PaymentRequest: C,
-    PaymentRequestUpdateEvent: C,
-    PaymentResponse: C,
-    performance: O,
-    Performance: C,
-    PerformanceEntry: C,
-    PerformanceLongTaskTiming: C,
-    PerformanceMark: C,
-    PerformanceMeasure: C,
-    PerformanceNavigation: C,
-    PerformanceNavigationTiming: C,
-    PerformanceObserver: C,
-    PerformanceObserverEntryList: C,
-    PerformancePaintTiming: C,
-    PerformanceResourceTiming: C,
-    PerformanceTiming: C,
-    PeriodicWave: C,
-    Permissions: C,
-    PermissionStatus: C,
-    personalbar: O,
-    PhotoCapabilities: C,
-    Plugin: C,
-    PluginArray: C,
-    PointerEvent: C,
-    PopStateEvent: C,
-    postMessage: O,
-    Presentation: C,
-    PresentationAvailability: C,
-    PresentationConnection: C,
-    PresentationConnectionAvailableEvent: C,
-    PresentationConnectionCloseEvent: C,
-    PresentationConnectionList: C,
-    PresentationReceiver: C,
-    PresentationRequest: C,
-    print: O,
-    ProcessingInstruction: C,
-    ProgressEvent: C,
-    PromiseRejectionEvent: C,
-    prompt: O,
-    PushManager: C,
-    PushSubscription: C,
-    PushSubscriptionOptions: C,
-    queueMicrotask: O,
-    RadioNodeList: C,
-    Range: C,
-    ReadableStream: C,
-    RemotePlayback: C,
-    removeEventListener: O,
-    Request: C,
-    requestAnimationFrame: O,
-    requestIdleCallback: O,
-    resizeBy: O,
-    ResizeObserver: C,
-    ResizeObserverEntry: C,
-    resizeTo: O,
-    Response: C,
-    RTCCertificate: C,
-    RTCDataChannel: C,
-    RTCDataChannelEvent: C,
-    RTCDtlsTransport: C,
-    RTCIceCandidate: C,
-    RTCIceTransport: C,
-    RTCPeerConnection: C,
-    RTCPeerConnectionIceEvent: C,
-    RTCRtpReceiver: C,
-    RTCRtpSender: C,
-    RTCSctpTransport: C,
-    RTCSessionDescription: C,
-    RTCStatsReport: C,
-    RTCTrackEvent: C,
-    screen: O,
-    Screen: C,
-    screenLeft: O,
-    ScreenOrientation: C,
-    screenTop: O,
-    screenX: O,
-    screenY: O,
-    ScriptProcessorNode: C,
-    scroll: O,
-    scrollbars: O,
-    scrollBy: O,
-    scrollTo: O,
-    scrollX: O,
-    scrollY: O,
-    SecurityPolicyViolationEvent: C,
-    Selection: C,
-    ServiceWorker: C,
-    ServiceWorkerContainer: C,
-    ServiceWorkerRegistration: C,
-    sessionStorage: O,
-    ShadowRoot: C,
-    SharedWorker: C,
-    SourceBuffer: C,
-    SourceBufferList: C,
-    speechSynthesis: O,
-    SpeechSynthesisEvent: C,
-    SpeechSynthesisUtterance: C,
-    StaticRange: C,
-    status: O,
-    statusbar: O,
-    StereoPannerNode: C,
-    stop: O,
-    Storage: C,
-    StorageEvent: C,
-    StorageManager: C,
-    styleMedia: O,
-    StyleSheet: C,
-    StyleSheetList: C,
-    SubtleCrypto: C,
-    SVGAElement: C,
-    SVGAngle: C,
-    SVGAnimatedAngle: C,
-    SVGAnimatedBoolean: C,
-    SVGAnimatedEnumeration: C,
-    SVGAnimatedInteger: C,
-    SVGAnimatedLength: C,
-    SVGAnimatedLengthList: C,
-    SVGAnimatedNumber: C,
-    SVGAnimatedNumberList: C,
-    SVGAnimatedPreserveAspectRatio: C,
-    SVGAnimatedRect: C,
-    SVGAnimatedString: C,
-    SVGAnimatedTransformList: C,
-    SVGAnimateElement: C,
-    SVGAnimateMotionElement: C,
-    SVGAnimateTransformElement: C,
-    SVGAnimationElement: C,
-    SVGCircleElement: C,
-    SVGClipPathElement: C,
-    SVGComponentTransferFunctionElement: C,
-    SVGDefsElement: C,
-    SVGDescElement: C,
-    SVGDiscardElement: C,
-    SVGElement: C,
-    SVGEllipseElement: C,
-    SVGFEBlendElement: C,
-    SVGFEColorMatrixElement: C,
-    SVGFEComponentTransferElement: C,
-    SVGFECompositeElement: C,
-    SVGFEConvolveMatrixElement: C,
-    SVGFEDiffuseLightingElement: C,
-    SVGFEDisplacementMapElement: C,
-    SVGFEDistantLightElement: C,
-    SVGFEDropShadowElement: C,
-    SVGFEFloodElement: C,
-    SVGFEFuncAElement: C,
-    SVGFEFuncBElement: C,
-    SVGFEFuncGElement: C,
-    SVGFEFuncRElement: C,
-    SVGFEGaussianBlurElement: C,
-    SVGFEImageElement: C,
-    SVGFEMergeElement: C,
-    SVGFEMergeNodeElement: C,
-    SVGFEMorphologyElement: C,
-    SVGFEOffsetElement: C,
-    SVGFEPointLightElement: C,
-    SVGFESpecularLightingElement: C,
-    SVGFESpotLightElement: C,
-    SVGFETileElement: C,
-    SVGFETurbulenceElement: C,
-    SVGFilterElement: C,
-    SVGForeignObjectElement: C,
-    SVGGElement: C,
-    SVGGeometryElement: C,
-    SVGGradientElement: C,
-    SVGGraphicsElement: C,
-    SVGImageElement: C,
-    SVGLength: C,
-    SVGLengthList: C,
-    SVGLinearGradientElement: C,
-    SVGLineElement: C,
-    SVGMarkerElement: C,
-    SVGMaskElement: C,
-    SVGMatrix: C,
-    SVGMetadataElement: C,
-    SVGMPathElement: C,
-    SVGNumber: C,
-    SVGNumberList: C,
-    SVGPathElement: C,
-    SVGPatternElement: C,
-    SVGPoint: C,
-    SVGPointList: C,
-    SVGPolygonElement: C,
-    SVGPolylineElement: C,
-    SVGPreserveAspectRatio: C,
-    SVGRadialGradientElement: C,
-    SVGRect: C,
-    SVGRectElement: C,
-    SVGScriptElement: C,
-    SVGSetElement: C,
-    SVGStopElement: C,
-    SVGStringList: C,
-    SVGStyleElement: C,
-    SVGSVGElement: C,
-    SVGSwitchElement: C,
-    SVGSymbolElement: C,
-    SVGTextContentElement: C,
-    SVGTextElement: C,
-    SVGTextPathElement: C,
-    SVGTextPositioningElement: C,
-    SVGTitleElement: C,
-    SVGTransform: C,
-    SVGTransformList: C,
-    SVGTSpanElement: C,
-    SVGUnitTypes: C,
-    SVGUseElement: C,
-    SVGViewElement: C,
-    TaskAttributionTiming: C,
-    Text: C,
-    TextEvent: C,
-    TextMetrics: C,
-    TextTrack: C,
-    TextTrackCue: C,
-    TextTrackCueList: C,
-    TextTrackList: C,
-    TimeRanges: C,
-    toolbar: O,
-    top: O,
-    Touch: C,
-    TouchEvent: C,
-    TouchList: C,
-    TrackEvent: C,
-    TransitionEvent: C,
-    TreeWalker: C,
-    UIEvent: C,
-    ValidityState: C,
-    visualViewport: O,
-    VisualViewport: C,
-    VTTCue: C,
-    WaveShaperNode: C,
-    WebAssembly: O,
-    WebGL2RenderingContext: C,
-    WebGLActiveInfo: C,
-    WebGLBuffer: C,
-    WebGLContextEvent: C,
-    WebGLFramebuffer: C,
-    WebGLProgram: C,
-    WebGLQuery: C,
-    WebGLRenderbuffer: C,
-    WebGLRenderingContext: C,
-    WebGLSampler: C,
-    WebGLShader: C,
-    WebGLShaderPrecisionFormat: C,
-    WebGLSync: C,
-    WebGLTexture: C,
-    WebGLTransformFeedback: C,
-    WebGLUniformLocation: C,
-    WebGLVertexArrayObject: C,
-    WebSocket: C,
-    WheelEvent: C,
-    Window: C,
-    Worker: C,
-    WritableStream: C,
-    XMLDocument: C,
-    XMLHttpRequest: C,
-    XMLHttpRequestEventTarget: C,
-    XMLHttpRequestUpload: C,
-    XMLSerializer: C,
-    XPathEvaluator: C,
-    XPathExpression: C,
-    XPathResult: C,
-    XSLTProcessor: C
-};
-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;
+
+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);
         }
-        currentGlobal = currentGlobal[pathSegment];
-        if (!currentGlobal) {
-            return null;
+    }
+}
+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);
+        }
+    }
+    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);
+            }
         }
     }
-    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;
+    initialise() {
+        const firstBodyStatement = this.body[0];
+        this.deoptimizeBody =
+            firstBodyStatement instanceof ExpressionStatement &&
+                firstBodyStatement.directive === 'use asm';
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (path.length === 0) {
-            // Technically, "undefined" is a global variable of sorts
-            return this.name !== 'undefined' && getGlobalAtPath([this.name]) === null;
+    render(code, options) {
+        if (this.body.length) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
         }
-        return getGlobalAtPath([this.name, ...path].slice(0, -1)) === null;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        const globalAtPath = getGlobalAtPath([this.name, ...path]);
-        return globalAtPath === null || globalAtPath.hasEffectsWhenCalled(callOptions, context);
     }
 }
 
-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 (this.variable !== null && exportNamesByVariable.has(this.variable)) {
-            variables.push(this.variable);
-        }
-    }
-    bind() {
-        if (this.variable === null && is_reference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-        }
+        this.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;
+        this.forceIncludeParameters = false;
+    }
+    deoptimizeCache() {
+        this.forceIncludeParameters = true;
     }
     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.forceIncludeParameters = true;
+            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 (!this.variable ||
-            (path.length > 0
-                ? this.getVariableRespectingTDZ()
-                : this.variable).hasEffectsWhenAssignedAtPath(path, context));
+        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return (!this.variable ||
-            this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context));
-    }
-    include() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.context.includeVariableInModule(this.variable);
-            }
-        }
-    }
-    includeCallArguments(context, args) {
-        this.getVariableRespectingTDZ().includeCallArguments(context, args);
-    }
-    isPossibleTDZ() {
-        // return cached value to avoid issues with the next tree-shaking pass
-        if (this.isTDZAccess !== null)
-            return this.isTDZAccess;
-        if (!(this.variable instanceof LocalVariable) ||
-            !this.variable.kind ||
-            !(this.variable.kind in tdzVariableKinds)) {
-            return (this.isTDZAccess = false);
-        }
-        let decl_id;
-        if (this.variable.declarations &&
-            this.variable.declarations.length === 1 &&
-            (decl_id = this.variable.declarations[0]) &&
-            this.start < decl_id.start &&
-            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
-            // a variable accessed before its declaration
-            // in the same function or at top level of module
-            return (this.isTDZAccess = true);
+        var _a;
+        if (path.length > 0) {
+            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
         }
-        if (!this.variable.initReached) {
-            // Either a const/let TDZ violation or
-            // var use before declaration was encountered.
-            return (this.isTDZAccess = 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;
+            }
         }
-        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}: `);
+        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;
                 }
             }
-            // 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, ');
+            else if (parameter.hasEffects(context)) {
+                return true;
             }
         }
+        return false;
     }
-    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);
+    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);
             }
-            else {
-                return;
+        }
+    }
+    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);
     }
-}
-function removeAnnotations(node, code) {
-    if (!node.annotations && node.parent.type === ExpressionStatement$1) {
-        node = node.parent;
+    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);
+        }
     }
-    if (node.annotations) {
-        for (const annotation of node.annotations) {
-            code.remove(annotation.start, annotation.end);
+    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;
 
-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);
-        }
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
     }
-}
-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);
+    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 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];
+
+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})`;
     }
-    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 {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
             }
         }
-        else {
-            currentNode.render(code, options);
-        }
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
     }
 }
-// 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;
+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, ')');
     }
-    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;
+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));
         }
-        code.remove(start + removeStart, (start += removeEnd));
     }
+};
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
+};
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
+};
+const ARRAY_TYPE = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    from: PF,
+    of: PF,
+    prototype: O
+};
+const INTL_MEMBER = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    supportedLocalesOf: PC
+};
+const knownGlobals = {
+    // Placeholders for global objects to avoid shape mutations
+    global: O,
+    globalThis: O,
+    self: O,
+    window: O,
+    // Common globals
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    Array: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        from: O,
+        isArray: PF,
+        of: PF,
+        prototype: O
+    },
+    ArrayBuffer: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isView: PF,
+        prototype: O
+    },
+    Atomics: O,
+    BigInt: C,
+    BigInt64Array: C,
+    BigUint64Array: C,
+    Boolean: PC,
+    constructor: C,
+    DataView: PC,
+    Date: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        now: PF,
+        parse: PF,
+        prototype: O,
+        UTC: PF
+    },
+    decodeURI: PF,
+    decodeURIComponent: PF,
+    encodeURI: PF,
+    encodeURIComponent: PF,
+    Error: PC,
+    escape: PF,
+    eval: O,
+    EvalError: PC,
+    Float32Array: ARRAY_TYPE,
+    Float64Array: ARRAY_TYPE,
+    Function: C,
+    hasOwnProperty: O,
+    Infinity: O,
+    Int16Array: ARRAY_TYPE,
+    Int32Array: ARRAY_TYPE,
+    Int8Array: ARRAY_TYPE,
+    isFinite: PF,
+    isNaN: PF,
+    isPrototypeOf: O,
+    JSON: O,
+    Map: PC,
+    Math: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        abs: PF,
+        acos: PF,
+        acosh: PF,
+        asin: PF,
+        asinh: PF,
+        atan: PF,
+        atan2: PF,
+        atanh: PF,
+        cbrt: PF,
+        ceil: PF,
+        clz32: PF,
+        cos: PF,
+        cosh: PF,
+        exp: PF,
+        expm1: PF,
+        floor: PF,
+        fround: PF,
+        hypot: PF,
+        imul: PF,
+        log: PF,
+        log10: PF,
+        log1p: PF,
+        log2: PF,
+        max: PF,
+        min: PF,
+        pow: PF,
+        random: PF,
+        round: PF,
+        sign: PF,
+        sin: PF,
+        sinh: PF,
+        sqrt: PF,
+        tan: PF,
+        tanh: PF,
+        trunc: PF
+    },
+    NaN: O,
+    Number: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isFinite: PF,
+        isInteger: PF,
+        isNaN: PF,
+        isSafeInteger: PF,
+        parseFloat: PF,
+        parseInt: PF,
+        prototype: O
+    },
+    Object: {
+        __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,
+        getPrototypeOf: PF,
+        hasOwn: PF,
+        is: PF,
+        isExtensible: PF,
+        isFrozen: PF,
+        isSealed: PF,
+        keys: PF,
+        fromEntries: PF,
+        entries: PF,
+        prototype: O
+    },
+    parseFloat: PF,
+    parseInt: PF,
+    Promise: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        all: O,
+        prototype: O,
+        race: O,
+        reject: O,
+        resolve: O
+    },
+    propertyIsEnumerable: O,
+    Proxy: O,
+    RangeError: PC,
+    ReferenceError: PC,
+    Reflect: O,
+    RegExp: PC,
+    Set: PC,
+    SharedArrayBuffer: C,
+    String: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        fromCharCode: PF,
+        fromCodePoint: PF,
+        prototype: O,
+        raw: PF
+    },
+    Symbol: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        for: PF,
+        keyFor: PF,
+        prototype: O
+    },
+    SyntaxError: PC,
+    toLocaleString: O,
+    toString: O,
+    TypeError: PC,
+    Uint16Array: ARRAY_TYPE,
+    Uint32Array: ARRAY_TYPE,
+    Uint8Array: ARRAY_TYPE,
+    Uint8ClampedArray: ARRAY_TYPE,
+    // Technically, this is a global, but it needs special handling
+    // undefined: ?,
+    unescape: PF,
+    URIError: PC,
+    valueOf: O,
+    WeakMap: PC,
+    WeakSet: PC,
+    // Additional globals shared by Node and Browser that are not strictly part of the language
+    clearInterval: C,
+    clearTimeout: C,
+    console: O,
+    Intl: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        Collator: INTL_MEMBER,
+        DateTimeFormat: INTL_MEMBER,
+        ListFormat: INTL_MEMBER,
+        NumberFormat: INTL_MEMBER,
+        PluralRules: INTL_MEMBER,
+        RelativeTimeFormat: INTL_MEMBER
+    },
+    setInterval: C,
+    setTimeout: C,
+    TextDecoder: C,
+    TextEncoder: C,
+    URL: C,
+    URLSearchParams: C,
+    // Browser specific globals
+    AbortController: C,
+    AbortSignal: C,
+    addEventListener: O,
+    alert: O,
+    AnalyserNode: C,
+    Animation: C,
+    AnimationEvent: C,
+    applicationCache: O,
+    ApplicationCache: C,
+    ApplicationCacheErrorEvent: C,
+    atob: O,
+    Attr: C,
+    Audio: C,
+    AudioBuffer: C,
+    AudioBufferSourceNode: C,
+    AudioContext: C,
+    AudioDestinationNode: C,
+    AudioListener: C,
+    AudioNode: C,
+    AudioParam: C,
+    AudioProcessingEvent: C,
+    AudioScheduledSourceNode: C,
+    AudioWorkletNode: C,
+    BarProp: C,
+    BaseAudioContext: C,
+    BatteryManager: C,
+    BeforeUnloadEvent: C,
+    BiquadFilterNode: C,
+    Blob: C,
+    BlobEvent: C,
+    blur: O,
+    BroadcastChannel: C,
+    btoa: O,
+    ByteLengthQueuingStrategy: C,
+    Cache: C,
+    caches: O,
+    CacheStorage: C,
+    cancelAnimationFrame: O,
+    cancelIdleCallback: O,
+    CanvasCaptureMediaStreamTrack: C,
+    CanvasGradient: C,
+    CanvasPattern: C,
+    CanvasRenderingContext2D: C,
+    ChannelMergerNode: C,
+    ChannelSplitterNode: C,
+    CharacterData: C,
+    clientInformation: O,
+    ClipboardEvent: C,
+    close: O,
+    closed: O,
+    CloseEvent: C,
+    Comment: C,
+    CompositionEvent: C,
+    confirm: O,
+    ConstantSourceNode: C,
+    ConvolverNode: C,
+    CountQueuingStrategy: C,
+    createImageBitmap: O,
+    Credential: C,
+    CredentialsContainer: C,
+    crypto: O,
+    Crypto: C,
+    CryptoKey: C,
+    CSS: C,
+    CSSConditionRule: C,
+    CSSFontFaceRule: C,
+    CSSGroupingRule: C,
+    CSSImportRule: C,
+    CSSKeyframeRule: C,
+    CSSKeyframesRule: C,
+    CSSMediaRule: C,
+    CSSNamespaceRule: C,
+    CSSPageRule: C,
+    CSSRule: C,
+    CSSRuleList: C,
+    CSSStyleDeclaration: C,
+    CSSStyleRule: C,
+    CSSStyleSheet: C,
+    CSSSupportsRule: C,
+    CustomElementRegistry: C,
+    customElements: O,
+    CustomEvent: C,
+    DataTransfer: C,
+    DataTransferItem: C,
+    DataTransferItemList: C,
+    defaultstatus: O,
+    defaultStatus: O,
+    DelayNode: C,
+    DeviceMotionEvent: C,
+    DeviceOrientationEvent: C,
+    devicePixelRatio: O,
+    dispatchEvent: O,
+    document: O,
+    Document: C,
+    DocumentFragment: C,
+    DocumentType: C,
+    DOMError: C,
+    DOMException: C,
+    DOMImplementation: C,
+    DOMMatrix: C,
+    DOMMatrixReadOnly: C,
+    DOMParser: C,
+    DOMPoint: C,
+    DOMPointReadOnly: C,
+    DOMQuad: C,
+    DOMRect: C,
+    DOMRectReadOnly: C,
+    DOMStringList: C,
+    DOMStringMap: C,
+    DOMTokenList: C,
+    DragEvent: C,
+    DynamicsCompressorNode: C,
+    Element: C,
+    ErrorEvent: C,
+    Event: C,
+    EventSource: C,
+    EventTarget: C,
+    external: O,
+    fetch: O,
+    File: C,
+    FileList: C,
+    FileReader: C,
+    find: O,
+    focus: O,
+    FocusEvent: C,
+    FontFace: C,
+    FontFaceSetLoadEvent: C,
+    FormData: C,
+    frames: O,
+    GainNode: C,
+    Gamepad: C,
+    GamepadButton: C,
+    GamepadEvent: C,
+    getComputedStyle: O,
+    getSelection: O,
+    HashChangeEvent: C,
+    Headers: C,
+    history: O,
+    History: C,
+    HTMLAllCollection: C,
+    HTMLAnchorElement: C,
+    HTMLAreaElement: C,
+    HTMLAudioElement: C,
+    HTMLBaseElement: C,
+    HTMLBodyElement: C,
+    HTMLBRElement: C,
+    HTMLButtonElement: C,
+    HTMLCanvasElement: C,
+    HTMLCollection: C,
+    HTMLContentElement: C,
+    HTMLDataElement: C,
+    HTMLDataListElement: C,
+    HTMLDetailsElement: C,
+    HTMLDialogElement: C,
+    HTMLDirectoryElement: C,
+    HTMLDivElement: C,
+    HTMLDListElement: C,
+    HTMLDocument: C,
+    HTMLElement: C,
+    HTMLEmbedElement: C,
+    HTMLFieldSetElement: C,
+    HTMLFontElement: C,
+    HTMLFormControlsCollection: C,
+    HTMLFormElement: C,
+    HTMLFrameElement: C,
+    HTMLFrameSetElement: C,
+    HTMLHeadElement: C,
+    HTMLHeadingElement: C,
+    HTMLHRElement: C,
+    HTMLHtmlElement: C,
+    HTMLIFrameElement: C,
+    HTMLImageElement: C,
+    HTMLInputElement: C,
+    HTMLLabelElement: C,
+    HTMLLegendElement: C,
+    HTMLLIElement: C,
+    HTMLLinkElement: C,
+    HTMLMapElement: C,
+    HTMLMarqueeElement: C,
+    HTMLMediaElement: C,
+    HTMLMenuElement: C,
+    HTMLMetaElement: C,
+    HTMLMeterElement: C,
+    HTMLModElement: C,
+    HTMLObjectElement: C,
+    HTMLOListElement: C,
+    HTMLOptGroupElement: C,
+    HTMLOptionElement: C,
+    HTMLOptionsCollection: C,
+    HTMLOutputElement: C,
+    HTMLParagraphElement: C,
+    HTMLParamElement: C,
+    HTMLPictureElement: C,
+    HTMLPreElement: C,
+    HTMLProgressElement: C,
+    HTMLQuoteElement: C,
+    HTMLScriptElement: C,
+    HTMLSelectElement: C,
+    HTMLShadowElement: C,
+    HTMLSlotElement: C,
+    HTMLSourceElement: C,
+    HTMLSpanElement: C,
+    HTMLStyleElement: C,
+    HTMLTableCaptionElement: C,
+    HTMLTableCellElement: C,
+    HTMLTableColElement: C,
+    HTMLTableElement: C,
+    HTMLTableRowElement: C,
+    HTMLTableSectionElement: C,
+    HTMLTemplateElement: C,
+    HTMLTextAreaElement: C,
+    HTMLTimeElement: C,
+    HTMLTitleElement: C,
+    HTMLTrackElement: C,
+    HTMLUListElement: C,
+    HTMLUnknownElement: C,
+    HTMLVideoElement: C,
+    IDBCursor: C,
+    IDBCursorWithValue: C,
+    IDBDatabase: C,
+    IDBFactory: C,
+    IDBIndex: C,
+    IDBKeyRange: C,
+    IDBObjectStore: C,
+    IDBOpenDBRequest: C,
+    IDBRequest: C,
+    IDBTransaction: C,
+    IDBVersionChangeEvent: C,
+    IdleDeadline: C,
+    IIRFilterNode: C,
+    Image: C,
+    ImageBitmap: C,
+    ImageBitmapRenderingContext: C,
+    ImageCapture: C,
+    ImageData: C,
+    indexedDB: O,
+    innerHeight: O,
+    innerWidth: O,
+    InputEvent: C,
+    IntersectionObserver: C,
+    IntersectionObserverEntry: C,
+    isSecureContext: O,
+    KeyboardEvent: C,
+    KeyframeEffect: C,
+    length: O,
+    localStorage: O,
+    location: O,
+    Location: C,
+    locationbar: O,
+    matchMedia: O,
+    MediaDeviceInfo: C,
+    MediaDevices: C,
+    MediaElementAudioSourceNode: C,
+    MediaEncryptedEvent: C,
+    MediaError: C,
+    MediaKeyMessageEvent: C,
+    MediaKeySession: C,
+    MediaKeyStatusMap: C,
+    MediaKeySystemAccess: C,
+    MediaList: C,
+    MediaQueryList: C,
+    MediaQueryListEvent: C,
+    MediaRecorder: C,
+    MediaSettingsRange: C,
+    MediaSource: C,
+    MediaStream: C,
+    MediaStreamAudioDestinationNode: C,
+    MediaStreamAudioSourceNode: C,
+    MediaStreamEvent: C,
+    MediaStreamTrack: C,
+    MediaStreamTrackEvent: C,
+    menubar: O,
+    MessageChannel: C,
+    MessageEvent: C,
+    MessagePort: C,
+    MIDIAccess: C,
+    MIDIConnectionEvent: C,
+    MIDIInput: C,
+    MIDIInputMap: C,
+    MIDIMessageEvent: C,
+    MIDIOutput: C,
+    MIDIOutputMap: C,
+    MIDIPort: C,
+    MimeType: C,
+    MimeTypeArray: C,
+    MouseEvent: C,
+    moveBy: O,
+    moveTo: O,
+    MutationEvent: C,
+    MutationObserver: C,
+    MutationRecord: C,
+    name: O,
+    NamedNodeMap: C,
+    NavigationPreloadManager: C,
+    navigator: O,
+    Navigator: C,
+    NetworkInformation: C,
+    Node: C,
+    NodeFilter: O,
+    NodeIterator: C,
+    NodeList: C,
+    Notification: C,
+    OfflineAudioCompletionEvent: C,
+    OfflineAudioContext: C,
+    offscreenBuffering: O,
+    OffscreenCanvas: C,
+    open: O,
+    openDatabase: O,
+    Option: C,
+    origin: O,
+    OscillatorNode: C,
+    outerHeight: O,
+    outerWidth: O,
+    PageTransitionEvent: C,
+    pageXOffset: O,
+    pageYOffset: O,
+    PannerNode: C,
+    parent: O,
+    Path2D: C,
+    PaymentAddress: C,
+    PaymentRequest: C,
+    PaymentRequestUpdateEvent: C,
+    PaymentResponse: C,
+    performance: O,
+    Performance: C,
+    PerformanceEntry: C,
+    PerformanceLongTaskTiming: C,
+    PerformanceMark: C,
+    PerformanceMeasure: C,
+    PerformanceNavigation: C,
+    PerformanceNavigationTiming: C,
+    PerformanceObserver: C,
+    PerformanceObserverEntryList: C,
+    PerformancePaintTiming: C,
+    PerformanceResourceTiming: C,
+    PerformanceTiming: C,
+    PeriodicWave: C,
+    Permissions: C,
+    PermissionStatus: C,
+    personalbar: O,
+    PhotoCapabilities: C,
+    Plugin: C,
+    PluginArray: C,
+    PointerEvent: C,
+    PopStateEvent: C,
+    postMessage: O,
+    Presentation: C,
+    PresentationAvailability: C,
+    PresentationConnection: C,
+    PresentationConnectionAvailableEvent: C,
+    PresentationConnectionCloseEvent: C,
+    PresentationConnectionList: C,
+    PresentationReceiver: C,
+    PresentationRequest: C,
+    print: O,
+    ProcessingInstruction: C,
+    ProgressEvent: C,
+    PromiseRejectionEvent: C,
+    prompt: O,
+    PushManager: C,
+    PushSubscription: C,
+    PushSubscriptionOptions: C,
+    queueMicrotask: O,
+    RadioNodeList: C,
+    Range: C,
+    ReadableStream: C,
+    RemotePlayback: C,
+    removeEventListener: O,
+    Request: C,
+    requestAnimationFrame: O,
+    requestIdleCallback: O,
+    resizeBy: O,
+    ResizeObserver: C,
+    ResizeObserverEntry: C,
+    resizeTo: O,
+    Response: C,
+    RTCCertificate: C,
+    RTCDataChannel: C,
+    RTCDataChannelEvent: C,
+    RTCDtlsTransport: C,
+    RTCIceCandidate: C,
+    RTCIceTransport: C,
+    RTCPeerConnection: C,
+    RTCPeerConnectionIceEvent: C,
+    RTCRtpReceiver: C,
+    RTCRtpSender: C,
+    RTCSctpTransport: C,
+    RTCSessionDescription: C,
+    RTCStatsReport: C,
+    RTCTrackEvent: C,
+    screen: O,
+    Screen: C,
+    screenLeft: O,
+    ScreenOrientation: C,
+    screenTop: O,
+    screenX: O,
+    screenY: O,
+    ScriptProcessorNode: C,
+    scroll: O,
+    scrollbars: O,
+    scrollBy: O,
+    scrollTo: O,
+    scrollX: O,
+    scrollY: O,
+    SecurityPolicyViolationEvent: C,
+    Selection: C,
+    ServiceWorker: C,
+    ServiceWorkerContainer: C,
+    ServiceWorkerRegistration: C,
+    sessionStorage: O,
+    ShadowRoot: C,
+    SharedWorker: C,
+    SourceBuffer: C,
+    SourceBufferList: C,
+    speechSynthesis: O,
+    SpeechSynthesisEvent: C,
+    SpeechSynthesisUtterance: C,
+    StaticRange: C,
+    status: O,
+    statusbar: O,
+    StereoPannerNode: C,
+    stop: O,
+    Storage: C,
+    StorageEvent: C,
+    StorageManager: C,
+    styleMedia: O,
+    StyleSheet: C,
+    StyleSheetList: C,
+    SubtleCrypto: C,
+    SVGAElement: C,
+    SVGAngle: C,
+    SVGAnimatedAngle: C,
+    SVGAnimatedBoolean: C,
+    SVGAnimatedEnumeration: C,
+    SVGAnimatedInteger: C,
+    SVGAnimatedLength: C,
+    SVGAnimatedLengthList: C,
+    SVGAnimatedNumber: C,
+    SVGAnimatedNumberList: C,
+    SVGAnimatedPreserveAspectRatio: C,
+    SVGAnimatedRect: C,
+    SVGAnimatedString: C,
+    SVGAnimatedTransformList: C,
+    SVGAnimateElement: C,
+    SVGAnimateMotionElement: C,
+    SVGAnimateTransformElement: C,
+    SVGAnimationElement: C,
+    SVGCircleElement: C,
+    SVGClipPathElement: C,
+    SVGComponentTransferFunctionElement: C,
+    SVGDefsElement: C,
+    SVGDescElement: C,
+    SVGDiscardElement: C,
+    SVGElement: C,
+    SVGEllipseElement: C,
+    SVGFEBlendElement: C,
+    SVGFEColorMatrixElement: C,
+    SVGFEComponentTransferElement: C,
+    SVGFECompositeElement: C,
+    SVGFEConvolveMatrixElement: C,
+    SVGFEDiffuseLightingElement: C,
+    SVGFEDisplacementMapElement: C,
+    SVGFEDistantLightElement: C,
+    SVGFEDropShadowElement: C,
+    SVGFEFloodElement: C,
+    SVGFEFuncAElement: C,
+    SVGFEFuncBElement: C,
+    SVGFEFuncGElement: C,
+    SVGFEFuncRElement: C,
+    SVGFEGaussianBlurElement: C,
+    SVGFEImageElement: C,
+    SVGFEMergeElement: C,
+    SVGFEMergeNodeElement: C,
+    SVGFEMorphologyElement: C,
+    SVGFEOffsetElement: C,
+    SVGFEPointLightElement: C,
+    SVGFESpecularLightingElement: C,
+    SVGFESpotLightElement: C,
+    SVGFETileElement: C,
+    SVGFETurbulenceElement: C,
+    SVGFilterElement: C,
+    SVGForeignObjectElement: C,
+    SVGGElement: C,
+    SVGGeometryElement: C,
+    SVGGradientElement: C,
+    SVGGraphicsElement: C,
+    SVGImageElement: C,
+    SVGLength: C,
+    SVGLengthList: C,
+    SVGLinearGradientElement: C,
+    SVGLineElement: C,
+    SVGMarkerElement: C,
+    SVGMaskElement: C,
+    SVGMatrix: C,
+    SVGMetadataElement: C,
+    SVGMPathElement: C,
+    SVGNumber: C,
+    SVGNumberList: C,
+    SVGPathElement: C,
+    SVGPatternElement: C,
+    SVGPoint: C,
+    SVGPointList: C,
+    SVGPolygonElement: C,
+    SVGPolylineElement: C,
+    SVGPreserveAspectRatio: C,
+    SVGRadialGradientElement: C,
+    SVGRect: C,
+    SVGRectElement: C,
+    SVGScriptElement: C,
+    SVGSetElement: C,
+    SVGStopElement: C,
+    SVGStringList: C,
+    SVGStyleElement: C,
+    SVGSVGElement: C,
+    SVGSwitchElement: C,
+    SVGSymbolElement: C,
+    SVGTextContentElement: C,
+    SVGTextElement: C,
+    SVGTextPathElement: C,
+    SVGTextPositioningElement: C,
+    SVGTitleElement: C,
+    SVGTransform: C,
+    SVGTransformList: C,
+    SVGTSpanElement: C,
+    SVGUnitTypes: C,
+    SVGUseElement: C,
+    SVGViewElement: C,
+    TaskAttributionTiming: C,
+    Text: C,
+    TextEvent: C,
+    TextMetrics: C,
+    TextTrack: C,
+    TextTrackCue: C,
+    TextTrackCueList: C,
+    TextTrackList: C,
+    TimeRanges: C,
+    toolbar: O,
+    top: O,
+    Touch: C,
+    TouchEvent: C,
+    TouchList: C,
+    TrackEvent: C,
+    TransitionEvent: C,
+    TreeWalker: C,
+    UIEvent: C,
+    ValidityState: C,
+    visualViewport: O,
+    VisualViewport: C,
+    VTTCue: C,
+    WaveShaperNode: C,
+    WebAssembly: O,
+    WebGL2RenderingContext: C,
+    WebGLActiveInfo: C,
+    WebGLBuffer: C,
+    WebGLContextEvent: C,
+    WebGLFramebuffer: C,
+    WebGLProgram: C,
+    WebGLQuery: C,
+    WebGLRenderbuffer: C,
+    WebGLRenderingContext: C,
+    WebGLSampler: C,
+    WebGLShader: C,
+    WebGLShaderPrecisionFormat: C,
+    WebGLSync: C,
+    WebGLTexture: C,
+    WebGLTransformFeedback: C,
+    WebGLUniformLocation: C,
+    WebGLVertexArrayObject: C,
+    WebSocket: C,
+    WheelEvent: C,
+    Window: C,
+    Worker: C,
+    WritableStream: C,
+    XMLDocument: C,
+    XMLHttpRequest: C,
+    XMLHttpRequestEventTarget: C,
+    XMLHttpRequestUpload: C,
+    XMLSerializer: C,
+    XPathEvaluator: C,
+    XPathExpression: C,
+    XPathResult: C,
+    XSLTProcessor: C
+};
+for (const global of ['window', 'global', 'self', 'globalThis']) {
+    knownGlobals[global] = knownGlobals;
 }
-
-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);
+function getGlobalAtPath(path) {
+    let currentGlobal = knownGlobals;
+    for (const pathSegment of path) {
+        if (typeof pathSegment !== 'string') {
+            return null;
         }
-    }
-}
-
-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);
+        currentGlobal = currentGlobal[pathSegment];
+        if (!currentGlobal) {
+            return null;
         }
     }
-    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);
-    }
+    return currentGlobal[ValueProperties];
 }
 
-class BlockStatement extends NodeBase {
+class GlobalVariable extends Variable {
     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);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
+        this.isReassigned = true;
     }
-    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;
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        return getGlobalAtPath([this.name, ...path]) ? UnknownTruthyValue : UnknownValue;
     }
-    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);
-            }
+    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));
     }
-    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);
-        }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return !globalAtPath || globalAtPath.hasEffectsWhenCalled(callOptions, context);
     }
 }
 
-class RestElement extends NodeBase {
+const tdzVariableKinds = {
+    __proto__: null,
+    class: true,
+    const: true,
+    let: true,
+    var: true
+};
+class Identifier extends NodeBase {
     constructor() {
         super(...arguments);
+        this.variable = null;
         this.deoptimized = false;
-        this.declarationInit = null;
+        this.isTDZAccess = 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();
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.declarationInit !== null) {
-            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
-            this.context.requestTreeshakingPass();
+    bind() {
+        if (!this.variable && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
         }
     }
-}
-
-class FunctionBase extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.objectEntity = null;
-        this.deoptimizedReturn = false;
+    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) {
-        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);
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
         }
+        this.variable.deoptimizePath(path);
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        if (path.length > 0) {
-            this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
-        }
+        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+        return this.getVariableRespectingTDZ().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.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
         }
-        return this.scope.getReturnExpression();
+        return (this.context.options.treeshake.unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
     }
     hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
+        return (this.variable !== null &&
+            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
+        return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsWhenAssignedAtPath(path, context);
     }
     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;
+        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);
             }
         }
-        for (const param of this.params) {
-            if (param.hasEffects(context))
-                return true;
-        }
-        return false;
-    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        const { brokenFlow } = context;
-        context.brokenFlow = BROKEN_FLOW_NONE;
-        this.body.include(context, includeChildrenRecursively);
-        context.brokenFlow = brokenFlow;
     }
     includeCallArguments(context, args) {
-        this.scope.includeCallArguments(context, args);
+        this.variable.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();
+    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);
         }
-        else {
-            this.scope.addReturnExpression(this.body);
+        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);
         }
-    }
-    parseNode(esTreeNode) {
-        if (esTreeNode.body.type === BlockStatement$1) {
-            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
+        if (!this.variable.initReached) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
         }
-        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;
+        return (this.isTDZAccess = 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;
+    markDeclarationReached() {
+        this.variable.initReached = true;
     }
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively);
-        for (const param of this.params) {
-            if (!(param instanceof Identifier)) {
-                param.include(context, includeChildrenRecursively);
+    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, ');
             }
         }
     }
-    getObjectEntity() {
-        if (this.objectEntity !== null) {
-            return this.objectEntity;
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable instanceof LocalVariable) {
+            this.variable.consolidateInitializers();
+            this.context.requestTreeshakingPass();
         }
-        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})`;
+    disallowImportReassignment() {
+        return this.context.error({
+            code: 'ILLEGAL_REASSIGNMENT',
+            message: `Illegal reassignment to import '${this.name}'`
+        }, this.start);
     }
-    else {
-        const fields = [];
-        for (const variable of exportedVariables) {
-            for (const exportName of exportNamesByVariable.get(variable)) {
-                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
-            }
+    getVariableRespectingTDZ() {
+        if (this.isPossibleTDZ()) {
+            return UNKNOWN_EXPRESSION;
         }
-        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, ')');
+        return this.variable;
     }
 }
-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, ')');
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
     }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
 }
 
 class ObjectPattern extends NodeBase {
@@ -8174,47 +8277,15 @@ class AssignmentExpression extends NodeBase {
                     renderSystemExportFunction(systemPatternExports, this.start, this.end, renderedSurroundingElement === ExpressionStatement$1, code, options);
                     return;
                 }
-            }
-        }
-        if (this.left.included &&
-            this.left instanceof ObjectPattern &&
-            (renderedSurroundingElement === ExpressionStatement$1 ||
-                renderedSurroundingElement === ArrowFunctionExpression$1)) {
-            code.appendRight(this.start, '(');
-            code.prependLeft(this.end, ')');
-        }
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.left.deoptimizePath(EMPTY_PATH);
-        this.right.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
-}
-
-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);
-    }
-    markDeclarationReached() {
-        this.left.markDeclarationReached();
-    }
-    render(code, options, { isShorthandProperty } = BLANK) {
-        this.left.render(code, options, { isShorthandProperty });
-        this.right.render(code, options);
+            }
+        }
+        if (this.left.included &&
+            this.left instanceof ObjectPattern &&
+            (renderedSurroundingElement === ExpressionStatement$1 ||
+                renderedSurroundingElement === ArrowFunctionExpression$1)) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -8331,7 +8402,8 @@ class FunctionNode extends FunctionBase {
         }
     }
     hasEffects() {
-        return this.id !== null && this.id.hasEffects();
+        var _a;
+        return !!((_a = this.id) === null || _a === void 0 ? void 0 : _a.hasEffects());
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         if (super.hasEffectsWhenCalledAtPath(path, callOptions, context))
@@ -8359,16 +8431,12 @@ class FunctionNode extends FunctionBase {
         context.ignore = ignore;
         return false;
     }
-    include(context, includeChildrenRecursively) {
-        super.include(context, includeChildrenRecursively);
-        if (this.id)
-            this.id.include();
-        const hasArguments = this.scope.argumentsVariable.included;
-        for (const param of this.params) {
-            if (!(param instanceof Identifier) || hasArguments) {
-                param.include(context, includeChildrenRecursively);
-            }
-        }
+    include(context, includeChildrenRecursively, { includeWithoutParameterDefaults } = BLANK) {
+        var _a;
+        (_a = this.id) === null || _a === void 0 ? void 0 : _a.include();
+        super.include(context, includeChildrenRecursively, {
+            includeWithoutParameterDefaults: includeWithoutParameterDefaults && !this.scope.argumentsVariable.included
+        });
     }
     initialise() {
         var _a;
@@ -8415,11 +8483,6 @@ class AwaitExpression extends NodeBase {
         }
         this.argument.include(context, includeChildrenRecursively);
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.argument.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
 }
 
 const binaryOperators = {
@@ -8443,9 +8506,10 @@ const binaryOperators = {
     '>>': (left, right) => left >> right,
     '>>>': (left, right) => left >>> right,
     '^': (left, right) => left ^ right,
-    in: () => UnknownValue,
-    instanceof: () => UnknownValue,
     '|': (left, right) => left | right
+    // We use the fallback for cases where we return something unknown
+    // in: () => UnknownValue,
+    // instanceof: () => UnknownValue,
 };
 class BinaryExpression extends NodeBase {
     deoptimizeCache() { }
@@ -8453,10 +8517,10 @@ class BinaryExpression extends NodeBase {
         if (path.length > 0)
             return UnknownValue;
         const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (leftValue === UnknownValue)
+        if (typeof leftValue === 'symbol')
             return UnknownValue;
         const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (rightValue === UnknownValue)
+        if (typeof rightValue === 'symbol')
             return UnknownValue;
         const operatorFn = binaryOperators[this.operator];
         if (!operatorFn)
@@ -8529,9 +8593,6 @@ class Literal extends NodeBase {
         }
         return path.length > 1;
     }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 0;
-    }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         if (path.length === 1) {
             return hasMemberEffectWhenCalled(this.members, path[0], callOptions, context);
@@ -8814,7 +8875,7 @@ class MemberExpression extends NodeBase {
         if (this.propertyKey === null) {
             this.propertyKey = UnknownKey;
             const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            return (this.propertyKey = value === UnknownValue ? UnknownKey : String(value));
+            return (this.propertyKey = typeof value === 'symbol' ? UnknownKey : String(value));
         }
         return this.propertyKey;
     }
@@ -8841,39 +8902,13 @@ class MemberExpression extends NodeBase {
     }
 }
 
-class CallExpression extends NodeBase {
+class CallExpressionBase extends NodeBase {
     constructor() {
         super(...arguments);
         this.deoptimized = false;
+        this.returnExpression = null;
         this.deoptimizableDependentExpressions = [];
         this.expressionsToBeDeoptimized = new Set();
-        this.returnExpression = null;
-    }
-    bind() {
-        super.bind();
-        if (this.callee instanceof Identifier) {
-            const variable = this.scope.findVariable(this.callee.name);
-            if (variable.isNamespace) {
-                this.context.warn({
-                    code: 'CANNOT_CALL_NAMESPACE',
-                    message: `Cannot call a namespace ('${this.callee.name}')`
-                }, this.start);
-            }
-            if (this.callee.name === 'eval') {
-                this.context.warn({
-                    code: 'EVAL',
-                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
-                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
-                }, this.start);
-            }
-        }
-        this.callOptions = {
-            args: this.arguments,
-            thisParam: this.callee instanceof MemberExpression && !this.callee.variable
-                ? this.callee.object
-                : null,
-            withNew: false
-        };
     }
     deoptimizeCache() {
         if (this.returnExpression !== UNKNOWN_EXPRESSION) {
@@ -8928,6 +8963,47 @@ class CallExpression extends NodeBase {
             return returnExpression.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
         }, UNKNOWN_EXPRESSION);
     }
+    hasEffectsWhenAccessedAtPath(path, context) {
+        return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+            this.getReturnExpression().hasEffectsWhenAccessedAtPath(path, context));
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
+            this.getReturnExpression().hasEffectsWhenAssignedAtPath(path, context));
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        return (!(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
+            this.getReturnExpression().hasEffectsWhenCalledAtPath(path, callOptions, context));
+    }
+}
+
+class CallExpression extends CallExpressionBase {
+    bind() {
+        super.bind();
+        if (this.callee instanceof Identifier) {
+            const variable = this.scope.findVariable(this.callee.name);
+            if (variable.isNamespace) {
+                this.context.warn({
+                    code: 'CANNOT_CALL_NAMESPACE',
+                    message: `Cannot call a namespace ('${this.callee.name}')`
+                }, this.start);
+            }
+            if (this.callee.name === 'eval') {
+                this.context.warn({
+                    code: 'EVAL',
+                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
+                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
+                }, this.start);
+            }
+        }
+        this.callOptions = {
+            args: this.arguments,
+            thisParam: this.callee instanceof MemberExpression && !this.callee.variable
+                ? this.callee.object
+                : null,
+            withNew: false
+        };
+    }
     hasEffects(context) {
         try {
             for (const argument of this.arguments) {
@@ -8945,18 +9021,6 @@ class CallExpression extends NodeBase {
                 this.applyDeoptimizations();
         }
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.getReturnExpression().hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.getReturnExpression().hasEffectsWhenAssignedAtPath(path, context));
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return (!(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
-            this.getReturnExpression().hasEffectsWhenCalledAtPath(path, callOptions, context));
-    }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -8970,7 +9034,7 @@ class CallExpression extends NodeBase {
         }
         else {
             this.included = true;
-            this.callee.include(context, false);
+            this.callee.include(context, false, { includeWithoutParameterDefaults: true });
         }
         this.callee.includeCallArguments(context, this.arguments);
         const returnExpression = this.getReturnExpression();
@@ -9179,8 +9243,6 @@ class ObjectMember extends ExpressionEntity {
         return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], callOptions, recursionTracker, origin);
     }
     hasEffectsWhenAccessedAtPath(path, context) {
-        if (path.length === 0)
-            return false;
         return this.object.hasEffectsWhenAccessedAtPath([this.key, ...path], context);
     }
     hasEffectsWhenAssignedAtPath(path, context) {
@@ -9194,6 +9256,7 @@ class ObjectMember extends ExpressionEntity {
 class ClassNode extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     createScope(parentScope) {
@@ -9203,7 +9266,14 @@ 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);
@@ -9216,6 +9286,8 @@ class ClassNode extends NodeBase {
     }
     hasEffects(context) {
         var _a, _b;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         const initEffect = ((_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffects(context)) || this.body.hasEffects(context);
         (_b = this.id) === null || _b === void 0 ? void 0 : _b.markDeclarationReached();
         return initEffect || super.hasEffects(context);
@@ -9227,12 +9299,13 @@ class ClassNode extends NodeBase {
         return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        var _a;
         if (path.length === 0) {
             return (!callOptions.withNew ||
                 (this.classConstructor !== null
                     ? this.classConstructor.hasEffectsWhenCalledAtPath(EMPTY_PATH, callOptions, context)
-                    : this.superClass !== null &&
-                        this.superClass.hasEffectsWhenCalledAtPath(path, callOptions, context)));
+                    : (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenCalledAtPath(path, callOptions, context)) ||
+                false);
         }
         else {
             return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
@@ -9240,6 +9313,8 @@ class ClassNode extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         var _a;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         this.included = true;
         (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         this.body.include(context, includeChildrenRecursively);
@@ -9259,6 +9334,17 @@ class ClassNode extends NodeBase {
         }
         this.classConstructor = null;
     }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const definition of this.body.body) {
+            if (!(definition.static ||
+                (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+                // Calls to methods are not tracked, ensure that the return value is deoptimized
+                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -9275,7 +9361,7 @@ class ClassNode extends NodeBase {
             let key;
             if (definition.computed) {
                 const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if (keyValue === UnknownValue) {
+                if (typeof keyValue === 'symbol') {
                     properties.push({ key: UnknownKey, kind, property: definition });
                     continue;
                 }
@@ -9397,7 +9483,7 @@ class ConditionalExpression extends NodeBase {
     }
     deoptimizePath(path) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             this.consequent.deoptimizePath(path);
             this.alternate.deoptimizePath(path);
         }
@@ -9411,14 +9497,14 @@ class ConditionalExpression extends NodeBase {
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null)
+        if (!usedBranch)
             return UnknownValue;
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null)
+        if (!usedBranch)
             return new MultiExpression([
                 this.consequent.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin),
                 this.alternate.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)
@@ -9430,14 +9516,14 @@ class ConditionalExpression extends NodeBase {
         if (this.test.hasEffects(context))
             return true;
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return this.consequent.hasEffects(context) || this.alternate.hasEffects(context);
         }
         return usedBranch.hasEffects(context);
     }
     hasEffectsWhenAccessedAtPath(path, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.consequent.hasEffectsWhenAccessedAtPath(path, context) ||
                 this.alternate.hasEffectsWhenAccessedAtPath(path, context));
         }
@@ -9445,7 +9531,7 @@ class ConditionalExpression extends NodeBase {
     }
     hasEffectsWhenAssignedAtPath(path, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.consequent.hasEffectsWhenAssignedAtPath(path, context) ||
                 this.alternate.hasEffectsWhenAssignedAtPath(path, context));
         }
@@ -9453,7 +9539,7 @@ class ConditionalExpression extends NodeBase {
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.consequent.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
                 this.alternate.hasEffectsWhenCalledAtPath(path, callOptions, context));
         }
@@ -9473,7 +9559,7 @@ class ConditionalExpression extends NodeBase {
     }
     includeCallArguments(context, args) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             this.consequent.includeCallArguments(context, args);
             this.alternate.includeCallArguments(context, args);
         }
@@ -9515,7 +9601,7 @@ class ConditionalExpression extends NodeBase {
         }
         this.isBranchResolutionAnalysed = true;
         const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-        return testValue === UnknownValue
+        return typeof testValue === 'symbol'
             ? null
             : (this.usedBranch = testValue ? this.consequent : this.alternate);
     }
@@ -9564,7 +9650,7 @@ class DoWhileStatement extends NodeBase {
         this.included = true;
         this.test.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
 }
@@ -9589,6 +9675,9 @@ class ExportAllDeclaration extends NodeBase {
 ExportAllDeclaration.prototype.needsBoundaries = true;
 
 class FunctionDeclaration extends FunctionNode {
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively, { includeWithoutParameterDefaults: true });
+    }
     initialise() {
         super.initialise();
         if (this.id !== null) {
@@ -9692,12 +9781,13 @@ ExportDefaultDeclaration.prototype.needsBoundaries = true;
 
 class ExportNamedDeclaration extends NodeBase {
     bind() {
+        var _a;
         // Do not bind specifiers
-        if (this.declaration !== null)
-            this.declaration.bind();
+        (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.bind();
     }
     hasEffects(context) {
-        return this.declaration !== null && this.declaration.hasEffects(context);
+        var _a;
+        return !!((_a = this.declaration) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
     }
     initialise() {
         this.context.addExport(this);
@@ -9751,7 +9841,7 @@ class ForInStatement extends NodeBase {
         this.left.include(context, includeChildrenRecursively || true);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
@@ -9791,7 +9881,7 @@ class ForOfStatement extends NodeBase {
         this.left.include(context, includeChildrenRecursively || true);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
@@ -9815,9 +9905,10 @@ class ForStatement extends NodeBase {
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
-        if ((this.init && this.init.hasEffects(context)) ||
-            (this.test && this.test.hasEffects(context)) ||
-            (this.update && this.update.hasEffects(context)))
+        var _a, _b, _c;
+        if (((_a = this.init) === null || _a === void 0 ? void 0 : _a.hasEffects(context)) ||
+            ((_b = this.test) === null || _b === void 0 ? void 0 : _b.hasEffects(context)) ||
+            ((_c = this.update) === null || _c === void 0 ? void 0 : _c.hasEffects(context)))
             return true;
         const { brokenFlow, ignore: { breaks, continues } } = context;
         context.ignore.breaks = true;
@@ -9830,24 +9921,20 @@ class ForStatement extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a, _b, _c;
         this.included = true;
-        if (this.init)
-            this.init.includeAsSingleStatement(context, includeChildrenRecursively);
-        if (this.test)
-            this.test.include(context, includeChildrenRecursively);
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        (_b = this.test) === null || _b === void 0 ? void 0 : _b.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        if (this.update)
-            this.update.include(context, includeChildrenRecursively);
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        (_c = this.update) === null || _c === void 0 ? void 0 : _c.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
-        if (this.init)
-            this.init.render(code, options, NO_SEMICOLON);
-        if (this.test)
-            this.test.render(code, options, NO_SEMICOLON);
-        if (this.update)
-            this.update.render(code, options, NO_SEMICOLON);
+        var _a, _b, _c;
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.render(code, options, NO_SEMICOLON);
+        (_b = this.test) === null || _b === void 0 ? void 0 : _b.render(code, options, NO_SEMICOLON);
+        (_c = this.update) === null || _c === void 0 ? void 0 : _c.render(code, options, NO_SEMICOLON);
         this.body.render(code, options);
     }
 }
@@ -9883,11 +9970,12 @@ class IfStatement extends NodeBase {
         this.testValue = UnknownValue;
     }
     hasEffects(context) {
+        var _a;
         if (this.test.hasEffects(context)) {
             return true;
         }
         const testValue = this.getTestValue();
-        if (testValue === UnknownValue) {
+        if (typeof testValue === 'symbol') {
             const { brokenFlow } = context;
             if (this.consequent.hasEffects(context))
                 return true;
@@ -9901,9 +9989,7 @@ class IfStatement extends NodeBase {
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
             return false;
         }
-        return testValue
-            ? this.consequent.hasEffects(context)
-            : this.alternate !== null && this.alternate.hasEffects(context);
+        return testValue ? this.consequent.hasEffects(context) : !!((_a = this.alternate) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
@@ -9912,7 +9998,7 @@ class IfStatement extends NodeBase {
         }
         else {
             const testValue = this.getTestValue();
-            if (testValue === UnknownValue) {
+            if (typeof testValue === 'symbol') {
                 this.includeUnknownTest(context);
             }
             else {
@@ -9942,7 +10028,7 @@ class IfStatement extends NodeBase {
         else {
             code.remove(this.start, this.consequent.start);
         }
-        if (this.consequent.included && (noTreeshake || testValue === UnknownValue || testValue)) {
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
             this.consequent.render(code, options);
         }
         else {
@@ -9950,7 +10036,7 @@ class IfStatement extends NodeBase {
             hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
         }
         if (this.alternate) {
-            if (this.alternate.included && (noTreeshake || testValue === UnknownValue || !testValue)) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
                 if (includesIfElse) {
                     if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
                         code.prependLeft(this.alternate.start, ' ');
@@ -9980,34 +10066,35 @@ class IfStatement extends NodeBase {
         return this.testValue;
     }
     includeKnownTest(context, testValue) {
+        var _a;
         if (this.test.shouldBeIncluded(context)) {
             this.test.include(context, false);
         }
         if (testValue && this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includeAsSingleStatement(context, false);
+            this.consequent.include(context, false, { asSingleStatement: true });
         }
-        if (this.alternate !== null && !testValue && this.alternate.shouldBeIncluded(context)) {
-            this.alternate.includeAsSingleStatement(context, false);
+        if (!testValue && ((_a = this.alternate) === null || _a === void 0 ? void 0 : _a.shouldBeIncluded(context))) {
+            this.alternate.include(context, false, { asSingleStatement: true });
         }
     }
     includeRecursively(includeChildrenRecursively, context) {
+        var _a;
         this.test.include(context, includeChildrenRecursively);
         this.consequent.include(context, includeChildrenRecursively);
-        if (this.alternate !== null) {
-            this.alternate.include(context, includeChildrenRecursively);
-        }
+        (_a = this.alternate) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
     }
     includeUnknownTest(context) {
+        var _a;
         this.test.include(context, false);
         const { brokenFlow } = context;
         let consequentBrokenFlow = BROKEN_FLOW_NONE;
         if (this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includeAsSingleStatement(context, false);
+            this.consequent.include(context, false, { asSingleStatement: true });
             consequentBrokenFlow = context.brokenFlow;
             context.brokenFlow = brokenFlow;
         }
-        if (this.alternate !== null && this.alternate.shouldBeIncluded(context)) {
-            this.alternate.includeAsSingleStatement(context, false);
+        if ((_a = this.alternate) === null || _a === void 0 ? void 0 : _a.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
             context.brokenFlow =
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
         }
@@ -10486,7 +10573,7 @@ class LogicalExpression extends NodeBase {
     }
     deoptimizePath(path) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             this.left.deoptimizePath(path);
             this.right.deoptimizePath(path);
         }
@@ -10500,14 +10587,14 @@ class LogicalExpression extends NodeBase {
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null)
+        if (!usedBranch)
             return UnknownValue;
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null)
+        if (!usedBranch)
             return new MultiExpression([
                 this.left.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin),
                 this.right.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)
@@ -10526,7 +10613,7 @@ class LogicalExpression extends NodeBase {
     }
     hasEffectsWhenAccessedAtPath(path, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.left.hasEffectsWhenAccessedAtPath(path, context) ||
                 this.right.hasEffectsWhenAccessedAtPath(path, context));
         }
@@ -10534,7 +10621,7 @@ class LogicalExpression extends NodeBase {
     }
     hasEffectsWhenAssignedAtPath(path, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.left.hasEffectsWhenAssignedAtPath(path, context) ||
                 this.right.hasEffectsWhenAssignedAtPath(path, context));
         }
@@ -10542,7 +10629,7 @@ class LogicalExpression extends NodeBase {
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         const usedBranch = this.getUsedBranch();
-        if (usedBranch === null) {
+        if (!usedBranch) {
             return (this.left.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
                 this.right.hasEffectsWhenCalledAtPath(path, callOptions, context));
         }
@@ -10553,7 +10640,7 @@ class LogicalExpression extends NodeBase {
         const usedBranch = this.getUsedBranch();
         if (includeChildrenRecursively ||
             (usedBranch === this.right && this.left.shouldBeIncluded(context)) ||
-            usedBranch === null) {
+            !usedBranch) {
             this.left.include(context, includeChildrenRecursively);
             this.right.include(context, includeChildrenRecursively);
         }
@@ -10594,7 +10681,7 @@ class LogicalExpression extends NodeBase {
         if (!this.isBranchResolutionAnalysed) {
             this.isBranchResolutionAnalysed = true;
             const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            if (leftValue === UnknownValue) {
+            if (typeof leftValue === 'symbol') {
                 return null;
             }
             else {
@@ -10780,21 +10867,37 @@ class NewExpression extends NodeBase {
         this.deoptimized = false;
     }
     hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const argument of this.arguments) {
-            if (argument.hasEffects(context))
-                return true;
+        try {
+            for (const argument of this.arguments) {
+                if (argument.hasEffects(context))
+                    return true;
+            }
+            if (this.context.options.treeshake.annotations &&
+                this.annotations)
+                return false;
+            return (this.callee.hasEffects(context) ||
+                this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        }
+        finally {
+            if (!this.deoptimized)
+                this.applyDeoptimizations();
         }
-        if (this.context.options.treeshake.annotations &&
-            this.annotations)
-            return false;
-        return (this.callee.hasEffects(context) ||
-            this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
     }
     hasEffectsWhenAccessedAtPath(path) {
         return path.length > 0;
     }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
     initialise() {
         this.callOptions = {
             args: this.arguments,
@@ -10863,7 +10966,7 @@ class ObjectExpression extends NodeBase {
             let key;
             if (property.computed) {
                 const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if (keyValue === UnknownValue) {
+                if (typeof keyValue === 'symbol') {
                     properties.push({ key: UnknownKey, kind: property.kind, property });
                     continue;
                 }
@@ -10984,8 +11087,8 @@ class PropertyDefinition extends NodeBase {
             : UNKNOWN_EXPRESSION;
     }
     hasEffects(context) {
-        return (this.key.hasEffects(context) ||
-            (this.static && this.value !== null && this.value.hasEffects(context)));
+        var _a;
+        return this.key.hasEffects(context) || (this.static && !!((_a = this.value) === null || _a === void 0 ? void 0 : _a.hasEffects(context)));
     }
     hasEffectsWhenAccessedAtPath(path, context) {
         return !this.value || this.value.hasEffectsWhenAccessedAtPath(path, context);
@@ -11000,17 +11103,16 @@ class PropertyDefinition extends NodeBase {
 
 class ReturnStatement extends NodeBase {
     hasEffects(context) {
-        if (!context.ignore.returnYield ||
-            (this.argument !== null && this.argument.hasEffects(context)))
+        var _a;
+        if (!context.ignore.returnYield || ((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context)))
             return true;
         context.brokenFlow = BROKEN_FLOW_ERROR_RETURN_LABEL;
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.argument) {
-            this.argument.include(context, includeChildrenRecursively);
-        }
+        (_a = this.argument) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         context.brokenFlow = BROKEN_FLOW_ERROR_RETURN_LABEL;
     }
     initialise() {
@@ -11130,6 +11232,9 @@ class Super extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    }
     include() {
         if (!this.included) {
             this.included = true;
@@ -11140,7 +11245,8 @@ class Super extends NodeBase {
 
 class SwitchCase extends NodeBase {
     hasEffects(context) {
-        if (this.test && this.test.hasEffects(context))
+        var _a;
+        if ((_a = this.test) === null || _a === void 0 ? void 0 : _a.hasEffects(context))
             return true;
         for (const node of this.consequent) {
             if (context.brokenFlow)
@@ -11151,9 +11257,9 @@ class SwitchCase extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.test)
-            this.test.include(context, includeChildrenRecursively);
+        (_a = this.test) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         for (const node of this.consequent) {
             if (includeChildrenRecursively || node.shouldBeIncluded(context))
                 node.include(context, includeChildrenRecursively);
@@ -11246,7 +11352,7 @@ class SwitchStatement extends NodeBase {
     }
 }
 
-class TaggedTemplateExpression extends NodeBase {
+class TaggedTemplateExpression extends CallExpressionBase {
     bind() {
         super.bind();
         if (this.tag.type === Identifier$1) {
@@ -11261,13 +11367,40 @@ class TaggedTemplateExpression extends NodeBase {
         }
     }
     hasEffects(context) {
-        return (super.hasEffects(context) ||
-            this.tag.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        try {
+            for (const argument of this.quasi.expressions) {
+                if (argument.hasEffects(context))
+                    return true;
+            }
+            return (this.tag.hasEffects(context) ||
+                this.tag.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        }
+        finally {
+            if (!this.deoptimized)
+                this.applyDeoptimizations();
+        }
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.tag.include(context, includeChildrenRecursively);
+            this.quasi.include(context, includeChildrenRecursively);
+        }
+        this.tag.includeCallArguments(context, this.callOptions.args);
+        const returnExpression = this.getReturnExpression();
+        if (!returnExpression.included) {
+            returnExpression.include(context, false);
+        }
     }
     initialise() {
         this.callOptions = {
-            args: NO_ARGS,
-            thisParam: null,
+            args: [UNKNOWN_EXPRESSION, ...this.quasi.expressions],
+            thisParam: this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
             withNew: false
         };
     }
@@ -11275,6 +11408,25 @@ class TaggedTemplateExpression extends NodeBase {
         this.tag.render(code, options, { isCalleeOfRenderedParent: true });
         this.quasi.render(code, options);
     }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { thisParam } = this.callOptions;
+        if (thisParam) {
+            this.tag.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParam, SHARED_RECURSION_TRACKER);
+        }
+        for (const argument of this.quasi.expressions) {
+            // This will make sure all properties of parameters behave as "unknown"
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.callOptions, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
 }
 
 class TemplateElement extends NodeBase {
@@ -11294,12 +11446,28 @@ class TemplateElement extends NodeBase {
 }
 
 class TemplateLiteral extends NodeBase {
+    deoptimizeThisOnEventAtPath() { }
     getLiteralValueAtPath(path) {
         if (path.length > 0 || this.quasis.length !== 1) {
             return UnknownValue;
         }
         return this.quasis[0].value.cooked;
     }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        return path.length > 1;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], callOptions, context);
+        }
+        return true;
+    }
     render(code, options) {
         code.indentExclusionRanges.push([this.start, this.end]);
         super.render(code, options);
@@ -11486,13 +11654,13 @@ class TryStatement extends NodeBase {
         this.includedLabelsAfterBlock = null;
     }
     hasEffects(context) {
+        var _a;
         return ((this.context.options.treeshake.tryCatchDeoptimization
             ? this.block.body.length > 0
-            : this.block.hasEffects(context)) ||
-            (this.finalizer !== null && this.finalizer.hasEffects(context)));
+            : this.block.hasEffects(context)) || !!((_a = this.finalizer) === null || _a === void 0 ? void 0 : _a.hasEffects(context)));
     }
     include(context, includeChildrenRecursively) {
-        var _a;
+        var _a, _b;
         const tryCatchDeoptimization = (_a = this.context.options.treeshake) === null || _a === void 0 ? void 0 : _a.tryCatchDeoptimization;
         const { brokenFlow } = context;
         if (!this.directlyIncluded || !tryCatchDeoptimization) {
@@ -11513,9 +11681,7 @@ class TryStatement extends NodeBase {
             this.handler.include(context, includeChildrenRecursively);
             context.brokenFlow = brokenFlow;
         }
-        if (this.finalizer !== null) {
-            this.finalizer.include(context, includeChildrenRecursively);
-        }
+        (_b = this.finalizer) === null || _b === void 0 ? void 0 : _b.include(context, includeChildrenRecursively);
     }
 }
 
@@ -11537,7 +11703,7 @@ class UnaryExpression extends NodeBase {
         if (path.length > 0)
             return UnknownValue;
         const argumentValue = this.argument.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (argumentValue === UnknownValue)
+        if (typeof argumentValue === 'symbol')
             return UnknownValue;
         return unaryOperators[this.operator](argumentValue);
     }
@@ -11651,18 +11817,12 @@ class VariableDeclaration extends NodeBase {
     hasEffectsWhenAssignedAtPath() {
         return false;
     }
-    include(context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively, { asSingleStatement } = BLANK) {
         this.included = true;
         for (const declarator of this.declarations) {
             if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
                 declarator.include(context, includeChildrenRecursively);
-        }
-    }
-    includeAsSingleStatement(context, includeChildrenRecursively) {
-        this.included = true;
-        for (const declarator of this.declarations) {
-            if (includeChildrenRecursively || declarator.shouldBeIncluded(context)) {
-                declarator.include(context, includeChildrenRecursively);
+            if (asSingleStatement) {
                 declarator.id.include(context, includeChildrenRecursively);
             }
         }
@@ -11683,16 +11843,14 @@ class VariableDeclaration extends NodeBase {
             }
         }
         else {
-            this.renderReplacedDeclarations(code, options, nodeRenderOptions);
+            this.renderReplacedDeclarations(code, options);
         }
     }
-    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options, isNoStatement) {
+    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
         if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
             code.remove(this.end - 1, this.end);
         }
-        if (!isNoStatement) {
-            separatorString += ';';
-        }
+        separatorString += ';';
         if (lastSeparatorPos !== null) {
             if (code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/ &&
                 (code.original.charCodeAt(this.end) === 10 /*"\n"*/ ||
@@ -11717,7 +11875,7 @@ class VariableDeclaration extends NodeBase {
             code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
         }
     }
-    renderReplacedDeclarations(code, options, { isNoStatement }) {
+    renderReplacedDeclarations(code, options) {
         const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.declarations, code, this.start + this.kind.length, this.end - (code.original.charCodeAt(this.end - 1) === 59 /*";"*/ ? 1 : 0));
         let actualContentEnd, renderedContentEnd;
         renderedContentEnd = findNonWhiteSpace(code.original, this.start + this.kind.length);
@@ -11773,7 +11931,7 @@ class VariableDeclaration extends NodeBase {
             lastSeparatorPos = separator;
             separatorString = nextSeparatorString;
         }
-        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, aggregatedSystemExports, options, isNoStatement);
+        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, aggregatedSystemExports, options);
     }
 }
 function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports) {
@@ -11810,15 +11968,17 @@ class VariableDeclarator extends NodeBase {
         this.id.deoptimizePath(path);
     }
     hasEffects(context) {
-        const initEffect = this.init !== null && this.init.hasEffects(context);
+        var _a;
+        const initEffect = (_a = this.init) === null || _a === void 0 ? void 0 : _a.hasEffects(context);
         this.id.markDeclarationReached();
         return initEffect || this.id.hasEffects(context);
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.init) {
-            this.init.include(context, includeChildrenRecursively);
-        }
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively, {
+            includeWithoutParameterDefaults: true
+        });
         this.id.markDeclarationReached();
         if (includeChildrenRecursively || this.id.shouldBeIncluded(context)) {
             this.id.include(context, includeChildrenRecursively);
@@ -11862,7 +12022,7 @@ class WhileStatement extends NodeBase {
         this.included = true;
         this.test.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
 }
@@ -11873,9 +12033,10 @@ class YieldExpression extends NodeBase {
         this.deoptimized = false;
     }
     hasEffects(context) {
+        var _a;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        return (!context.ignore.returnYield || (this.argument !== null && this.argument.hasEffects(context)));
+        return !context.ignore.returnYield || !!((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
     }
     render(code, options) {
         if (this.argument) {
@@ -11885,14 +12046,6 @@ class YieldExpression extends NodeBase {
             }
         }
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        const { argument } = this;
-        if (argument) {
-            argument.deoptimizePath(UNKNOWN_PATH);
-            this.context.requestTreeshakingPass();
-        }
-    }
 }
 
 const nodeConstructors = {