@poe-platform/safe-js 0.1.164 → 0.1.166

package/dist/safe-js/chunks/{chunk-JPANSO6U.js → chunk-L2WEG3IX.js}

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

package/dist/safe-js/chunks/{chunk-VHZYRV5Q.js → chunk-LVK2NO45.js}

@@ -9486,7 +9486,7 @@ function syncIterator(iterator) {
 }
 
 // packages/safe-js/src/interp/patterns.ts
-async function bindPattern(pattern, value, target, scope, context) {
+async function bindPattern(pattern, value, target, scope, context, reference) {
   switch (pattern.type) {
     case "Identifier":
       bindIdentifier(pattern, value, target, scope);
@@ -9495,15 +9495,15 @@ async function bindPattern(pattern, value, target, scope, context) {
       if ("kind" in target) {
         throw new TypeError("Destructuring declarations cannot bind to member expressions.");
       }
-      return bindMemberExpression(pattern, value, scope, context);
+      return bindMemberExpression(pattern, value, context, reference);
     case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, target, scope, context);
+      return bindAssignmentPattern(pattern, value, target, scope, context, reference);
     case "ArrayPattern":
       return bindArrayPattern(pattern, value, target, scope, context);
     case "ObjectPattern":
       return bindObjectPattern(pattern, value, target, scope, context);
     case "RestElement":
-      return bindPattern(pattern.argument, value, target, scope, context);
+      return bindPattern(pattern.argument, value, target, scope, context, reference);
   }
 }
 function bindIdentifier(pattern, value, target, scope) {
@@ -9522,9 +9522,9 @@ function bindIdentifier(pattern, value, target, scope) {
   }
   scope.declare(pattern.name, target.kind, value);
 }
-async function bindAssignmentPattern(pattern, value, target, scope, context) {
+async function bindAssignmentPattern(pattern, value, target, scope, context, reference) {
   if (value !== void 0) {
-    return bindPattern(pattern.left, value, target, scope, context);
+    return bindPattern(pattern.left, value, target, scope, context, reference);
   }
   const defaultValue = await context.evaluate(
     pattern.right,
@@ -9533,7 +9533,26 @@ async function bindAssignmentPattern(pattern, value, target, scope, context) {
   if (defaultValue.kind !== "normal") {
     return { ok: false, result: defaultValue };
   }
-  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
+  return bindPattern(pattern.left, defaultValue.value, target, scope, context, reference);
+}
+async function bindPatternValue(pattern, readValue, target, scope, context) {
+  let member = pattern;
+  while (member.type === "AssignmentPattern" || member.type === "RestElement")
+    member = member.type === "AssignmentPattern" ? member.left : member.argument;
+  let reference;
+  if ("assign" in target && member.type === "MemberExpression") {
+    const prepared = await prepareMemberReference(member, context);
+    if (!prepared.ok) return prepared;
+    reference = prepared.reference;
+  }
+  let value;
+  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [reference?.object, reference?.key, value]);
+  try {
+    value = (await readValue()).value;
+    return await bindPattern(pattern, value, target, scope, context, reference);
+  } finally {
+    release();
+  }
 }
 async function bindArrayPattern(pattern, value, target, scope, context) {
   const budget = context.budget ?? new Budget();
@@ -9570,20 +9589,22 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
         await next(false);
         continue;
       }
-      let elementValue;
-      if (element.type === "RestElement") {
-        const rest = [];
-        retained = rest;
-        for (let entry = await next(); !done; entry = await next()) {
-          budget.allocateArrayLength(rest.length + 1);
-          rest.push(entry.value);
-        }
-        elementValue = rest;
-      } else {
-        elementValue = (await next()).value;
-      }
-      retained = elementValue;
-      const binding = await bindPattern(element, elementValue, target, scope, context);
+      const binding = await bindPatternValue(
+        element,
+        async () => {
+          if (element.type !== "RestElement") return next();
+          const rest = [];
+          retained = rest;
+          for (let entry = await next(); !done; entry = await next()) {
+            budget.allocateArrayLength(rest.length + 1);
+            rest.push(entry.value);
+          }
+          return { value: rest };
+        },
+        target,
+        scope,
+        context
+      );
       if (!binding.ok) {
         if (!done) {
           done = true;
@@ -9605,15 +9626,15 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
   }
 }
 async function bindObjectPattern(pattern, value, target, scope, context) {
-  if (typeof value !== "object" || value === null) {
-    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  if (value === void 0 || value === null) {
+    throw new TypeError("Object destructuring requires a non-nullish value.");
   }
   const excludedKeys = /* @__PURE__ */ new Set();
   for (const property of pattern.properties) {
     if (property.type === "RestElement") {
-      const binding2 = await bindPattern(
+      const binding2 = await bindPatternValue(
         property,
-        await copyObjectRestValue(value, excludedKeys, context),
+        async () => ({ value: await copyObjectRestValue(value, excludedKeys, context) }),
         target,
         scope,
         context
@@ -9628,9 +9649,9 @@ async function bindObjectPattern(pattern, value, target, scope, context) {
       return key;
     }
     excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
-    const binding = await bindPattern(
+    const binding = await bindPatternValue(
       property.value,
-      await context.getProperty(value, key.value),
+      async () => ({ value: await context.getProperty(value, key.value) }),
       target,
       scope,
       context
@@ -9641,7 +9662,22 @@ async function bindObjectPattern(pattern, value, target, scope, context) {
   }
   return { ok: true };
 }
-async function bindMemberExpression(pattern, value, scope, context) {
+async function bindMemberExpression(pattern, value, context, reference) {
+  if (reference === void 0) {
+    const prepared = await prepareMemberReference(pattern, context);
+    if (!prepared.ok) return prepared;
+    reference = prepared.reference;
+  }
+  if (reference.object === null || reference.object === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
+  }
+  if (!isIndexableValue(reference.object)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  await context.setProperty(reference.object, reference.key, value);
+  return { ok: true };
+}
+async function prepareMemberReference(pattern, context) {
   const object = await context.evaluate(pattern.object);
   if (object.kind !== "normal") {
     return { ok: false, result: object };
@@ -9650,14 +9686,10 @@ async function bindMemberExpression(pattern, value, scope, context) {
   if (property.kind !== "normal") {
     return { ok: false, result: property };
   }
-  if (object.value === null || object.value === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  if (!isIndexableValue(object.value)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  await context.setProperty(object.value, await context.toPropertyKey(property.value), value);
-  return { ok: true };
+  return {
+    ok: true,
+    reference: { object: object.value, key: await context.toPropertyKey(property.value) }
+  };
 }
 async function evaluatePatternKey(property, context) {
   return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
@@ -15992,42 +16024,47 @@ function applyBinaryOperator(node, left, right, context) {
     case ">>>":
       return toNumber(left) >>> toNumber(right);
     case "instanceof":
-      while (isSandboxClosure(right) && right.boundTarget !== void 0) right = right.boundTarget;
-      if (isSandboxPromiseConstructor(right)) return isSandboxPromise(left);
-      if (isSandboxMapConstructor(right) && isSandboxMap(left)) {
-        return true;
-      }
-      if (isFloat32ArrayConstructor(right)) return isFloat32Array(left);
-      if (isDateConstructor(right))
-        return isSandboxDate(left) && getDatePrototype(left, context.budget, context.compilation?.owner) !== null;
-      if (isSandboxSetConstructor(right) && isSandboxSet(left)) {
-        return true;
-      }
-      if (isSandboxErrorConstructorInstance2(left, right)) {
-        return true;
-      }
-      if (isGuestClosure(right)) {
-        if (typeof left !== "object" || left === null) return false;
-        const check = (prototype2) => {
-          if (typeof prototype2 !== "object" || prototype2 === null) {
-            throw new TypeError("Function has a non-object prototype in instanceof check.");
-          }
-          let depth = 0;
-          for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
-            context.budget.visitNode();
-            assertSandboxDataDepth(depth++);
-            if (current === prototype2) return true;
-          }
-          return false;
-        };
-        const prototype = getPropertyValue(right, "prototype", context);
-        return prototype instanceof Promise ? prototype.then(check) : check(prototype);
-      }
-      return false;
+      return evaluateInstanceof(left, right, context);
     case "in":
       return hasSandboxProperty(right, left, context);
   }
 }
+async function evaluateInstanceof(left, right, context) {
+  while (true) {
+    if (right === null || typeof right !== "object" && typeof right !== "function")
+      throw new TypeError("Right-hand side of 'instanceof' must be an object.");
+    const method = await getPropertyValue(right, Symbol.hasInstance, context);
+    if (method !== void 0 && method !== null) {
+      if (!isSandboxClosure(method)) throw new TypeError("Symbol.hasInstance must be callable.");
+      return Boolean(await invokeSandboxClosure(method, [left], context, context.callStack, void 0, right));
+    }
+    if (!isSandboxClosure(right))
+      throw new TypeError("Right-hand side of 'instanceof' is not a function.");
+    if (right.boundTarget === void 0) break;
+    context.budget.visitNode();
+    right = right.boundTarget;
+  }
+  if (isSandboxPromiseConstructor(right)) return isSandboxPromise(left);
+  if (isSandboxMapConstructor(right) && isSandboxMap(left)) return true;
+  if (isFloat32ArrayConstructor(right)) return isFloat32Array(left);
+  if (isDateConstructor(right))
+    return isSandboxDate(left) && getDatePrototype(left, context.budget, context.compilation?.owner) !== null;
+  if (isSandboxSetConstructor(right) && isSandboxSet(left)) return true;
+  if (isSandboxErrorConstructorInstance2(left, right)) return true;
+  if (isGuestClosure(right)) {
+    if (typeof left !== "object" || left === null) return false;
+    const prototype = await getPropertyValue(right, "prototype", context);
+    if (typeof prototype !== "object" || prototype === null)
+      throw new TypeError("Function has a non-object prototype in instanceof check.");
+    let depth = 0;
+    for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
+      context.budget.visitNode();
+      assertSandboxDataDepth(depth++);
+      if (current === prototype) return true;
+    }
+  }
+  return false;
+}
 function createCoercionContext(context) {
   return {
     stack: context.callStack,
@@ -35896,4 +35933,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-VHZYRV5Q.js.map
+//# sourceMappingURL=chunk-LVK2NO45.js.map