poe-code 4.0.58 → 4.0.59

package/dist/index.js

@@ -124066,11 +124066,6 @@ var init_AS001 = __esm({
                 pendingClassBody = true;
               }
             }
-            if (token.value === "function" && nextSignificantChar === "*") {
-              const generatorStart = this.positionWithinSource(this.skipTriviaFrom(this.index));
-              const generatorEnd = this.positionWithinSource(this.skipTriviaFrom(this.index) + 1);
-              this.report("generator", generatorStart, generatorEnd);
-            }
           }
           const isStatementBrace = token.type === "punctuator" && token.value === "{" && canStartStatement;
           if (token.type === "punctuator" && token.value === "{") {
@@ -124116,7 +124111,6 @@ var init_AS001 = __esm({
         switch (token.value) {
           case "class":
           case "eval":
-          case "function":
           case "Function":
           case "switch":
           case "this":
@@ -124532,6 +124526,9 @@ var init_AS003 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlock(node);
             return;
@@ -124663,9 +124660,15 @@ var init_AS003 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "Identifier":
             this.visitIdentifier(node);
             return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -124935,6 +124938,10 @@ var init_AS003 = __esm({
             bindings.push(...this.collectImportBindings(statement));
             continue;
           }
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push({ kind: "let", name: statement.id.name });
+            continue;
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
             continue;
@@ -124948,6 +124955,9 @@ var init_AS003 = __esm({
       collectBlockBindings(body) {
         const bindings = [];
         for (const statement of body) {
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push({ kind: "let", name: statement.id.name });
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
           }
@@ -124956,6 +124966,12 @@ var init_AS003 = __esm({
       }
       collectParameterBindings(node) {
         const bindings = [];
+        if (node.type !== "ArrowFunctionExpression") {
+          bindings.push({ kind: "let", name: "arguments" });
+          if (node.type === "FunctionExpression" && node.id !== void 0) {
+            bindings.push({ kind: "const", name: node.id.name });
+          }
+        }
         for (const parameter of node.params) {
           this.collectBindingNamesFromElement(parameter, "param", bindings);
         }
@@ -125239,6 +125255,9 @@ var init_AS006_007 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "ExportNamedDeclaration":
             this.visitVariableDeclaration(node.declaration);
             return;
@@ -125370,9 +125389,15 @@ var init_AS006_007 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "Identifier":
             this.markRead(node);
             return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -125646,6 +125671,10 @@ var init_AS006_007 = __esm({
             bindings.push(...this.collectImportBindings(statement));
             continue;
           }
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push(this.createBinding(statement.id, "let"));
+            continue;
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
             continue;
@@ -125659,6 +125688,9 @@ var init_AS006_007 = __esm({
       collectBlockBindings(body) {
         const bindings = [];
         for (const statement of body) {
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push(this.createBinding(statement.id, "let"));
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
           }
@@ -125667,6 +125699,9 @@ var init_AS006_007 = __esm({
       }
       collectParameterBindings(node) {
         const bindings = [];
+        if (node.type === "FunctionExpression" && node.id !== void 0) {
+          bindings.push(this.createBinding(node.id, "param"));
+        }
         for (const parameter of node.params) {
           this.collectBindingNamesFromElement(parameter, "param", bindings);
         }
@@ -125841,6 +125876,9 @@ var init_AS008 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.withNestedScope(() => {
               this.visitBlock(node);
@@ -125957,6 +125995,12 @@ var init_AS008 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -126227,6 +126271,9 @@ var init_AS009 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node.body);
             return;
@@ -126354,6 +126401,12 @@ var init_AS009 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -126713,6 +126766,9 @@ var init_AS010 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlock(node);
             return;
@@ -126845,9 +126901,15 @@ var init_AS010 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "Identifier":
             this.markRead(node);
             return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -127353,6 +127415,9 @@ var init_AS011 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             for (const statement of node.body) {
               this.visitStatement(statement);
@@ -127468,6 +127533,12 @@ var init_AS011 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -127588,399 +127659,7 @@ var init_AS011 = __esm({
           this.visitExpression(expression);
         }
       }
-      visitAssignmentTarget(node) {
-        switch (node.type) {
-          case "Identifier":
-          case "MetaProperty":
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentPattern":
-            this.visitAssignmentTarget(node.left);
-            this.visitExpression(node.right);
-            return;
-          case "RestElement":
-            this.visitAssignmentTarget(node.argument);
-            return;
-          case "ArrayPattern":
-            for (const element of node.elements) {
-              if (element !== null) {
-                this.visitAssignmentTarget(element);
-              }
-            }
-            return;
-          case "ObjectPattern":
-            for (const property of node.properties) {
-              if (property.type === "RestElement") {
-                this.visitAssignmentTarget(property.argument);
-                continue;
-              }
-              if (property.computed) {
-                this.visitExpression(property.key);
-              }
-              this.visitAssignmentTarget(property.value);
-            }
-            return;
-        }
-      }
-      visitBindingTarget(node) {
-        switch (node.type) {
-          case "AssignmentPattern":
-            this.visitBindingTarget(node.left);
-            this.visitExpression(node.right);
-            return;
-          case "RestElement":
-            this.visitBindingTarget(node.argument);
-            return;
-          default:
-            this.visitAssignmentTarget(node);
-            return;
-        }
-      }
-      isForbiddenMemberProperty(node) {
-        if (!node.computed) {
-          return node.property.type === "Identifier" && FORBIDDEN_PROPERTY_NAMES.has(node.property.name);
-        }
-        return node.property.type === "StringLiteral" && FORBIDDEN_PROPERTY_NAMES.has(node.property.value);
-      }
-      report(span) {
-        this.diagnostics.push({
-          code: "AS011",
-          severity: "error",
-          message: MESSAGE3,
-          filename: this.filename,
-          line: span.start.line,
-          column: span.start.column,
-          span
-        });
-      }
-    };
-  }
-});
-
-// packages/safejs/src/lint/rules/AS012.ts
-function AS012(source, options = {}) {
-  return new AS012Scanner(options.filename ?? "<input>").scan(source);
-}
-function getMemberPropertyName(node) {
-  if (node.type !== "MemberExpression") {
-    return void 0;
-  }
-  if (!node.computed && node.property.type === "Identifier") {
-    return node.property.name;
-  }
-  if (node.computed && node.property.type === "StringLiteral") {
-    return node.property.value;
-  }
-  return void 0;
-}
-function isSupportedSortComparator(node) {
-  return node.type === "ArrowFunctionExpression" && !node.async && isNumberReturningArrow(node);
-}
-function isNumberReturningArrow(node) {
-  if (node.body.type === "BlockStatement") {
-    return false;
-  }
-  return isClearlyNumberExpression(node.body);
-}
-function isClearlyNumberExpression(node) {
-  switch (node.type) {
-    case "NumericLiteral":
-      return true;
-    case "RegexLiteral":
-      return false;
-    case "UnaryExpression":
-      return (node.operator === "+" || node.operator === "-" || node.operator === "~") && isClearlyNumberExpression(node.argument);
-    case "BinaryExpression":
-      return NUMBER_RETURNING_BINARY_OPERATORS.has(node.operator);
-    case "ConditionalExpression":
-      return isClearlyNumberExpression(node.consequent) && isClearlyNumberExpression(node.alternate);
-    case "CallExpression":
-      return isLocaleCompareCall(node);
-    default:
-      return false;
-  }
-}
-function isLocaleCompareCall(node) {
-  return getMemberPropertyName(node.callee) === "localeCompare";
-}
-var SORT_MESSAGE, NUMBER_RETURNING_BINARY_OPERATORS, AS012Scanner;
-var init_AS012 = __esm({
-  "packages/safejs/src/lint/rules/AS012.ts"() {
-    "use strict";
-    init_parser3();
-    SORT_MESSAGE = "Array#sort only supports comparators that are arrows returning a number.";
-    NUMBER_RETURNING_BINARY_OPERATORS = /* @__PURE__ */ new Set([
-      "%",
-      "*",
-      "**",
-      "-",
-      "/",
-      "<<",
-      ">>",
-      ">>>",
-      "&",
-      "^",
-      "|"
-    ]);
-    AS012Scanner = class {
-      constructor(filename) {
-        this.filename = filename;
-      }
-      filename;
-      diagnostics = [];
-      scan(source) {
-        this.visitModule(parseModule(source, this.filename));
-        return this.diagnostics;
-      }
-      visitModule(node) {
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-      }
-      visitStatement(node) {
-        switch (node.type) {
-          case "BlockStatement":
-            for (const statement of node.body) {
-              this.visitStatement(statement);
-            }
-            return;
-          case "ExpressionStatement":
-            this.visitExpression(node.expression);
-            return;
-          case "IfStatement":
-            this.visitIfStatement(node);
-            return;
-          case "ForStatement":
-            this.visitForStatement(node);
-            return;
-          case "ForInStatement":
-          case "ForOfStatement":
-            this.visitForOfStatement(node);
-            return;
-          case "WhileStatement":
-          case "DoWhileStatement":
-            this.visitWhileStatement(node);
-            return;
-          case "TryStatement":
-            this.visitTryStatement(node);
-            return;
-          case "VariableDeclaration":
-            this.visitVariableDeclaration(node);
-            return;
-          case "ReturnStatement":
-            this.visitReturnStatement(node);
-            return;
-          case "ThrowStatement":
-            this.visitThrowStatement(node);
-            return;
-          case "ExportNamedDeclaration":
-            this.visitVariableDeclaration(node.declaration);
-            return;
-          case "ExportDefaultDeclaration":
-            this.visitExpression(node.declaration);
-            return;
-          case "ImportDeclaration":
-          case "BreakStatement":
-          case "ContinueStatement":
-            return;
-        }
-      }
-      visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== void 0) {
-          this.visitStatement(node.alternate);
-        }
-      }
-      visitForStatement(node) {
-        if (node.init !== void 0) {
-          if (node.init.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.init);
-          } else {
-            this.visitExpression(node.init);
-          }
-        }
-        if (node.test !== void 0) {
-          this.visitExpression(node.test);
-        }
-        if (node.update !== void 0) {
-          this.visitExpression(node.update);
-        }
-        this.visitStatement(node.body);
-      }
-      visitForOfStatement(node) {
-        if (node.left.type === "VariableDeclaration") {
-          this.visitVariableDeclaration(node.left);
-        } else {
-          this.visitPattern(node.left);
-        }
-        this.visitExpression(node.right);
-        this.visitStatement(node.body);
-      }
-      visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-      }
-      visitTryStatement(node) {
-        this.visitStatement(node.block);
-        if (node.handler !== void 0) {
-          this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== void 0) {
-          this.visitStatement(node.finalizer);
-        }
-      }
-      visitCatchClause(node) {
-        if (node.param !== void 0) {
-          this.visitPattern(node.param);
-        }
-        this.visitStatement(node.body);
-      }
-      visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-          this.visitVariableDeclarator(declarator);
-        }
-      }
-      visitVariableDeclarator(node) {
-        this.visitPattern(node.id);
-        if (node.init !== void 0) {
-          this.visitExpression(node.init);
-        }
-      }
-      visitReturnStatement(node) {
-        if (node.argument !== void 0) {
-          this.visitExpression(node.argument);
-        }
-      }
-      visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitExpression(node) {
-        switch (node.type) {
-          case "ArrowFunctionExpression":
-            this.visitArrowFunction(node);
-            return;
-          case "AwaitExpression":
-            this.visitExpression(node.argument);
-            return;
-          case "ArrayExpression":
-            this.visitArrayExpression(node);
-            return;
-          case "ObjectExpression":
-            this.visitObjectExpression(node);
-            return;
-          case "UnaryExpression":
-            this.visitUnaryExpression(node);
-            return;
-          case "BinaryExpression":
-          case "LogicalExpression":
-            this.visitBinaryLikeExpression(node);
-            return;
-          case "ConditionalExpression":
-            this.visitConditionalExpression(node);
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentExpression":
-            this.visitAssignmentExpression(node);
-            return;
-          case "CallExpression":
-            this.visitCallExpression(node);
-            return;
-          case "TemplateLiteral":
-            this.visitTemplateLiteral(node);
-            return;
-          case "Identifier":
-          case "BooleanLiteral":
-          case "NullLiteral":
-          case "NumericLiteral":
-          case "RegexLiteral":
-          case "StringLiteral":
-          case "UndefinedLiteral":
-            return;
-        }
-      }
-      visitArrowFunction(node) {
-        for (const parameter of node.params) {
-          this.visitPattern(parameter);
-        }
-        if (node.body.type === "BlockStatement") {
-          for (const statement of node.body.body) {
-            this.visitStatement(statement);
-          }
-          return;
-        }
-        this.visitExpression(node.body);
-      }
-      visitArrayExpression(node) {
-        for (const element of node.elements) {
-          if (element.type === "SpreadElement") {
-            this.visitExpression(element.argument);
-            continue;
-          }
-          this.visitExpression(element);
-        }
-      }
-      visitObjectExpression(node) {
-        for (const property of node.properties) {
-          if (property.type === "SpreadElement") {
-            this.visitExpression(property.argument);
-            continue;
-          }
-          this.visitProperty(property);
-        }
-      }
-      visitProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-      }
-      visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-      }
-      visitBinaryLikeExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-      }
-      visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-          this.visitExpression(node.property);
-        }
-      }
-      visitAssignmentExpression(node) {
-        this.visitPattern(node.left);
-        this.visitExpression(node.right);
-      }
-      visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        this.reportUnsupportedMethodArgs(node);
-        for (const argument of node.arguments) {
-          this.visitCallArgument(argument);
-        }
-      }
-      visitCallArgument(node) {
-        if (node.type === "SpreadElement") {
-          this.visitExpression(node.argument);
-          return;
-        }
-        this.visitExpression(node);
-      }
-      visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-          this.visitExpression(expression);
-        }
-      }
-      visitPattern(node) {
+      visitAssignmentTarget(node) {
         switch (node.type) {
           case "Identifier":
           case "MetaProperty":
@@ -127988,56 +127667,59 @@ var init_AS012 = __esm({
           case "MemberExpression":
             this.visitMemberExpression(node);
             return;
+          case "AssignmentPattern":
+            this.visitAssignmentTarget(node.left);
+            this.visitExpression(node.right);
+            return;
+          case "RestElement":
+            this.visitAssignmentTarget(node.argument);
+            return;
           case "ArrayPattern":
             for (const element of node.elements) {
-              if (element === null) {
-                continue;
+              if (element !== null) {
+                this.visitAssignmentTarget(element);
               }
-              this.visitPattern(element);
             }
             return;
           case "ObjectPattern":
             for (const property of node.properties) {
               if (property.type === "RestElement") {
-                this.visitPattern(property);
+                this.visitAssignmentTarget(property.argument);
                 continue;
               }
               if (property.computed) {
                 this.visitExpression(property.key);
               }
-              this.visitPattern(property.value);
+              this.visitAssignmentTarget(property.value);
             }
             return;
+        }
+      }
+      visitBindingTarget(node) {
+        switch (node.type) {
           case "AssignmentPattern":
-            this.visitPattern(node.left);
+            this.visitBindingTarget(node.left);
             this.visitExpression(node.right);
             return;
           case "RestElement":
-            this.visitPattern(node.argument);
+            this.visitBindingTarget(node.argument);
+            return;
+          default:
+            this.visitAssignmentTarget(node);
             return;
         }
       }
-      reportUnsupportedMethodArgs(node) {
-        const methodName = getMemberPropertyName(node.callee);
-        if (methodName === void 0) {
-          return;
-        }
-        if (methodName !== "sort") {
-          return;
-        }
-        const comparator = node.arguments[0];
-        if (comparator === void 0 || comparator.type === "SpreadElement") {
-          return;
-        }
-        if (!isSupportedSortComparator(comparator)) {
-          this.report(comparator.span, SORT_MESSAGE);
+      isForbiddenMemberProperty(node) {
+        if (!node.computed) {
+          return node.property.type === "Identifier" && FORBIDDEN_PROPERTY_NAMES.has(node.property.name);
         }
+        return node.property.type === "StringLiteral" && FORBIDDEN_PROPERTY_NAMES.has(node.property.value);
       }
-      report(span, message2) {
+      report(span) {
         this.diagnostics.push({
-          code: "AS012",
+          code: "AS011",
           severity: "error",
-          message: message2,
+          message: MESSAGE3,
           filename: this.filename,
           line: span.start.line,
           column: span.start.column,
@@ -128176,6 +127858,9 @@ var init_AS015 = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             for (const statement of node.body) {
               this.visitStatement(statement);
@@ -128292,6 +127977,12 @@ var init_AS015 = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -128634,7 +128325,7 @@ var init_AS_async_not_needed = __esm({
   "packages/safejs/src/lint/rules/AS-async-not-needed.ts"() {
     "use strict";
     init_parser3();
-    AS_ASYNC_NOT_NEEDED_MESSAGE = "Async arrow functions without await should remove the async keyword.";
+    AS_ASYNC_NOT_NEEDED_MESSAGE = "Async functions without await should remove the async keyword.";
     ASAsyncNotNeededScanner = class {
       constructor(source, filename) {
         this.source = source;
@@ -128654,6 +128345,9 @@ var init_AS_async_not_needed = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitFunctionExpression(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -128694,6 +128388,10 @@ var init_AS_async_not_needed = __esm({
               this.visitArrowFunction(node.declaration, true);
               return;
             }
+            if (node.declaration.type === "FunctionExpression") {
+              this.visitFunctionExpression(node.declaration, true);
+              return;
+            }
             this.visitExpression(node.declaration);
             return;
           case "ImportDeclaration":
@@ -128779,6 +128477,11 @@ var init_AS_async_not_needed = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node, false);
             return;
@@ -128843,8 +128546,8 @@ var init_AS_async_not_needed = __esm({
         }
         this.visitExpression(node.body);
       }
-      visitFunctionExpression(node) {
-        if (node.async && !bodyContainsAwait(node.body)) {
+      visitFunctionExpression(node, isDefaultExport = false) {
+        if (node.async && !isDefaultExport && !bodyContainsAwait(node.body)) {
           this.report(createAsyncKeywordSpan(node.span));
         }
         for (const param of node.params) {
@@ -129000,6 +128703,7 @@ function AS_AWAIT_NON_PROMISE(source, options = {}) {
 }
 function isKnownNonPromiseExpression(node) {
   switch (node.type) {
+    case "FunctionExpression":
     case "ArrowFunctionExpression":
     case "ArrayExpression":
     case "BinaryExpression":
@@ -129037,6 +128741,9 @@ var init_AS_await_non_promise = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -129152,6 +128859,12 @@ var init_AS_await_non_promise = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -129359,6 +129072,9 @@ var init_AS_destructure_null_default = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -129480,6 +129196,12 @@ var init_AS_destructure_null_default = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -129838,6 +129560,12 @@ var init_AS_export_import_meta = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            for (const param of node.params) {
+              this.visitAssignmentTarget(param);
+            }
+            this.visitStatement(node.body);
+            return;
           case "ExportNamedDeclaration":
             this.visitExportNamedDeclaration(node.declaration);
             return;
@@ -129990,7 +129718,15 @@ var init_AS_export_import_meta = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "ArrowFunctionExpression":
+            for (const param of node.params) {
+              this.visitAssignmentTarget(param);
+            }
             if (node.body.type === "BlockStatement") {
               this.visitStatement(node.body);
             } else {
@@ -129998,6 +129734,9 @@ var init_AS_export_import_meta = __esm({
             }
             return;
           case "FunctionExpression":
+            for (const param of node.params) {
+              this.visitAssignmentTarget(param);
+            }
             this.visitStatement(node.body);
             return;
           case "AwaitExpression":
@@ -130194,6 +129933,9 @@ var init_AS_floating_promise = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -130324,6 +130066,12 @@ var init_AS_floating_promise = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -130532,6 +130280,7 @@ var init_AS_floating_promise = __esm({
             this.reportUnhandledLikelyPromiseStatementExpression(node.alternate);
             return;
           case "CallExpression":
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
           case "AwaitExpression":
           case "ArrayExpression":
@@ -130630,6 +130379,11 @@ var init_AS_floating_promise = __esm({
       }
       collectBlockBindings(statements) {
         return statements.flatMap((statement) => {
+          if (statement.type === "FunctionDeclaration") {
+            return [
+              { async: statement.async && !statement.generator, kind: "local", name: statement.id.name }
+            ];
+          }
           if (statement.type === "VariableDeclaration") {
             return this.collectDeclarationBindings(statement);
           }
@@ -130642,7 +130396,7 @@ var init_AS_floating_promise = __esm({
       collectDeclarationBindings(node) {
         return node.declarations.flatMap(
           (declarator) => this.collectDeclaratorBindings(declarator).map((name) => ({
-            async: declarator.init?.type === "ArrowFunctionExpression" && declarator.init.async,
+            async: (declarator.init?.type === "ArrowFunctionExpression" || declarator.init?.type === "FunctionExpression" && !declarator.init.generator) && declarator.init.async,
             kind: "local",
             name
           }))
@@ -130652,13 +130406,17 @@ var init_AS_floating_promise = __esm({
         return this.collectPatternBindingNames(node.id);
       }
       collectArrowFunctionBindings(node) {
-        return node.params.flatMap(
+        const bindings = node.params.flatMap(
           (param) => this.collectParameterBindingNames(param).map((name) => ({
             async: false,
             kind: "local",
             name
           }))
         );
+        if (node.type === "FunctionExpression" && node.id !== void 0) {
+          bindings.unshift({ async: node.async && !node.generator, kind: "local", name: node.id.name });
+        }
+        return bindings;
       }
       collectPatternBindings(node) {
         return this.collectPatternBindingNames(node).map((name) => ({
@@ -130807,6 +130565,9 @@ var init_AS_frontmatter_field_unused = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -130929,6 +130690,12 @@ var init_AS_frontmatter_field_unused = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -131517,6 +131284,7 @@ function inferExpressionKind(expression) {
         return "boolean";
       }
       return void 0;
+    case "FunctionExpression":
     case "ArrowFunctionExpression":
     case "AssignmentExpression":
     case "AwaitExpression":
@@ -131635,6 +131403,9 @@ var init_AS_jsdoc_type = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -131781,6 +131552,12 @@ var init_AS_jsdoc_type = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -132035,6 +131812,9 @@ var init_AS_large_literal = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -132153,6 +131933,12 @@ var init_AS_large_literal = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -132531,7 +132317,7 @@ var init_AS_missing_async = __esm({
   "packages/safejs/src/lint/rules/AS-missing-async.ts"() {
     "use strict";
     init_parser3();
-    AS_MISSING_ASYNC_MESSAGE = "Arrow functions that contain await must be marked async.";
+    AS_MISSING_ASYNC_MESSAGE = "Functions that contain await must be marked async.";
     ASMissingAsyncScanner = class {
       constructor(filename) {
         this.filename = filename;
@@ -132549,6 +132335,9 @@ var init_AS_missing_async = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitFunctionExpression(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -132668,6 +132457,11 @@ var init_AS_missing_async = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -132955,6 +132749,9 @@ var init_AS_mutating_frozen = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -133095,6 +132892,12 @@ var init_AS_mutating_frozen = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -133450,6 +133253,9 @@ var init_AS_needless_template = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -133571,6 +133377,12 @@ var init_AS_needless_template = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -133814,6 +133626,9 @@ var init_AS_shadow_global = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunctionExpression(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -133935,6 +133750,12 @@ var init_AS_shadow_global = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunctionExpression(node);
             return;
@@ -133986,6 +133807,9 @@ var init_AS_shadow_global = __esm({
         }
       }
       visitArrowFunctionExpression(node) {
+        if (node.type !== "ArrowFunctionExpression" && node.id !== void 0) {
+          this.reportIfGlobalShadow(node.id);
+        }
         for (const parameter of node.params) {
           this.visitBindingElement(parameter);
         }
@@ -134262,6 +134086,9 @@ var init_AS_unbounded_loop = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "BlockStatement":
             this.visitBlockStatement(node);
             return;
@@ -134397,6 +134224,12 @@ var init_AS_unbounded_loop = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -134584,6 +134417,9 @@ var init_AS_unreachable = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return false;
           case "BlockStatement":
             return this.visitBlock(node);
           case "ExpressionStatement":
@@ -134628,7 +134464,6 @@ var init_AS_unreachable = __esm({
             this.visitExpression(node.declaration);
             return false;
           case "ImportDeclaration":
-          case "FunctionDeclaration":
           case "EmptyStatement":
             return false;
         }
@@ -134708,6 +134543,12 @@ var init_AS_unreachable = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -134973,6 +134814,9 @@ var init_AS_unused_import = __esm({
       }
       visitStatement(node) {
         switch (node.type) {
+          case "FunctionDeclaration":
+            this.visitArrowFunction(node);
+            return;
           case "ExportNamedDeclaration":
             this.visitVariableDeclaration(node.declaration);
             return;
@@ -135098,9 +134942,15 @@ var init_AS_unused_import = __esm({
       }
       visitExpression(node) {
         switch (node.type) {
+          case "YieldExpression":
+            if (node.argument !== void 0) {
+              this.visitExpression(node.argument);
+            }
+            return;
           case "Identifier":
             this.markRead(node);
             return;
+          case "FunctionExpression":
           case "ArrowFunctionExpression":
             this.visitArrowFunction(node);
             return;
@@ -135333,6 +135183,10 @@ var init_AS_unused_import = __esm({
             bindings.push(...this.collectImportBindings(statement));
             continue;
           }
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push({ kind: "let", name: statement.id.name });
+            continue;
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
             continue;
@@ -135346,6 +135200,9 @@ var init_AS_unused_import = __esm({
       collectBlockBindings(body) {
         const bindings = [];
         for (const statement of body) {
+          if (statement.type === "FunctionDeclaration") {
+            bindings.push({ kind: "let", name: statement.id.name });
+          }
           if (statement.type === "VariableDeclaration") {
             bindings.push(...this.collectDeclarationBindings(statement));
           }
@@ -135354,6 +135211,12 @@ var init_AS_unused_import = __esm({
       }
       collectParameterBindings(node) {
         const bindings = [];
+        if (node.type !== "ArrowFunctionExpression") {
+          bindings.push({ kind: "param", name: "arguments" });
+          if (node.type === "FunctionExpression" && node.id !== void 0) {
+            bindings.push({ kind: "param", name: node.id.name });
+          }
+        }
         for (const parameter of node.params) {
           this.collectBindingNamesFromElement(parameter, "param", bindings);
         }
@@ -135772,7 +135635,6 @@ var init_lint3 = __esm({
     init_AS009();
     init_AS010();
     init_AS011();
-    init_AS012();
     init_AS013();
     init_AS015();
     init_AS_async_not_needed();
@@ -135805,7 +135667,6 @@ var init_lint3 = __esm({
       AS009,
       AS010,
       AS011,
-      AS012,
       AS013,
       AS015,
       AS_IMPORT_CYCLE,
@@ -136193,6 +136054,57 @@ var init_budget2 = __esm({
   }
 });
 
+// packages/safejs/src/interp/arguments.ts
+function createSandboxArguments(values) {
+  const result = /* @__PURE__ */ (function() {
+    return arguments;
+  })();
+  for (let index = 0; index < values.length; index += 1) {
+    result[index] = values[index];
+  }
+  result.length = values.length;
+  Object.defineProperty(result, sandboxArgumentsBrand, { value: true });
+  return result;
+}
+function isSandboxArguments(value) {
+  return typeof value === "object" && value !== null && Object.hasOwn(value, sandboxArgumentsBrand);
+}
+function getSandboxArgumentEntries(value) {
+  return Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
+    ([key3, descriptor]) => "value" in descriptor ? [[key3, descriptor.value]] : []
+  );
+}
+function copySandboxArgumentProperties(source, target, copyValue) {
+  const names = Object.getOwnPropertyNames(source);
+  if (!names.includes("length") || names.indexOf("length") > names.indexOf("callee")) {
+    Reflect.deleteProperty(target, "length");
+  }
+  for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(source))) {
+    if (!("value" in descriptor)) {
+      if (key3 !== "callee") throw new TypeError(`Cannot copy arguments accessor '${key3}'.`);
+      continue;
+    }
+    Object.defineProperty(target, key3, { ...descriptor, value: copyValue(descriptor.value, key3) });
+  }
+  const iterator = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
+  if (iterator === void 0) {
+    Reflect.deleteProperty(target, Symbol.iterator);
+  } else {
+    if (iterator.value !== Array.prototype.values) {
+      throw new TypeError("Cannot copy a replaced arguments iterator.");
+    }
+    Object.defineProperty(target, Symbol.iterator, iterator);
+  }
+  if (!Object.isExtensible(source)) Object.preventExtensions(target);
+}
+var sandboxArgumentsBrand;
+var init_arguments = __esm({
+  "packages/safejs/src/interp/arguments.ts"() {
+    "use strict";
+    sandboxArgumentsBrand = /* @__PURE__ */ Symbol("SandboxArguments");
+  }
+});
+
 // packages/safejs/src/graph-depth.ts
 function assertSandboxDataDepth(depth) {
   if (depth > MAX_DATA_DEPTH) {
@@ -136235,6 +136147,9 @@ function walkGraphDepth(root, rootPath, assertDepth) {
   }
 }
 function graphEntries(value) {
+  if (isSandboxArguments(value)) {
+    return getSandboxArgumentEntries(value).map(([key3, entry]) => [`.${key3}`, entry]);
+  }
   if (Array.isArray(value)) return value.map((entry, index) => [`[${index}]`, entry]);
   if (value instanceof Map) {
     return [...value.entries()].flatMap(([key3, entry], index) => [
@@ -136259,6 +136174,7 @@ var init_graph_depth = __esm({
     "use strict";
     init_shape();
     init_budget2();
+    init_arguments();
     MAX_DATA_DEPTH = 1024;
     SnapshotBudgetError = class extends Error {
       code = "budgetExceeded";
@@ -136278,6 +136194,44 @@ var init_graph_depth = __esm({
   }
 });
 
+// packages/safejs/src/snapshot/arguments.ts
+function serializeArguments(value, serializeValue) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!("value" in descriptor)) {
+      if (key3 !== "callee") throw new TypeError(`Cannot snapshot arguments accessor '${key3}'.`);
+      continue;
+    }
+    properties[key3] = {
+      value: serializeValue(descriptor.value, key3),
+      configurable: descriptor.configurable === true,
+      enumerable: descriptor.enumerable === true,
+      writable: descriptor.writable === true
+    };
+  }
+  const iterator = Object.getOwnPropertyDescriptor(value, Symbol.iterator);
+  if (iterator !== void 0 && iterator.value !== Array.prototype.values) {
+    throw new TypeError("Cannot snapshot a replaced arguments iterator.");
+  }
+  const names = Object.getOwnPropertyNames(value);
+  return {
+    kind: "arguments",
+    extensible: Object.isExtensible(value),
+    lengthBeforeCallee: names.includes("length") && names.indexOf("length") < names.indexOf("callee"),
+    iterator: iterator === void 0 ? null : {
+      configurable: iterator.configurable === true,
+      enumerable: iterator.enumerable === true,
+      writable: iterator.writable === true
+    },
+    properties
+  };
+}
+var init_arguments2 = __esm({
+  "packages/safejs/src/snapshot/arguments.ts"() {
+    "use strict";
+  }
+});
+
 // packages/safejs/src/snapshot/dump-format.ts
 function serializeSafeJSSnapshot(snapshot2) {
   for (const [key3, value] of getEnumerableDataEntries(snapshot2)) {
@@ -136350,7 +136304,12 @@ function serializeHeapReference(value, path189, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (Array.isArray(value)) {
+    if (isSandboxArguments(value)) {
+      state.heap[String(id)] = serializeArguments(value, (entry, key3) => {
+        const serialized = serializeDumpValue(entry, `${path189}.${key3}`, state);
+        return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+      });
+    } else if (Array.isArray(value)) {
       state.heap[String(id)] = {
         kind: "array",
         items: serializeArrayItems(value, path189, state)
@@ -136389,7 +136348,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat36] of stats2.entries()) {
-    if (stat36.count > 1 || stat36.cyclic) {
+    if (stat36.count > 1 || stat36.cyclic || isSandboxArguments(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -136422,7 +136381,7 @@ function collectContainerStats(value, stats2, ancestors) {
   }
   stat36.expanded = true;
   ancestors.add(value);
-  const entries = Array.isArray(value) ? getArrayDataItems(value) : getEnumerableDataValues(value);
+  const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : Array.isArray(value) ? getArrayDataItems(value) : getEnumerableDataValues(value);
   for (const entry of entries) {
     collectContainerStats(entry, stats2, ancestors);
   }
@@ -136464,6 +136423,8 @@ var init_dump_format = __esm({
   "packages/safejs/src/snapshot/dump-format.ts"() {
     "use strict";
     init_graph_depth();
+    init_arguments();
+    init_arguments2();
     DUMP_FORMAT_VERSION = 1;
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
@@ -136497,6 +136458,10 @@ function validateDumpHeap(root, state) {
     const id = parseHeapId(key3, path189);
     addUnique2(heapIds, id, path189);
     const entry = requireRecord3(value, path189);
+    if (entry.kind === "arguments") {
+      validateArgumentsProperties(entry, path189);
+      continue;
+    }
     if (entry.kind === "array") {
       requireArray(entry.items, `${path189}.items`, state);
       continue;
@@ -136601,6 +136566,7 @@ function validateTaggedValue(record, path189, state) {
       requireSafeInteger(record.lastIndex, `${path189}.lastIndex`, 0);
       return;
     case "array":
+    case "arguments":
     case "object":
     case "map":
     case "set":
@@ -136641,6 +136607,55 @@ function validateGeneratorShape(record, path189, state) {
     }
   });
 }
+function validateArgumentsProperties(record, path189) {
+  if (typeof record.extensible !== "boolean") {
+    fail2("invalidType", `${path189}.extensible`, "expected boolean");
+  }
+  if (typeof record.lengthBeforeCallee !== "boolean") {
+    fail2("invalidType", `${path189}.lengthBeforeCallee`, "expected boolean");
+  }
+  const properties = requireRecord3(record.properties, `${path189}.properties`);
+  if (record.iterator !== null) {
+    const iterator = requireRecord3(record.iterator, `${path189}.iterator`);
+    for (const key3 of Object.keys(iterator)) {
+      if (!["configurable", "enumerable", "writable"].includes(key3)) {
+        fail2(
+          "invalidValue",
+          `${path189}.iterator${formatKey(key3)}`,
+          "unknown iterator descriptor field"
+        );
+      }
+    }
+    for (const flag of ["configurable", "enumerable", "writable"]) {
+      if (typeof iterator[flag] !== "boolean")
+        fail2("invalidType", `${path189}.iterator.${flag}`, "expected boolean");
+    }
+  }
+  if (record.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
+    fail2("invalidValue", `${path189}.properties`, "initial length property is required");
+  }
+  for (const [key3, value] of Object.entries(properties)) {
+    const propertyPath = `${path189}.properties${formatKey(key3)}`;
+    if (key3 === "callee")
+      fail2("invalidValue", propertyPath, "strict callee accessor cannot be replaced");
+    const descriptor = requireRecord3(value, propertyPath);
+    for (const field of Object.keys(descriptor)) {
+      if (!["value", "configurable", "enumerable", "writable"].includes(field)) {
+        fail2(
+          "invalidValue",
+          `${propertyPath}${formatKey(field)}`,
+          "unknown property descriptor field"
+        );
+      }
+    }
+    if (!Object.hasOwn(descriptor, "value"))
+      fail2("invalidValue", propertyPath, "property value is required");
+    for (const flag of ["configurable", "enumerable", "writable"]) {
+      if (typeof descriptor[flag] !== "boolean")
+        fail2("invalidType", `${propertyPath}.${flag}`, "expected boolean");
+    }
+  }
+}
 function validateGenericValue(value, path189, depth, state) {
   if (depth > state.limits.maxDepth)
     fail2("budgetExceeded", path189, `exceeds nesting limit ${state.limits.maxDepth}`);
@@ -136752,6 +136767,7 @@ var init_validation = __esm({
     DEFAULT_MAX_STRING_LENGTH = 1e6;
     DEFAULT_MAX_DATA_SIZE = 16e6;
     TAGGED_VALUE_KINDS = /* @__PURE__ */ new Set([
+      "arguments",
       "array",
       "fn",
       "generator",
@@ -137214,7 +137230,7 @@ function measureSandboxData(values) {
       usage += value.source.length + value.flags.length;
       return;
     }
-    const entries = Object.entries(value);
+    const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value) : Object.entries(value);
     usage += entries.length;
     for (const [key3, entry] of entries) {
       usage += key3.length;
@@ -137331,6 +137347,18 @@ function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections
     }
     return copy;
   }
+  if (isSandboxArguments(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxArguments([]);
+    state.seen.set(value, copy);
+    copySandboxArgumentProperties(
+      value,
+      copy,
+      (entry, key3) => copyToSandbox(entry, state, joinPath(path189, key3), cloneSandboxCollections, depth + 1)
+    );
+    return copy;
+  }
   if (isPlainObject10(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) {
@@ -137433,6 +137461,18 @@ function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
     }
     return copy;
   }
+  if (isSandboxArguments(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxArguments([]);
+    state.seen.set(value, copy);
+    copySandboxArgumentProperties(
+      value,
+      copy,
+      (entry, key3) => copyFromSandbox(entry, state, joinPath(path189, key3), options, depth + 1)
+    );
+    return copy;
+  }
   if (isPlainObject10(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) {
@@ -137503,7 +137543,8 @@ function allocateSandboxValue(value, budget, seen) {
     return;
   }
   seen.add(value);
-  for (const entry of Object.values(value)) {
+  const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : Object.values(value);
+  for (const entry of entries) {
     allocateSandboxValue(entry, budget, seen);
   }
 }
@@ -137598,6 +137639,8 @@ var init_values = __esm({
     init_promise_tracker();
     init_parse5();
     init_graph_depth();
+    init_arguments();
+    init_arguments();
     sandboxClosureBrand = /* @__PURE__ */ Symbol("SandboxClosure");
     sandboxGeneratorBrand = /* @__PURE__ */ Symbol("SandboxGenerator");
     sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
@@ -140400,6 +140443,8 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode3)
   const scope = context.scope.child({}, { functionBoundary: true });
   if (node.type !== "ArrowFunctionExpression") {
     scope.declare("this", "const", thisValue);
+    context.budget.allocateArrayLength(args.length);
+    scope.declare("arguments", "let", createSandboxArguments(args));
   }
   await bindParameters(node.params, args, scope, context, evaluateNode3);
   hoistVarDeclarations(node.body, scope);
@@ -145910,6 +145955,7 @@ var init_serialize = __esm({
     "use strict";
     init_hash();
     init_graph_depth();
+    init_arguments2();
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
@@ -152180,7 +152226,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "4.0.58",
+      version: "4.0.59",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",
@@ -152655,7 +152701,8 @@ function formatHelpText(input) {
     `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for command options.")}`,
     "",
     `${text.muted("Learn more about Poe:")}            ${text.link("https://poe.com/api")}`,
-    `${text.muted("GitHub:")}                          ${text.link("https://github.com/poe-platform/poe-code")}`
+    `${text.muted("GitHub:")}                          ${text.link("https://github.com/poe-platform/poe-code")}`,
+    ""
   ].join("\n");
 }
 function formatSubcommandHelp(cmd, helper) {