poe-code 5.0.4 → 7.0.0

package/packages/safejs/dist/interp/values.d.ts

@@ -52,6 +52,9 @@ export type SandboxCallContext = {
 };
 export type SandboxClosure = {
     readonly async?: true;
+    readonly sandbox?: true;
+    readonly boundTarget?: SandboxClosure;
+    readonly cancellationSignal?: AbortSignal;
     readonly kind: "fn";
     readonly name?: string;
     readonly properties?: SandboxObject;
@@ -82,6 +85,9 @@ type CopyFromSandboxOptions = {
 };
 export declare function createSandboxClosure(input: {
     async?: boolean;
+    sandbox?: boolean;
+    boundTarget?: SandboxClosure;
+    cancellationSignal?: AbortSignal;
     call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     construct?: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     name?: string;

package/packages/safejs/dist/interp/values.js

@@ -2,6 +2,7 @@ import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { SandboxError } from "./budget.js";
 import { observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
 import { promiseReplayContext } from "./promise-replay.js";
+import { invokeCancelableClosure, readPromiseCancellation, registerPromiseCancellation } from "./cancel.js";
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
@@ -17,15 +18,30 @@ const sandboxRetainedValues = Symbol("SandboxRetainedValues");
 export function createSandboxClosure(input) {
     const closure = {
         kind: "fn",
-        call: input.call,
+        call: (args, context) => invokeCancelableClosure(closure, input.call, args, context),
         name: input.name,
-        ...(input.construct === undefined ? {} : { construct: input.construct }),
+        ...(input.construct === undefined
+            ? {}
+            : {
+                construct: (args, context) => invokeCancelableClosure(closure, input.construct, args, context, true)
+            }),
         ...(input.async === true ? { async: true } : {})
     };
     Object.defineProperty(closure, sandboxClosureBrand, {
         enumerable: false,
         value: true
     });
+    if (input.sandbox === true) {
+        Object.defineProperty(closure, "sandbox", { value: true });
+    }
+    if (input.boundTarget !== undefined) {
+        Object.defineProperty(closure, "boundTarget", { value: input.boundTarget });
+    }
+    if (input.cancellationSignal !== undefined) {
+        Object.defineProperty(closure, "cancellationSignal", {
+            value: input.cancellationSignal
+        });
+    }
     if (input.properties !== undefined) {
         Object.defineProperty(closure, "properties", {
             enumerable: false,
@@ -40,11 +56,14 @@ export function createSandboxClosure(input) {
     return Object.freeze(closure);
 }
 export function createSandboxPromise(promise, metadata = {}) {
+    const original = metadata.trackReplay === false
+        ? promise
+        : (promiseReplayContext.getStore()?.track(promise) ?? promise);
     const sandboxPromise = {
         kind: "promise",
-        promise: metadata.trackReplay === false
-            ? promise
-            : (promiseReplayContext.getStore()?.track(promise) ?? promise)
+        get promise() {
+            return readPromiseCancellation(sandboxPromise, original);
+        }
     };
     Object.defineProperty(sandboxPromise, sandboxPromiseBrand, {
         enumerable: false,
@@ -70,6 +89,7 @@ export function createSandboxPromise(promise, metadata = {}) {
         });
     }
     trackSandboxPromise(sandboxPromise);
+    registerPromiseCancellation(sandboxPromise);
     return Object.freeze(sandboxPromise);
 }
 export function createSandboxGenerator(channel, metadata = undefined) {

package/packages/safejs/dist/interp/var-hoist.js

@@ -1,140 +1,10 @@
+import { boundIdentifiers, hoistedVarDeclarations } from "../parse/bindings.js";
 export function hoistVarDeclarations(node, scope) {
-    if (node.type === "BlockStatement") {
-        for (const statement of node.body) {
-            hoistVarStatement(statement, scope);
-        }
-        return;
-    }
-    switch (node.type) {
-        case "VariableDeclaration":
-        case "IfStatement":
-        case "ForStatement":
-        case "ForInStatement":
-        case "ForOfStatement":
-        case "WhileStatement":
-        case "DoWhileStatement":
-        case "TryStatement":
-        case "SwitchStatement":
-        case "ExportNamedDeclaration":
-            hoistVarStatement(node, scope);
-            return;
-        default:
-            return;
-    }
-}
-function hoistVarStatement(statement, scope) {
-    switch (statement.type) {
-        case "VariableDeclaration":
-            declareVarBindings(statement, scope);
-            return;
-        case "BlockStatement":
-            hoistVarDeclarations(statement, scope);
-            return;
-        case "IfStatement":
-            hoistVarStatement(statement.consequent, scope);
-            if (statement.alternate !== undefined) {
-                hoistVarStatement(statement.alternate, scope);
-            }
-            return;
-        case "ForStatement":
-            if (statement.init?.type === "VariableDeclaration") {
-                declareVarBindings(statement.init, scope);
-            }
-            hoistVarStatement(statement.body, scope);
-            return;
-        case "ForInStatement":
-        case "ForOfStatement":
-            if (statement.left.type === "VariableDeclaration") {
-                declareVarBindings(statement.left, scope);
-            }
-            hoistVarStatement(statement.body, scope);
-            return;
-        case "WhileStatement":
-        case "DoWhileStatement":
-            hoistVarStatement(statement.body, scope);
-            return;
-        case "TryStatement":
-            hoistVarDeclarations(statement.block, scope);
-            if (statement.handler !== undefined) {
-                hoistVarDeclarations(statement.handler.body, scope);
-            }
-            if (statement.finalizer !== undefined) {
-                hoistVarDeclarations(statement.finalizer, scope);
+    for (const declaration of hoistedVarDeclarations([node])) {
+        for (const declarator of declaration.declarations) {
+            for (const identifier of boundIdentifiers(declarator.id)) {
+                scope.declareVar(identifier.name);
             }
-            return;
-        case "SwitchStatement":
-            for (const switchCase of statement.cases) {
-                for (const consequent of switchCase.consequent) {
-                    hoistVarStatement(consequent, scope);
-                }
-            }
-            return;
-        case "ExportNamedDeclaration":
-            hoistVarStatement(statement.declaration, scope);
-            return;
-        case "FunctionDeclaration":
-        case "ExportDefaultDeclaration":
-        case "ImportDeclaration":
-        case "BreakStatement":
-        case "ContinueStatement":
-        case "EmptyStatement":
-        case "ExpressionStatement":
-        case "ReturnStatement":
-        case "ThrowStatement":
-            return;
-    }
-}
-function declareVarBindings(declaration, scope) {
-    if (declaration.kind !== "var") {
-        return;
-    }
-    for (const declarator of declaration.declarations) {
-        for (const name of getPatternBindingNames(declarator.id)) {
-            scope.declareVar(name);
         }
     }
 }
-function getPatternBindingNames(pattern) {
-    switch (pattern.type) {
-        case "Identifier":
-            return [pattern.name];
-        case "ArrayPattern":
-            return pattern.elements.flatMap((element) => element === null || element.type === "MemberExpression"
-                ? []
-                : getNestedPatternBindingNames(element));
-        case "ObjectPattern":
-            return pattern.properties.flatMap((property) => property.type === "RestElement"
-                ? property.argument.type === "MemberExpression"
-                    ? []
-                    : getNestedPatternBindingNames(property.argument)
-                : property.value.type === "MemberExpression"
-                    ? []
-                    : getNestedPatternBindingNames(property.value));
-    }
-}
-function getNestedPatternBindingNames(pattern) {
-    switch (pattern.type) {
-        case "Identifier":
-            return [pattern.name];
-        case "AssignmentPattern":
-            return pattern.left.type === "MemberExpression"
-                ? []
-                : getNestedPatternBindingNames(pattern.left);
-        case "RestElement":
-            return pattern.argument.type === "MemberExpression"
-                ? []
-                : getNestedPatternBindingNames(pattern.argument);
-        case "ArrayPattern":
-            return pattern.elements.flatMap((element) => element === null || element.type === "MemberExpression"
-                ? []
-                : getNestedPatternBindingNames(element));
-        case "ObjectPattern":
-            return pattern.properties.flatMap((property) => property.type === "RestElement"
-                ? property.argument.type === "MemberExpression"
-                    ? []
-                    : getNestedPatternBindingNames(property.argument)
-                : property.value.type === "MemberExpression"
-                    ? []
-                    : getNestedPatternBindingNames(property.value));
-    }
-}

package/packages/safejs/dist/lint/index.js

@@ -3,14 +3,12 @@ import { AS003 } from "./rules/AS003.js";
 import { AS004 } from "./rules/AS004.js";
 import { AS005 } from "./rules/AS005.js";
 import { AS006_007 } from "./rules/AS006-007.js";
-import { AS008 } from "./rules/AS008.js";
 import { AS009 } from "./rules/AS009.js";
 import { AS010 } from "./rules/AS010.js";
 import { AS011 } from "./rules/AS011.js";
 import { AS013 } from "./rules/AS013.js";
 import { AS015 } from "./rules/AS015.js";
 import { AS_ASYNC_NOT_NEEDED } from "./rules/AS-async-not-needed.js";
-import { AS_AWAIT_NON_PROMISE } from "./rules/AS-await-non-promise.js";
 import { AS_DESTRUCTURE_NULL_DEFAULT } from "./rules/AS-destructure-null-default.js";
 import { AS_EXPORT_IMPORT_META } from "./rules/AS-export-import-meta.js";
 import { AS_FLOATING_PROMISE } from "./rules/AS-floating-promise.js";
@@ -35,14 +33,12 @@ const RULES = [
     AS_UNUSED_IMPORT,
     AS006_007,
     AS_MISSING_ASYNC,
-    AS008,
     AS009,
     AS010,
     AS011,
     AS013,
     AS015,
     AS_IMPORT_CYCLE,
-    AS_AWAIT_NON_PROMISE,
     AS_FLOATING_PROMISE,
     AS_ASYNC_NOT_NEEDED,
     AS_JSDOC_TYPE,

package/packages/safejs/dist/lint/rules/AS001.js

@@ -156,7 +156,10 @@ class AS001Scanner {
                     (previousToken.value === "." || previousToken.value === "?.");
                 const isPropertyKey = nextSignificantChar === ":" && !canStartStatement;
                 const isMemberName = isMemberNameToken(token, previousToken, previousPreviousToken, braceContextStack, nextSignificantChar);
-                if (canStartStatement && nextSignificantChar === ":" && !this.isLoopLabelStart()) {
+                if (canStartStatement &&
+                    nextSignificantChar === ":" &&
+                    token.value !== "default" &&
+                    !this.isLoopLabelStart()) {
                     this.report("label", token.start, this.positionWithinSource(token.start.offset + token.value.length));
                 }
                 else if (!isMemberProperty && !isPropertyKey && !isMemberName) {
@@ -214,17 +217,9 @@ class AS001Scanner {
             case "class":
             case "eval":
             case "Function":
-            case "switch":
-            case "this":
-            case "var":
             case "with":
                 this.report(token.value, token.start, token.end);
                 return;
-            case "new":
-                if (!this.source.slice(this.skipTriviaFrom(token.end.offset)).startsWith("RegExp")) {
-                    this.report(token.value, token.start, token.end);
-                }
-                return;
             default:
                 return;
         }

package/packages/safejs/dist/lint/rules/AS003.js

@@ -1,5 +1,6 @@
 import { parseModule } from "../../parse/parser.js";
 import { KNOWN_RUNTIME_GLOBALS } from "./known-globals.js";
+import { hoistedVarDeclarations } from "../../parse/bindings.js";
 export function AS003(source, options = {}) {
     return new AS003Scanner(options.filename ?? "<input>", new Set([...KNOWN_RUNTIME_GLOBALS, ...(options.allowedGlobals ?? [])])).scan(source);
 }
@@ -52,6 +53,9 @@ class AS003Scanner {
             case "TryStatement":
                 this.visitTryStatement(node);
                 return;
+            case "SwitchStatement":
+                this.visitSwitchStatement(node);
+                return;
             case "VariableDeclaration":
                 this.visitVariableDeclaration(node);
                 return;
@@ -75,8 +79,14 @@ class AS003Scanner {
                 return;
         }
     }
-    visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
+    visitBlock(node, functionBody = false) {
+        const bindings = this.collectBlockBindings(node.body);
+        if (functionBody) {
+            for (const declaration of hoistedVarDeclarations(node.body)) {
+                bindings.push(...this.collectDeclarationBindings(declaration));
+            }
+        }
+        this.withScope(bindings, () => {
             for (const statement of node.body) {
                 this.visitStatement(statement);
             }
@@ -93,7 +103,9 @@ class AS003Scanner {
         }
     }
     visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
+        const bindings = node.init?.type === "VariableDeclaration" && node.init.kind !== "var"
+            ? this.collectDeclarationBindings(node.init)
+            : [];
         this.withScope(bindings, () => {
             if (node.init !== undefined) {
                 if (node.init.type === "VariableDeclaration") {
@@ -113,7 +125,9 @@ class AS003Scanner {
         });
     }
     visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
+        const bindings = node.left.type === "VariableDeclaration" && node.left.kind !== "var"
+            ? this.collectDeclarationBindings(node.left)
+            : [];
         this.withScope(bindings, () => {
             if (node.left.type === "VariableDeclaration") {
                 this.visitVariableDeclaration(node.left);
@@ -129,6 +143,17 @@ class AS003Scanner {
         this.visitExpression(node.test);
         this.visitStatement(node.body);
     }
+    visitSwitchStatement(node) {
+        this.visitExpression(node.discriminant);
+        this.withScope(this.collectBlockBindings(node.cases.flatMap((switchCase) => switchCase.consequent)), () => {
+            for (const switchCase of node.cases) {
+                if (switchCase.test !== undefined)
+                    this.visitExpression(switchCase.test);
+                for (const statement of switchCase.consequent)
+                    this.visitStatement(statement);
+            }
+        });
+    }
     visitTryStatement(node) {
         this.visitBlock(node.block);
         if (node.handler !== undefined) {
@@ -202,8 +227,20 @@ class AS003Scanner {
                 this.visitAssignmentExpression(node);
                 return;
             case "CallExpression":
+            case "NewExpression":
                 this.visitCallExpression(node);
                 return;
+            case "SequenceExpression":
+                for (const expression of node.expressions)
+                    this.visitExpression(expression);
+                return;
+            case "UpdateExpression":
+                this.visitExpression(node.argument);
+                return;
+            case "TaggedTemplateExpression":
+                this.visitExpression(node.tag);
+                this.visitTemplateLiteral(node.quasi);
+                return;
             case "TemplateLiteral":
                 this.visitTemplateLiteral(node);
                 return;
@@ -221,7 +258,7 @@ class AS003Scanner {
                 this.visitBindingElement(parameter);
             }
             if (node.body.type === "BlockStatement") {
-                this.visitBlock(node.body);
+                this.visitBlock(node.body, true);
             }
             else {
                 this.visitExpression(node.body);
@@ -442,6 +479,9 @@ class AS003Scanner {
     }
     collectModuleBindings(body) {
         const bindings = [];
+        for (const declaration of hoistedVarDeclarations(body)) {
+            bindings.push(...this.collectDeclarationBindings(declaration));
+        }
         for (const statement of body) {
             if (statement.type === "ImportDeclaration") {
                 bindings.push(...this.collectImportBindings(statement));
@@ -451,7 +491,7 @@ class AS003Scanner {
                 bindings.push({ kind: "let", name: statement.id.name });
                 continue;
             }
-            if (statement.type === "VariableDeclaration") {
+            if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
                 bindings.push(...this.collectDeclarationBindings(statement));
                 continue;
             }
@@ -467,7 +507,7 @@ class AS003Scanner {
             if (statement.type === "FunctionDeclaration") {
                 bindings.push({ kind: "let", name: statement.id.name });
             }
-            if (statement.type === "VariableDeclaration") {
+            if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
                 bindings.push(...this.collectDeclarationBindings(statement));
             }
         }

package/packages/safejs/dist/lint/rules/AS006-007.js

@@ -1,4 +1,5 @@
 import { parseModule } from "../../parse/parser.js";
+import { hoistedVarDeclarations } from "../../parse/bindings.js";
 export function AS006_007(source, options = {}) {
     return new AS006007Scanner(options.filename ?? "<input>").scan(source);
 }
@@ -58,6 +59,9 @@ class AS006007Scanner {
             case "TryStatement":
                 this.visitTryStatement(node);
                 return;
+            case "SwitchStatement":
+                this.visitSwitchStatement(node);
+                return;
             case "VariableDeclaration":
                 this.visitVariableDeclaration(node);
                 return;
@@ -75,8 +79,14 @@ class AS006007Scanner {
                 return;
         }
     }
-    visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
+    visitBlock(node, functionBody = false) {
+        const bindings = this.collectBlockBindings(node.body);
+        if (functionBody) {
+            for (const declaration of hoistedVarDeclarations(node.body)) {
+                bindings.push(...this.collectDeclarationBindings(declaration));
+            }
+        }
+        this.withScope(bindings, () => {
             for (const statement of node.body) {
                 this.visitStatement(statement);
             }
@@ -90,7 +100,9 @@ class AS006007Scanner {
         }
     }
     visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
+        const bindings = node.init?.type === "VariableDeclaration" && node.init.kind !== "var"
+            ? this.collectDeclarationBindings(node.init)
+            : [];
         this.withScope(bindings, () => {
             if (node.init !== undefined) {
                 if (node.init.type === "VariableDeclaration") {
@@ -110,7 +122,9 @@ class AS006007Scanner {
         });
     }
     visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
+        const bindings = node.left.type === "VariableDeclaration" && node.left.kind !== "var"
+            ? this.collectDeclarationBindings(node.left)
+            : [];
         this.withScope(bindings, () => {
             if (node.left.type === "VariableDeclaration") {
                 this.visitVariableDeclaration(node.left);
@@ -143,6 +157,18 @@ class AS006007Scanner {
             this.visitBlock(node.body);
         });
     }
+    visitSwitchStatement(node) {
+        this.visitExpression(node.discriminant);
+        const statements = node.cases.flatMap((switchCase) => switchCase.consequent);
+        this.withScope(this.collectBlockBindings(statements), () => {
+            for (const switchCase of node.cases) {
+                if (switchCase.test !== undefined)
+                    this.visitExpression(switchCase.test);
+                for (const statement of switchCase.consequent)
+                    this.visitStatement(statement);
+            }
+        });
+    }
     visitThrowStatement(node) {
         this.visitExpression(node.argument);
     }
@@ -202,8 +228,20 @@ class AS006007Scanner {
                 this.visitAssignmentExpression(node);
                 return;
             case "CallExpression":
+            case "NewExpression":
                 this.visitCallExpression(node);
                 return;
+            case "SequenceExpression":
+                for (const expression of node.expressions)
+                    this.visitExpression(expression);
+                return;
+            case "UpdateExpression":
+                this.visitExpression(node.argument);
+                return;
+            case "TaggedTemplateExpression":
+                this.visitExpression(node.tag);
+                this.visitTemplateLiteral(node.quasi);
+                return;
             case "TemplateLiteral":
                 this.visitTemplateLiteral(node);
                 return;
@@ -222,7 +260,7 @@ class AS006007Scanner {
                     this.visitBindingElement(parameter);
                 }
                 if (node.body.type === "BlockStatement") {
-                    this.visitBlock(node.body);
+                    this.visitBlock(node.body, true);
                     return;
                 }
                 this.visitExpression(node.body);
@@ -436,6 +474,9 @@ class AS006007Scanner {
     }
     collectModuleBindings(body) {
         const bindings = [];
+        for (const declaration of hoistedVarDeclarations(body)) {
+            bindings.push(...this.collectDeclarationBindings(declaration));
+        }
         for (const statement of body) {
             if (statement.type === "ImportDeclaration") {
                 bindings.push(...this.collectImportBindings(statement));
@@ -445,7 +486,7 @@ class AS006007Scanner {
                 bindings.push(this.createBinding(statement.id, "let"));
                 continue;
             }
-            if (statement.type === "VariableDeclaration") {
+            if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
                 bindings.push(...this.collectDeclarationBindings(statement));
                 continue;
             }
@@ -461,7 +502,7 @@ class AS006007Scanner {
             if (statement.type === "FunctionDeclaration") {
                 bindings.push(this.createBinding(statement.id, "let"));
             }
-            if (statement.type === "VariableDeclaration") {
+            if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
                 bindings.push(...this.collectDeclarationBindings(statement));
             }
         }

package/packages/safejs/dist/parse/bindings.d.ts

@@ -0,0 +1,6 @@
+import type { ArrayPattern, AssignmentPattern, Identifier, MemberExpression, ObjectPattern, ParseResult, RestElement, VariableDeclaration } from "./parser.js";
+type BindingPattern = Identifier | ArrayPattern | ObjectPattern | AssignmentPattern | RestElement | MemberExpression;
+export declare function boundIdentifiers(pattern: BindingPattern): Iterable<Identifier>;
+export declare function containsParameterExpression(pattern: BindingPattern): boolean;
+export declare function hoistedVarDeclarations(nodes: readonly ParseResult[]): Iterable<VariableDeclaration>;
+export {};

package/packages/safejs/dist/parse/bindings.js

@@ -0,0 +1,90 @@
+export function* boundIdentifiers(pattern) {
+    switch (pattern.type) {
+        case "Identifier":
+            yield pattern;
+            return;
+        case "AssignmentPattern":
+            yield* boundIdentifiers(pattern.left);
+            return;
+        case "RestElement":
+            yield* boundIdentifiers(pattern.argument);
+            return;
+        case "ArrayPattern":
+            for (const element of pattern.elements) {
+                if (element !== null)
+                    yield* boundIdentifiers(element);
+            }
+            return;
+        case "ObjectPattern":
+            for (const property of pattern.properties) {
+                yield* boundIdentifiers(property.type === "RestElement" ? property : property.value);
+            }
+            return;
+        case "MemberExpression":
+            return;
+    }
+}
+export function containsParameterExpression(pattern) {
+    switch (pattern.type) {
+        case "AssignmentPattern":
+        case "MemberExpression":
+            return true;
+        case "RestElement":
+            return containsParameterExpression(pattern.argument);
+        case "ArrayPattern":
+            return pattern.elements.some((element) => element !== null && containsParameterExpression(element));
+        case "ObjectPattern":
+            return pattern.properties.some((property) => property.type === "RestElement"
+                ? containsParameterExpression(property.argument)
+                : property.computed || containsParameterExpression(property.value));
+        case "Identifier":
+            return false;
+    }
+}
+export function* hoistedVarDeclarations(nodes) {
+    for (const node of nodes) {
+        switch (node.type) {
+            case "VariableDeclaration":
+                if (node.kind === "var")
+                    yield node;
+                break;
+            case "BlockStatement":
+                yield* hoistedVarDeclarations(node.body);
+                break;
+            case "IfStatement":
+                yield* hoistedVarDeclarations([node.consequent]);
+                if (node.alternate !== undefined)
+                    yield* hoistedVarDeclarations([node.alternate]);
+                break;
+            case "ForStatement":
+                if (node.init?.type === "VariableDeclaration")
+                    yield* hoistedVarDeclarations([node.init]);
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "ForInStatement":
+            case "ForOfStatement":
+                if (node.left.type === "VariableDeclaration")
+                    yield* hoistedVarDeclarations([node.left]);
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "WhileStatement":
+            case "DoWhileStatement":
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "TryStatement":
+                yield* hoistedVarDeclarations([node.block]);
+                if (node.handler !== undefined)
+                    yield* hoistedVarDeclarations([node.handler.body]);
+                if (node.finalizer !== undefined)
+                    yield* hoistedVarDeclarations([node.finalizer]);
+                break;
+            case "SwitchStatement":
+                for (const switchCase of node.cases)
+                    yield* hoistedVarDeclarations(switchCase.consequent);
+                break;
+            case "ExportNamedDeclaration":
+                yield* hoistedVarDeclarations([node.declaration]);
+                break;
+        }
+    }
+}