poe-code 6.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "6.0.0",
+  "version": "7.0.1",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

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

@@ -1,4 +1,4 @@
-import type { ArrowFunctionExpression, AwaitExpression, FunctionDeclaration, FunctionExpression, ParseResult, SourceSpan } from "../parse.js";
+import type { ArrowFunctionExpression, AwaitExpression, BlockStatement, FunctionDeclaration, FunctionExpression, ParseResult, SourceSpan } from "../parse.js";
 import { type GeneratorCompletion } from "./generator.js";
 import { type OtelSpan } from "../observability/otel.js";
 import type { Budget } from "./budget.js";
@@ -25,6 +25,7 @@ export type AsyncEvaluationContext = {
     onSuspend?: () => void;
     captureReplayState?: () => unknown;
     rootNode?: ParseResult;
+    functionBody?: BlockStatement;
     restoredLoopIterations: Map<number, LoopIterationSnapshot>;
     resumeTarget?: {
         nodeId?: number;

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

@@ -5,6 +5,7 @@ import { getThenable, resolveSandboxValue } from "./promise.js";
 import { runAsyncPrefix, suspendJob } from "./jobs.js";
 import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
+import { boundIdentifiers, containsParameterExpression, hoistedVarDeclarations } from "../parse/bindings.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, allocateProducedSandboxValue, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
     context.onYield?.({
@@ -112,6 +113,7 @@ function createGeneratorClosure(node, context, evaluateNode) {
             const channel = createGeneratorChannel(async (generatorYield) => {
                 const result = await evaluateNode(node.body, {
                     ...closureContext,
+                    functionBody: node.body,
                     generatorYield: (value, yieldNodeId) => {
                         generator.state = "suspended";
                         return generatorYield(value, yieldNodeId);
@@ -166,6 +168,7 @@ async function executeClosure(node, args, thisValue, context, evaluateNode) {
     const scope = await createClosureScope(node, args, thisValue, context, evaluateNode);
     const result = await evaluateNode(node.body, {
         ...context,
+        functionBody: node.body.type === "BlockStatement" ? node.body : undefined,
         scope
     });
     if (result.kind === "error") {
@@ -187,16 +190,32 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode)
         scope.declare("arguments", "let", createSandboxArguments(args));
     }
     await bindParameters(node.params, args, scope, context, evaluateNode);
-    hoistVarDeclarations(node.body, scope);
-    return scope;
+    const bodyScope = node.params.some(containsParameterExpression)
+        ? scope.child({}, { functionBoundary: true })
+        : scope;
+    hoistVarDeclarations(node.body, bodyScope);
+    if (bodyScope !== scope) {
+        for (const declaration of hoistedVarDeclarations([node.body])) {
+            for (const declarator of declaration.declarations) {
+                for (const identifier of boundIdentifiers(declarator.id)) {
+                    if (!scope.hasOwnBinding(identifier.name))
+                        continue;
+                    const parameter = scope.lookup(identifier.name);
+                    if (parameter.found)
+                        bodyScope.assign(identifier.name, parameter.value);
+                }
+            }
+        }
+    }
+    return bodyScope;
 }
 function isBlockBody(body) {
     return body.type === "BlockStatement";
 }
 async function bindParameters(params, args, scope, context, evaluateNode) {
     for (const param of params) {
-        for (const name of getParameterBindingNames(param)) {
-            scope.predeclare(name, "let");
+        for (const identifier of boundIdentifiers(param)) {
+            scope.predeclare(identifier.name, "var");
         }
     }
     for (let index = 0; index < params.length; index += 1) {
@@ -204,7 +223,7 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
         if (param.type === "RestElement") {
             const rest = args.slice(index);
             context.budget.allocateArrayLength(rest.length);
-            const binding = await bindPattern(param, rest, { kind: "let" }, scope, {
+            const binding = await bindPattern(param, rest, { kind: "var", initialize: true }, scope, {
                 evaluate: (defaultNode) => evaluateNode(defaultNode, { ...context, scope })
             });
             if (!binding.ok) {
@@ -217,7 +236,7 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
             }
             return;
         }
-        const binding = await bindPattern(param, args[index], { kind: "let" }, scope, {
+        const binding = await bindPattern(param, args[index], { kind: "var", initialize: true }, scope, {
             evaluate: (defaultNode) => evaluateNode(defaultNode, { ...context, scope })
         });
         if (!binding.ok) {
@@ -230,24 +249,6 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
         }
     }
 }
-function getParameterBindingNames(pattern) {
-    switch (pattern.type) {
-        case "Identifier":
-            return [pattern.name];
-        case "MemberExpression":
-            return [];
-        case "AssignmentPattern":
-            return getParameterBindingNames(pattern.left);
-        case "RestElement":
-            return getParameterBindingNames(pattern.argument);
-        case "ArrayPattern":
-            return pattern.elements.flatMap((element) => element === null ? [] : getParameterBindingNames(element));
-        case "ObjectPattern":
-            return pattern.properties.flatMap((property) => property.type === "RestElement"
-                ? getParameterBindingNames(property)
-                : getParameterBindingNames(property.value));
-    }
-}
 export function normalizeClosureResult(result, budget) {
     if (isSandboxPromise(result) &&
         (result.synchronousPrefix !== undefined || result.hostCall !== undefined)) {

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

@@ -803,7 +803,9 @@ function isParseResult(value) {
         Object.hasOwn(value, "span"));
 }
 function createBlockContext(node, context) {
-    const scope = node === context.rootNode || context.generatorResume !== undefined
+    const scope = node === context.rootNode ||
+        node === context.functionBody ||
+        context.generatorResume !== undefined
         ? context.scope
         : context.scope.child();
     const blockContext = {
@@ -816,15 +818,15 @@ function createBlockContext(node, context) {
     return blockContext;
 }
 function predeclareBlockBindings(node, context) {
-    predeclareStatementListBindings(node.body, context);
+    predeclareStatementListBindings(node.body, context, node === context.functionBody || node === context.rootNode);
 }
-function predeclareStatementListBindings(statements, context) {
+function predeclareStatementListBindings(statements, context, functionBody = false) {
     const { scope } = context;
     const names = new Set();
     for (const statement of statements) {
         if (statement.type === "FunctionDeclaration") {
             const name = statement.id.name;
-            if (names.has(name)) {
+            if (names.has(name) && !(functionBody && scope.getOwnBindingKind(name) === "var")) {
                 throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
             }
             const closure = createInterpretedClosure(statement, context, evaluateNode);
@@ -838,7 +840,7 @@ function predeclareStatementListBindings(statements, context) {
                 throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
             }
             names.add(name);
-            scope.declare(name, "const", closure);
+            scope.declare(name, functionBody ? "var" : "let", closure);
             continue;
         }
         if (statement.type !== "VariableDeclaration" || statement.kind === "var") {

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

@@ -5,6 +5,7 @@ import { type SandboxValue } from "./values.js";
 type Pattern = VariableDeclarator["id"] | AssignmentPattern | MemberExpression | RestElement;
 export type PatternTarget = {
     kind: VariableDeclarationKind;
+    initialize?: true;
 } | {
     assign: true;
 };

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

@@ -20,7 +20,7 @@ export async function bindPattern(pattern, value, target, scope, context) {
     }
 }
 function bindIdentifier(pattern, value, target, scope) {
-    if ("assign" in target || target.kind === "var") {
+    if ("assign" in target || (target.kind === "var" && target.initialize !== true)) {
         if ("assign" in target) {
             const binding = scope.lookup(pattern.name);
             if (!binding.found) {

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,9 +217,6 @@ 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;

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 {};