poe-code 4.0.57 → 4.0.59

package/packages/safejs/dist/snapshot/validation.js

@@ -6,6 +6,7 @@ const DEFAULT_MAX_ENTRIES = 100_000;
 const DEFAULT_MAX_STRING_LENGTH = 1_000_000;
 const DEFAULT_MAX_DATA_SIZE = 16_000_000;
 const TAGGED_VALUE_KINDS = new Set([
+    "arguments",
     "array",
     "fn",
     "generator",
@@ -57,6 +58,10 @@ function validateDumpHeap(root, state) {
         const id = parseHeapId(key, path);
         addUnique(heapIds, id, path);
         const entry = requireRecord(value, path);
+        if (entry.kind === "arguments") {
+            validateArgumentsProperties(entry, path);
+            continue;
+        }
         if (entry.kind === "array") {
             requireArray(entry.items, `${path}.items`, state);
             continue;
@@ -319,6 +324,7 @@ function validateTaggedValue(record, path, state) {
             requireSafeInteger(record.lastIndex, `${path}.lastIndex`, 0);
             return;
         case "array":
+        case "arguments":
         case "object":
         case "map":
         case "set":
@@ -364,9 +370,11 @@ function validateGeneratorShape(record, path, state) {
 }
 function validateHeapValue(value, path, state) {
     const record = requireRecord(value, path);
-    if (!["array", "object", "map", "set"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
+    if (record.kind === "arguments")
+        validateArgumentsProperties(record, path);
     if (record.kind === "array")
         requireArray(record.items, `${path}.items`, state);
     if (record.kind === "object")
@@ -381,6 +389,47 @@ function validateHeapValue(value, path, state) {
     if (record.kind === "set")
         requireArray(record.values, `${path}.values`, state);
 }
+function validateArgumentsProperties(record, path) {
+    if (typeof record.extensible !== "boolean") {
+        fail("invalidType", `${path}.extensible`, "expected boolean");
+    }
+    if (typeof record.lengthBeforeCallee !== "boolean") {
+        fail("invalidType", `${path}.lengthBeforeCallee`, "expected boolean");
+    }
+    const properties = requireRecord(record.properties, `${path}.properties`);
+    if (record.iterator !== null) {
+        const iterator = requireRecord(record.iterator, `${path}.iterator`);
+        for (const key of Object.keys(iterator)) {
+            if (!["configurable", "enumerable", "writable"].includes(key)) {
+                fail("invalidValue", `${path}.iterator${formatKey(key)}`, "unknown iterator descriptor field");
+            }
+        }
+        for (const flag of ["configurable", "enumerable", "writable"]) {
+            if (typeof iterator[flag] !== "boolean")
+                fail("invalidType", `${path}.iterator.${flag}`, "expected boolean");
+        }
+    }
+    if (record.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
+        fail("invalidValue", `${path}.properties`, "initial length property is required");
+    }
+    for (const [key, value] of Object.entries(properties)) {
+        const propertyPath = `${path}.properties${formatKey(key)}`;
+        if (key === "callee")
+            fail("invalidValue", propertyPath, "strict callee accessor cannot be replaced");
+        const descriptor = requireRecord(value, propertyPath);
+        for (const field of Object.keys(descriptor)) {
+            if (!["value", "configurable", "enumerable", "writable"].includes(field)) {
+                fail("invalidValue", `${propertyPath}${formatKey(field)}`, "unknown property descriptor field");
+            }
+        }
+        if (!Object.hasOwn(descriptor, "value"))
+            fail("invalidValue", propertyPath, "property value is required");
+        for (const flag of ["configurable", "enumerable", "writable"]) {
+            if (typeof descriptor[flag] !== "boolean")
+                fail("invalidType", `${propertyPath}.${flag}`, "expected boolean");
+        }
+    }
+}
 function validateGenerator(record, path, nodeById) {
     if (record.state === "suspended") {
         requireNodeId(record.yieldNodeId, `${path}.yieldNodeId`, nodeById);

package/packages/safejs/dist/lint/rules/AS002.d.ts

@@ -1,13 +0,0 @@
-import { type SourceSpan } from "../../parse/parser.js";
-export type Diagnostic = {
-    code: "AS002";
-    severity: "error";
-    message: string;
-    filename: string;
-    line: number;
-    column: number;
-    span: SourceSpan;
-};
-export declare function AS002(source: string, options?: {
-    filename?: string;
-}): Diagnostic[];

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

@@ -1,525 +0,0 @@
-import { parseModule } from "../../parse/parser.js";
-export function AS002(source, options = {}) {
-    return new AS002Scanner(options.filename ?? "<input>").scan(source);
-}
-class AS002Scanner {
-    filename;
-    diagnostics = [];
-    scopes = [];
-    lambdaStack = [];
-    reportedCaptures = new Set();
-    constructor(filename) {
-        this.filename = filename;
-    }
-    scan(source) {
-        const module = parseModule(source, this.filename);
-        this.visitModule(module);
-        return this.diagnostics;
-    }
-    visitModule(node) {
-        this.withScope(this.collectModuleBindings(node.body), () => {
-            for (const statement of node.body) {
-                this.visitStatement(statement);
-            }
-        });
-    }
-    visitStatement(node) {
-        switch (node.type) {
-            case "BlockStatement":
-                this.visitBlock(node);
-                return;
-            case "ExpressionStatement":
-                this.visitExpressionStatement(node);
-                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":
-                if (node.argument !== undefined) {
-                    this.visitExpression(node.argument);
-                }
-                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;
-        }
-    }
-    visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
-            for (const statement of node.body) {
-                this.visitStatement(statement);
-            }
-        });
-    }
-    visitExpressionStatement(node) {
-        this.visitExpression(node.expression);
-    }
-    visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== undefined) {
-            this.visitStatement(node.alternate);
-        }
-    }
-    visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
-        this.withScope(bindings, () => {
-            if (node.init !== undefined) {
-                if (node.init.type === "VariableDeclaration") {
-                    this.visitVariableDeclaration(node.init);
-                }
-                else {
-                    this.visitExpression(node.init);
-                }
-            }
-            if (node.test !== undefined) {
-                this.visitExpression(node.test);
-            }
-            if (node.update !== undefined) {
-                this.visitExpression(node.update);
-            }
-            this.visitStatement(node.body);
-        });
-    }
-    visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
-        this.withScope(bindings, () => {
-            if (node.left.type === "VariableDeclaration") {
-                this.visitVariableDeclaration(node.left);
-            }
-            else {
-                this.visitAssignmentTarget(node.left);
-            }
-            this.visitExpression(node.right);
-            this.visitStatement(node.body);
-        });
-    }
-    visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-    }
-    visitTryStatement(node) {
-        this.visitBlock(node.block);
-        if (node.handler !== undefined) {
-            this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== undefined) {
-            this.visitBlock(node.finalizer);
-        }
-    }
-    visitCatchClause(node) {
-        this.withScope(this.collectCatchBindings(node), () => {
-            if (node.param !== undefined) {
-                this.visitBindingPattern(node.param);
-            }
-            this.visitBlock(node.body);
-        });
-    }
-    visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-    }
-    visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-            this.visitVariableDeclarator(declarator);
-        }
-    }
-    visitVariableDeclarator(node) {
-        this.visitBindingPattern(node.id);
-        if (node.init !== undefined) {
-            this.visitExpression(node.init);
-        }
-    }
-    visitExpression(node) {
-        switch (node.type) {
-            case "Identifier":
-                this.visitIdentifier(node);
-                return;
-            case "ArrowFunctionExpression":
-                this.visitArrowFunction(node);
-                return;
-            case "AwaitExpression":
-                this.visitAwaitExpression(node);
-                return;
-            case "ArrayExpression":
-                this.visitArrayExpression(node);
-                return;
-            case "ObjectExpression":
-                this.visitObjectExpression(node);
-                return;
-            case "UnaryExpression":
-                this.visitUnaryExpression(node);
-                return;
-            case "BinaryExpression":
-                this.visitBinaryExpression(node);
-                return;
-            case "LogicalExpression":
-                this.visitLogicalExpression(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 "BooleanLiteral":
-            case "NullLiteral":
-            case "NumericLiteral":
-            case "StringLiteral":
-            case "UndefinedLiteral":
-                return;
-        }
-    }
-    visitArrowFunction(node) {
-        const lambdaContext = {
-            depth: this.lambdaStack.length + 1,
-            nodeId: node.nodeId ?? -1
-        };
-        this.lambdaStack.push(lambdaContext);
-        this.withScope(this.collectParameterBindings(node), () => {
-            for (const parameter of node.params) {
-                this.visitBindingElement(parameter);
-            }
-            if (node.body.type === "BlockStatement") {
-                this.visitBlock(node.body);
-            }
-            else {
-                this.visitExpression(node.body);
-            }
-        });
-        this.lambdaStack.pop();
-    }
-    visitAwaitExpression(node) {
-        this.visitExpression(node.argument);
-    }
-    visitArrayExpression(node) {
-        for (const element of node.elements) {
-            if (element?.type === "SpreadElement") {
-                this.visitSpreadElement(element);
-                continue;
-            }
-            if (element !== undefined) {
-                this.visitExpression(element);
-            }
-        }
-    }
-    visitObjectExpression(node) {
-        for (const property of node.properties) {
-            if (property.type === "SpreadElement") {
-                this.visitSpreadElement(property);
-                continue;
-            }
-            this.visitProperty(property);
-        }
-    }
-    visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-    }
-    visitBinaryExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-    }
-    visitLogicalExpression(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.visitAssignmentTarget(node.left);
-        this.visitExpression(node.right);
-    }
-    visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        for (const argument of node.arguments) {
-            if (argument.type === "SpreadElement") {
-                this.visitSpreadElement(argument);
-                continue;
-            }
-            this.visitExpression(argument);
-        }
-    }
-    visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-            this.visitExpression(expression);
-        }
-    }
-    visitProperty(node) {
-        if (node.computed) {
-            this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-    }
-    visitSpreadElement(node) {
-        this.visitExpression(node.argument);
-    }
-    visitBindingElement(node) {
-        switch (node.type) {
-            case "AssignmentPattern":
-                this.visitBindingPattern(node.left);
-                this.visitExpression(node.right);
-                return;
-            case "RestElement":
-                this.visitBindingPattern(node.argument);
-                return;
-            default:
-                this.visitBindingPattern(node);
-                return;
-        }
-    }
-    visitBindingPattern(node) {
-        switch (node.type) {
-            case "Identifier":
-                return;
-            case "MemberExpression":
-                this.visitMemberExpression(node);
-                return;
-            case "ArrayPattern":
-                for (const element of node.elements) {
-                    if (element !== null) {
-                        this.visitBindingElement(element);
-                    }
-                }
-                return;
-            case "ObjectPattern":
-                for (const property of node.properties) {
-                    if (property.type === "RestElement") {
-                        this.visitBindingPattern(property.argument);
-                        continue;
-                    }
-                    this.visitAssignmentProperty(property);
-                }
-                return;
-        }
-    }
-    visitAssignmentProperty(node) {
-        if (node.computed) {
-            this.visitExpression(node.key);
-        }
-        this.visitBindingElement(node.value);
-    }
-    visitAssignmentTarget(node) {
-        switch (node.type) {
-            case "AssignmentPattern":
-                this.visitAssignmentTarget(node.left);
-                this.visitExpression(node.right);
-                return;
-            case "RestElement":
-                this.visitAssignmentTarget(node.argument);
-                return;
-            case "Identifier":
-                this.visitIdentifier(node);
-                return;
-            case "MemberExpression":
-                this.visitMemberExpression(node);
-                return;
-            case "ArrayPattern":
-                for (const element of node.elements) {
-                    if (element === null) {
-                        continue;
-                    }
-                    this.visitAssignmentTarget(element);
-                }
-                return;
-            case "ObjectPattern":
-                for (const property of node.properties) {
-                    if (property.type === "RestElement") {
-                        this.visitAssignmentTarget(property);
-                        continue;
-                    }
-                    if (property.computed) {
-                        this.visitExpression(property.key);
-                    }
-                    this.visitAssignmentTarget(property.value);
-                }
-                return;
-        }
-    }
-    visitIdentifier(node) {
-        const currentLambda = this.lambdaStack[this.lambdaStack.length - 1];
-        if (currentLambda === undefined) {
-            return;
-        }
-        const binding = this.resolveBinding(node.name);
-        if (binding === undefined ||
-            binding.kind !== "let" ||
-            binding.ownerLambdaDepth >= currentLambda.depth) {
-            return;
-        }
-        const captureKey = `${currentLambda.nodeId}:${binding.name}`;
-        if (this.reportedCaptures.has(captureKey)) {
-            return;
-        }
-        this.reportedCaptures.add(captureKey);
-        this.diagnostics.push({
-            code: "AS002",
-            severity: "error",
-            message: `Lambda closes over let-bound '${binding.name}' from an outer scope. Change it to const or pass it as a parameter.`,
-            filename: this.filename,
-            line: node.span.start.line,
-            column: node.span.start.column,
-            span: node.span
-        });
-    }
-    withScope(bindings, visit) {
-        const scope = new Map();
-        for (const binding of bindings) {
-            scope.set(binding.name, binding);
-        }
-        this.scopes.push(scope);
-        visit();
-        this.scopes.pop();
-    }
-    resolveBinding(name) {
-        for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
-            const binding = this.scopes[index]?.get(name);
-            if (binding !== undefined) {
-                return binding;
-            }
-        }
-        return undefined;
-    }
-    collectModuleBindings(body) {
-        const bindings = [];
-        for (const statement of body) {
-            if (statement.type === "ImportDeclaration") {
-                bindings.push(...this.collectImportBindings(statement));
-                continue;
-            }
-            if (statement.type === "VariableDeclaration") {
-                bindings.push(...this.collectDeclarationBindings(statement));
-                continue;
-            }
-            if (statement.type === "ExportNamedDeclaration") {
-                bindings.push(...this.collectDeclarationBindings(statement.declaration));
-            }
-        }
-        return bindings;
-    }
-    collectBlockBindings(body) {
-        const bindings = [];
-        for (const statement of body) {
-            if (statement.type === "VariableDeclaration") {
-                bindings.push(...this.collectDeclarationBindings(statement));
-            }
-        }
-        return bindings;
-    }
-    collectParameterBindings(node) {
-        const bindings = [];
-        for (const parameter of node.params) {
-            this.collectBindingNamesFromElement(parameter, "param", bindings);
-        }
-        return bindings;
-    }
-    collectDeclarationBindings(node) {
-        const bindings = [];
-        for (const declarator of node.declarations) {
-            this.collectBindingNamesFromPattern(declarator.id, node.kind, bindings);
-        }
-        return bindings;
-    }
-    collectCatchBindings(node) {
-        const bindings = [];
-        if (node.param !== undefined) {
-            this.collectBindingNamesFromPattern(node.param, "let", bindings);
-        }
-        return bindings;
-    }
-    collectImportBindings(node) {
-        const bindings = [];
-        for (const specifier of node.specifiers) {
-            bindings.push(this.createBinding(specifier.local.name, "import"));
-        }
-        return bindings;
-    }
-    collectBindingNamesFromElement(node, kind, bindings) {
-        switch (node.type) {
-            case "AssignmentPattern":
-                this.collectBindingNamesFromPattern(node.left, kind, bindings);
-                return;
-            case "RestElement":
-                this.collectBindingNamesFromPattern(node.argument, kind, bindings);
-                return;
-            default:
-                this.collectBindingNamesFromPattern(node, kind, bindings);
-                return;
-        }
-    }
-    collectBindingNamesFromPattern(node, kind, bindings) {
-        switch (node.type) {
-            case "Identifier":
-                bindings.push(this.createBinding(node.name, kind));
-                return;
-            case "MemberExpression":
-                return;
-            case "ArrayPattern":
-                for (const element of node.elements) {
-                    if (element !== null) {
-                        this.collectBindingNamesFromElement(element, kind, bindings);
-                    }
-                }
-                return;
-            case "ObjectPattern":
-                for (const property of node.properties) {
-                    if (property.type === "RestElement") {
-                        this.collectBindingNamesFromPattern(property.argument, kind, bindings);
-                        continue;
-                    }
-                    this.collectBindingNamesFromElement(property.value, kind, bindings);
-                }
-                return;
-        }
-    }
-    createBinding(name, kind) {
-        return {
-            kind,
-            name,
-            ownerLambdaDepth: this.lambdaStack.length
-        };
-    }
-}

package/packages/safejs/dist/lint/rules/AS012.d.ts

@@ -1,13 +0,0 @@
-import { type SourceSpan } from "../../parse/parser.js";
-export type Diagnostic = {
-    code: "AS012";
-    severity: "error";
-    message: string;
-    filename: string;
-    line: number;
-    column: number;
-    span: SourceSpan;
-};
-export declare function AS012(source: string, options?: {
-    filename?: string;
-}): Diagnostic[];