@poe-platform/safe-js 0.1.139 → 0.1.141

package/dist/safe-js/chunks/{chunk-I5E3GOL7.js → chunk-HEQEBF3T.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-EZAX76DY.js";
+} from "./chunk-Q6QTL7UZ.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-I5E3GOL7.js.map
+//# sourceMappingURL=chunk-HEQEBF3T.js.map

package/dist/safe-js/chunks/{chunk-EZAX76DY.js → chunk-Q6QTL7UZ.js}

@@ -3408,7 +3408,7 @@ var Parser = class {
       });
     });
   }
-  parseFunctionParts(generator, lexicalContext) {
+  parseFunctionParts(generator, lexicalContext, accessor) {
     return this.withLexicalContext(lexicalContext, () => {
       const params = this.withScope(() => {
         const parsed = this.parseArrowParameters();
@@ -3416,7 +3416,24 @@ var Parser = class {
           for (const identifier of boundIdentifiers(param)) this.declareBinding(identifier);
         return parsed;
       });
+      if (accessor === "get" && params.length !== 0)
+        throw new Error("A getter cannot have parameters.");
+      if (accessor === "set" && (params.length !== 1 || params[0]?.type === "RestElement"))
+        throw new Error("A setter must have exactly one non-rest parameter.");
+      const bodyTokenIndex = this.index;
       const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
+      if (accessor === "set" && params[0]?.type !== "Identifier") {
+        let directiveTokenIndex = bodyTokenIndex + 1;
+        for (const statement of body.body) {
+          const token = this.tokens[directiveTokenIndex];
+          if (statement.type !== "ExpressionStatement" || statement.expression.type !== "StringLiteral" || token?.type !== "string" || statement.span.start.offset !== token.start.offset || statement.span.end.offset !== token.end.offset) break;
+          if (statement.expression.raw === '"use strict"' || statement.expression.raw === "'use strict'")
+            throw new Error(
+              "A setter with a non-simple parameter cannot contain a use strict directive."
+            );
+          directiveTokenIndex += this.tokens[directiveTokenIndex + 1]?.value === ";" ? 2 : 1;
+        }
+      }
       return { params, body };
     });
   }
@@ -3447,8 +3464,14 @@ var Parser = class {
     }
     const generator = this.consumePunctuator("*") !== void 0;
     if (async && generator) throw new DisallowedSyntaxError("async generator", methodStart.start);
-    if ((this.currentToken().value === "get" || this.currentToken().value === "set") && this.isObjectMethodStart())
-      throw new DisallowedSyntaxError("class accessor", this.currentToken().start);
+    let accessor;
+    const modifier = this.currentToken();
+    if ((modifier.value === "get" || modifier.value === "set") && this.isObjectMethodStart()) {
+      if (async || generator || modifier.end.offset - modifier.start.offset !== modifier.value.length)
+        throw unexpectedTokenError(modifier);
+      accessor = modifier.value;
+      this.index++;
+    }
     const computed = this.consumePunctuator("[") !== void 0;
     const key = computed ? this.parseExpression({ allowSequence: true }).node : this.currentToken().type === "string" ? createStringLiteral(this.tokens[this.index++]) : this.currentToken().type === "numeric" ? createNumericLiteral(this.tokens[this.index++]) : this.parseIdentifierName();
     if (computed) this.expectPunctuator("]");
@@ -3456,7 +3479,7 @@ var Parser = class {
     if (isStatic && name === "prototype") throw new Error("A static class element cannot be named prototype.");
     if (this.currentToken().value === "(") {
       const constructor = !isStatic && name === "constructor";
-      if (constructor && (async || generator)) throw new Error("A class constructor cannot be async or a generator.");
+      if (constructor && (async || generator || accessor !== void 0)) throw new Error("A class constructor must be an ordinary method.");
       const { params, body } = this.parseFunctionParts(generator, {
         newTarget: true,
         superProperty: true,
@@ -3465,7 +3488,7 @@ var Parser = class {
         return: true,
         await: async,
         strictAwait: true
-      });
+      }, accessor);
       const value2 = this.withFunctionSource({
         type: "FunctionExpression",
         async,
@@ -3480,7 +3503,7 @@ var Parser = class {
         key,
         computed,
         static: isStatic,
-        kind: constructor ? "constructor" : "method",
+        kind: accessor ?? (constructor ? "constructor" : "method"),
         value: value2,
         span: createSpan2(start.start, value2.span.end)
       };
@@ -4728,7 +4751,10 @@ var Parser = class {
     return (propertyToken.type === "identifier" || propertyToken.type === "keyword" || propertyToken.type === "numeric" || propertyToken.type === "string") && this.peekToken(2).type === "punctuator" && this.peekToken(2).value === "(";
   }
   parseObjectMethod(asyncToken, methodStart) {
-    const { params, body } = this.parseFunctionParts(false, ordinaryFunctionContext);
+    const { params, body } = this.parseFunctionParts(false, {
+      ...ordinaryFunctionContext,
+      superProperty: true
+    });
     return this.withFunctionSource({
       type: "FunctionExpression",
       async: asyncToken !== void 0,
@@ -26516,8 +26542,15 @@ async function evaluateClass(node, context, evaluateNode2, callContext) {
       } else {
         const home = element.static ? constructor : prototype;
         const method = createInterpretedClosure(element.value, classContext, evaluateNode2, home);
-        Object.defineProperty(materializeFunctionProperties(method), "name", { value: key });
-        Object.defineProperty(element.static ? properties : prototype, key, { value: method, configurable: true, writable: true, enumerable: false });
+        const accessor = element.kind === "get" || element.kind === "set" ? element.kind : void 0;
+        Object.defineProperty(materializeFunctionProperties(method), "name", {
+          value: accessor === void 0 ? key : `${accessor} ${key}`
+        });
+        Object.defineProperty(
+          element.static ? properties : prototype,
+          key,
+          accessor === void 0 ? { value: method, configurable: true, writable: true, enumerable: false } : { [accessor]: accessorAdapter(method, accessor), configurable: true, enumerable: false }
+        );
       }
     }
     if (node.id !== void 0) scope.declare(node.id.name, "const", constructor);
@@ -28930,7 +28963,11 @@ async function evaluateObjectExpression(node, context) {
       const releaseKey = retainValues(context.budget, () => [key.value]);
       let value;
       try {
-        value = await evaluateNode(property.value, { ...context, inferredName: String(key.value) });
+        value = await evaluateNode(property.value, {
+          ...context,
+          inferredName: String(key.value),
+          ...property.value.type === "FunctionExpression" && property.value.method === true ? { functionEnvironment: { homeObject: object } } : {}
+        });
       } finally {
         releaseKey();
       }
@@ -31540,7 +31577,12 @@ async function evaluateFunctionExpression(node, context, evaluateNode2) {
     return {
       kind: "normal",
       hasValue: true,
-      value: createInterpretedClosure(node, context, evaluateNode2)
+      value: createInterpretedClosure(
+        node,
+        context,
+        evaluateNode2,
+        node.method === true ? context.functionEnvironment?.homeObject : void 0
+      )
     };
   }
   const wrapperScope = context.scope.child();
@@ -35469,4 +35511,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-EZAX76DY.js.map
+//# sourceMappingURL=chunk-Q6QTL7UZ.js.map