@poe-platform/safe-js 0.1.324 → 0.1.326

package/dist/safe-js/chunks/{chunk-WWBX6TN2.js → chunk-CIIKFZ3V.js}

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

package/dist/safe-js/chunks/{chunk-CMWXZ76K.js → chunk-FPU2PHHJ.js}

@@ -14883,7 +14883,7 @@ function createFloat32ArrayPrototypes(budget, constructor) {
     getters.push(getter);
     Object.defineProperty(shared, key, { get: accessorAdapter(getter, "get"), configurable: true });
   }
-  for (const key of ["set", "slice", "subarray", "fill"])
+  for (const key of ["set", "slice", "subarray", "fill", "copyWithin", "reverse"])
     Object.defineProperty(shared, key, { value: getFloat32Member(new Float32Array(0), key, budget, constructor), writable: true, configurable: true });
   const arrayPrototype = resolveIntrinsicIdentity(budget, '["Array","prototype"]');
   Object.defineProperty(shared, "toString", { value: getSandboxDataProperty(arrayPrototype, "toString", budget), writable: true, configurable: true });
@@ -14965,17 +14965,35 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
   if (key === "byteLength") return storage.length * 4;
   if (key === "byteOffset") return storage.byteOffset;
   if (key === "BYTES_PER_ELEMENT") return 4;
-  if (!["set", "slice", "subarray", "fill"].includes(key)) return void 0;
+  if (!["set", "slice", "subarray", "fill", "copyWithin", "reverse"].includes(key)) return void 0;
   return createSandboxClosure({
     guest: true,
     sandbox: true,
     name: key,
-    length: key === "set" || key === "fill" ? 1 : 2,
+    length: key === "reverse" ? 0 : key === "set" || key === "fill" ? 1 : 2,
     call: (args, context) => {
       const receiver = context?.thisValue;
       if (!isFloat32Array(receiver))
         throw new TypeError(`Float32Array#${key} requires a Float32Array receiver.`);
-      const storage2 = float32Storage(receiver, key === "slice" || key === "fill");
+      const storage2 = float32Storage(receiver, key === "slice" || key === "fill" || key === "copyWithin" || key === "reverse");
+      if (key === "reverse") {
+        const release = retainValues(budget, () => [receiver, ...args]);
+        try {
+          const bytes = new Uint8Array(storage2.buffer, storage2.byteOffset, storage2.length * 4);
+          for (let lower = 0; lower < Math.floor(storage2.length / 2); lower++) {
+            const upper = storage2.length - lower - 1;
+            for (let offset = 0; offset < 4; offset++) {
+              budget.visitNode();
+              const saved = bytes[lower * 4 + offset];
+              bytes[lower * 4 + offset] = bytes[upper * 4 + offset];
+              bytes[upper * 4 + offset] = saved;
+            }
+          }
+          return receiver;
+        } finally {
+          release();
+        }
+      }
       const bridge = {
         ...context,
         stack: context?.stack ?? [],
@@ -14986,6 +15004,36 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
         }),
         invokeClosure: context?.invokeClosure ?? ((callee, values, thisValue, construct) => invokeBuiltinClosure(callee, values, budget, context, thisValue, construct))
       };
+      if (key === "copyWithin") {
+        return (async () => {
+          const release = retainValues(budget, () => [receiver, ...args]);
+          try {
+            const target = relativeIndex(await sandboxNumber(args[0], budget, bridge), storage2.length);
+            const start = relativeIndex(await sandboxNumber(args[1], budget, bridge), storage2.length);
+            const end = args[2] === void 0 ? storage2.length : relativeIndex(await sandboxNumber(args[2], budget, bridge), storage2.length);
+            let count = Math.min(end - start, storage2.length - target);
+            if (count > 0) {
+              const current = float32Storage(receiver, true);
+              count = Math.min(count, current.length - start, current.length - target);
+              if (count > 0) {
+                const bytes = new Uint8Array(current.buffer, current.byteOffset, current.length * 4);
+                const direction = start < target && target < start + count ? -1 : 1;
+                let from = start * 4 + (direction < 0 ? count * 4 - 1 : 0);
+                let to = target * 4 + (direction < 0 ? count * 4 - 1 : 0);
+                for (let remaining = count * 4; remaining > 0; remaining--) {
+                  budget.visitNode();
+                  bytes[to] = bytes[from];
+                  from += direction;
+                  to += direction;
+                }
+              }
+            }
+            return receiver;
+          } finally {
+            release();
+          }
+        })();
+      }
       if (key === "fill") {
         return (async () => {
           const release = retainValues(budget, () => [receiver, ...args]);
@@ -42364,4 +42412,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CMWXZ76K.js.map
+//# sourceMappingURL=chunk-FPU2PHHJ.js.map