@poe-platform/safe-js 0.1.373 → 0.1.375

package/dist/safe-js/chunks/{chunk-SCIKHRZS.js → chunk-M22DVZY3.js}

@@ -6887,6 +6887,24 @@ function arrayBufferDataProperties(value) {
   });
 }
 
+// packages/safe-js/src/interp/float16-array.ts
+import { Float16Array as PonyfillFloat16Array } from "@petamoriken/float16";
+var float16BackingViews = /* @__PURE__ */ new WeakMap();
+var FallbackFloat16Array = class Float16Array extends PonyfillFloat16Array {
+  constructor(input, byteOffset, length) {
+    super(input, byteOffset, length);
+    if (Object.getPrototypeOf(this) !== Float16Array.prototype) return;
+    const buffer = this.buffer;
+    float16BackingViews.set(this, new Uint16Array(
+      buffer,
+      this.byteOffset,
+      input === buffer && length === void 0 ? void 0 : this.length
+    ));
+  }
+};
+Object.defineProperty(FallbackFloat16Array, "name", { value: "Float16Array", configurable: true });
+var Float16Array2 = Object.getOwnPropertyDescriptor(globalThis, "Float16Array")?.value ?? FallbackFloat16Array;
+
 // packages/safe-js/src/interp/typed-array-constructors.ts
 var numericTypedArrayConstructors = {
   Float32Array,
@@ -6899,7 +6917,8 @@ var numericTypedArrayConstructors = {
   Uint32Array,
   Float64Array,
   BigInt64Array,
-  BigUint64Array
+  BigUint64Array,
+  Float16Array: Float16Array2
 };
 
 // packages/safe-js/src/interp/typed-array.ts
@@ -6934,23 +6953,27 @@ function restoreTypedArrayView(buffer, byteOffset, length, budget, Native = Floa
   }
 }
 function isNumericTypedArray(value) {
+  if (typeof value === "object" && value !== null && float16BackingViews.has(value))
+    return Object.getPrototypeOf(value) === Float16Array2.prototype;
   if (!ArrayBuffer.isView(value)) return false;
   const tag = Reflect.apply(readTag, value, []);
   return Object.hasOwn(numericTypedArrayConstructors, tag) && Object.getPrototypeOf(value) === numericTypedArrayConstructors[tag].prototype;
 }
 function typedArrayStorage(value, requireInBounds = false) {
-  if (requireInBounds) Reflect.apply(createValuesIterator, value, []);
-  const buffer = Reflect.apply(readBuffer, value, []);
+  const backingView = float16BackingViews.get(value);
+  const view = backingView ?? value;
+  if (requireInBounds) Reflect.apply(createValuesIterator, view, []);
+  const buffer = Reflect.apply(readBuffer, view, []);
   if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype) {
     throw new TypeError("Float32Array requires a non-shared ArrayBuffer.");
   }
-  const Native = numericTypedArrayConstructors[Reflect.apply(readTag, value, [])];
+  const Native = backingView === void 0 ? numericTypedArrayConstructors[Reflect.apply(readTag, value, [])] : Float16Array2;
   return {
     Native,
     elementSize: Native.BYTES_PER_ELEMENT,
     buffer,
-    byteOffset: Reflect.apply(readOffset, value, []),
-    length: Reflect.apply(readLength2, value, []),
+    byteOffset: Reflect.apply(readOffset, view, []),
+    length: Reflect.apply(readLength2, view, []),
     byteLength: Reflect.apply(bufferLength, buffer, [])
   };
 }
@@ -11375,6 +11398,31 @@ var constructors = /* @__PURE__ */ new WeakMap();
 function hasBigIntContent(Native) {
   return Native === BigInt64Array || Native === BigUint64Array;
 }
+function copyTypedArrayElements(target, source, offset, budget) {
+  if (!float16BackingViews.has(target) && !float16BackingViews.has(source)) {
+    Reflect.apply(Float32Array.prototype.set, target, [source, offset]);
+    return;
+  }
+  const to = typedArrayStorage(target, true);
+  const from = typedArrayStorage(source, true);
+  if (hasBigIntContent(to.Native) !== hasBigIntContent(from.Native))
+    throw new TypeError("Cannot mix BigInt and Number typed arrays.");
+  if (to.Native === from.Native) {
+    new Uint8Array(to.buffer, to.byteOffset + offset * to.elementSize, from.length * from.elementSize).set(new Uint8Array(from.buffer, from.byteOffset, from.length * from.elementSize));
+    return;
+  }
+  if (to.buffer === from.buffer) {
+    checkTypedArrayAllocation(from.length, budget, from.elementSize);
+    const copy = new from.Native(from.length);
+    const copyStorage = typedArrayStorage(copy);
+    new Uint8Array(copyStorage.buffer).set(new Uint8Array(from.buffer, from.byteOffset, from.length * from.elementSize));
+    source = copy;
+  }
+  for (let index = 0; index < from.length; index++) {
+    budget.visitNode();
+    target[offset + index] = source[index];
+  }
+}
 function typedArrayElement(value, Native, budget, context) {
   return hasBigIntContent(Native) ? sandboxBigInt(value, budget, context) : sandboxNumber(value, budget, context);
 }
@@ -11493,7 +11541,12 @@ function allocateTypedArray(source, budget, Native) {
   if (Array.isArray(source) || isNumericTypedArray(source)) {
     const length2 = isNumericTypedArray(source) ? typedArrayStorage(source).length : source.length;
     checkTypedArrayAllocation(length2, budget, Native.BYTES_PER_ELEMENT);
-    if (isNumericTypedArray(source)) return Reflect.construct(Native, [source]);
+    if (isNumericTypedArray(source)) {
+      typedArrayStorage(source, true);
+      const result2 = new Native(length2);
+      copyTypedArrayElements(result2, source, 0, budget);
+      return result2;
+    }
     const result = new Native(length2);
     for (let index = 0; index < length2; index += 1) {
       budget.visitNode();
@@ -12081,7 +12134,7 @@ function getTypedArrayMember(value, property, budget, bindings) {
               length = Number.isNaN(size) || size <= 0 ? 0 : Math.min(Math.trunc(size), Number.MAX_SAFE_INTEGER);
             }
             if (offset + length > targetStorage.length) throw new RangeError("Float32Array#set source is out of bounds.");
-            if (isNumericTypedArray(source)) Reflect.apply(Float32Array.prototype.set, receiver, [source, offset]);
+            if (isNumericTypedArray(source)) copyTypedArrayElements(receiver, source, offset, budget);
             else for (let index = 0; index < length; index++) {
               budget.visitNode();
               current = await bridge.getProperty(sourceObject, String(index));
@@ -26162,7 +26215,7 @@ function createArrayBufferGlobal(budget) {
       sandbox: true,
       name: "isView",
       length: 1,
-      call: (args) => ArrayBuffer.isView(args[0])
+      call: (args) => ArrayBuffer.isView(args[0]) || isNumericTypedArray(args[0])
     })
   });
   Object.defineProperties(prototype, {
@@ -28552,8 +28605,13 @@ function measureSandboxData(values, options = {}) {
     if (Array.isArray(value)) {
       usage += value.length;
       if (hasManagedDescriptors(value)) {
-        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        const descriptors3 = [];
+        for (const key of Object.getOwnPropertyNames(value)) {
           if (key === "length") continue;
+          const descriptor = Object.getOwnPropertyDescriptor(value, key);
+          if (descriptor !== void 0) descriptors3.push([key, descriptor]);
+        }
+        for (const [key, descriptor] of descriptors3) {
           usage += key.length + 1;
           if ("value" in descriptor) visit(descriptor.value, depth + 1);
           else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
@@ -29064,7 +29122,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (options.unwrapHostObject === void 0) throw new TypeError("Live capabilities require their owning realm bridge.");
     return options.unwrapHostObject(value);
   }
-  if (nodeTypes.isProxy(value)) throw new TypeError("Unsupported proxy sandbox value.");
+  if (nodeTypes.isProxy(value) && !isNumericTypedArray(value)) throw new TypeError("Unsupported proxy sandbox value.");
   if (sandboxErrorTypes.has(value) && hasExplicitSandboxPrototype(value)) {
     const prototype = getSandboxPrototype(value);
     let nativePrototype = null;
@@ -43642,4 +43700,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-SCIKHRZS.js.map
+//# sourceMappingURL=chunk-M22DVZY3.js.map