@poe-platform/safe-js 0.1.374 → 0.1.376

package/dist/safe-js/chunks/{chunk-35DAUDMZ.js → chunk-7UITTELW.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, [])
   };
 }
@@ -8388,8 +8411,9 @@ function getSandboxDataProperty(value, key, budget) {
   }
   return void 0;
 }
-function setSandboxPrototype(value, prototype, budget) {
+function setSandboxPrototype(value, prototype, budget, throwOnFailure = true) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
+    if (!throwOnFailure) return false;
     throw new TypeError("Object.prototype has an immutable null prototype.");
   }
   if (!Array.isArray(value) && !isSandboxGenerator(value) && !isSandboxDate(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isSandboxGenerator(prototype) && !isSandboxDate(prototype) && !isSandboxPromise(prototype) && !isSandboxRegex(prototype) && !isSandboxMap(prototype) && !isSandboxSet(prototype) && !isPrototypeRecord(prototype)) {
@@ -8399,18 +8423,23 @@ function setSandboxPrototype(value, prototype, budget) {
   }
   if (getSandboxPrototype(value, budget) === prototype) {
     if (prototype === null) prototypes.set(value, null);
-    return;
+    return true;
   }
   if (!Object.isExtensible(isSandboxGenerator(value) ? getGeneratorProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value)) {
+    if (!throwOnFailure) return false;
     throw new TypeError("Cannot change the prototype of a non-extensible object.");
   }
   let depth = 0;
   for (let current = prototype; current !== null; current = getSandboxPrototype(current, budget)) {
     budget?.visitNode();
     assertSandboxDataDepth(depth++);
-    if (current === value) throw new TypeError("Cyclic prototype value.");
+    if (current === value) {
+      if (!throwOnFailure) return false;
+      throw new TypeError("Cyclic prototype value.");
+    }
   }
   prototypes.set(value, prototype);
+  return true;
 }
 function isPrototypeRecord(value) {
   if (isSandboxDataView(value)) return true;
@@ -8435,6 +8464,12 @@ function hasGuestObjectState(value) {
   if (isLiveCapability(value)) return true;
   if (functionProperties.has(value) || prototypes.has(value) && !hasNullObjectPrototype(value)) return true;
   if (isSandboxBox(value) || isSandboxDate(value)) return false;
+  if (Array.isArray(value) && descriptorObjects.has(value)) {
+    return Object.getOwnPropertyNames(value).some((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      return key === "length" ? descriptor.writable !== true : !descriptor.enumerable || !descriptor.configurable || !descriptor.writable;
+    });
+  }
   return descriptorObjects.has(value) && (isNumericTypedArray(value) ? typedArrayProperties(value).map(([, descriptor]) => descriptor) : Object.values(Object.getOwnPropertyDescriptors(value))).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
@@ -11375,6 +11410,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 +11553,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 +12146,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));
@@ -15103,17 +15168,19 @@ async function definePropertiesFromObject(target, descriptors2, budget, context)
     release();
   }
 }
-function defineDataProperty(target, key, descriptor, budget, context) {
+function defineDataProperty(target, key, descriptor, budget, context, throwOnFailure = true) {
   budget.visitNode();
   if (isNumericTypedArray(target) && typeof key !== "symbol" && isTypedArrayIndex(String(key)) && "value" in descriptor) {
     const { value, ...attributes } = descriptor;
-    Object.defineProperty(target, key, attributes);
+    if (throwOnFailure) Object.defineProperty(target, key, attributes);
+    else if (!Reflect.defineProperty(target, key, attributes)) return false;
     return (async () => {
       const release = retainValues(budget, () => [target, value]);
       try {
         const number = await typedArrayElement(value, typedArrayStorage(target).Native, budget, context);
         Reflect.set(target, key, number);
         markDescriptorObject(target);
+        return throwOnFailure ? void 0 : true;
       } finally {
         release();
       }
@@ -15121,17 +15188,43 @@ function defineDataProperty(target, key, descriptor, budget, context) {
   }
   const properties = objectProperties(target, true);
   if (Array.isArray(properties)) {
-    if (key === "length" && "value" in descriptor)
-      budget.allocateArrayLength(Number(descriptor.value));
-    else if (typeof key !== "symbol") {
+    if (key === "length" && "value" in descriptor) {
+      const applyLength = (first, second) => {
+        const length = first >>> 0;
+        if (length !== second) throw new RangeError("Invalid array length.");
+        budget.allocateArrayLength(length);
+        const normalized = { ...descriptor, value: length };
+        if (throwOnFailure) Object.defineProperty(properties, key, normalized);
+        else {
+          const success = Reflect.defineProperty(properties, key, normalized);
+          markDescriptorObject(properties);
+          return success;
+        }
+        markDescriptorObject(properties);
+        return void 0;
+      };
+      if (typeof descriptor.value === "number") return applyLength(descriptor.value, descriptor.value);
+      return (async () => {
+        const release = retainValues(budget, () => [target, descriptor.value]);
+        try {
+          const first = await sandboxNumber(descriptor.value, budget, context);
+          const second = await sandboxNumber(descriptor.value, budget, context);
+          return applyLength(first, second);
+        } finally {
+          release();
+        }
+      })();
+    } else if (typeof key !== "symbol") {
       const index = Number(key);
       if (Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key) {
         budget.allocateArrayLength(index + 1);
       }
     }
   }
-  Object.defineProperty(properties, key, descriptor);
+  if (throwOnFailure) Object.defineProperty(properties, key, descriptor);
+  else if (!Reflect.defineProperty(properties, key, descriptor)) return false;
   markDescriptorObject(properties);
+  return throwOnFailure ? void 0 : true;
 }
 function isAssignableSandboxTarget(value) {
   return typeof value === "object" && value !== null && !isSandboxClosure(value) && !isSandboxGenerator(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value);
@@ -15675,8 +15768,21 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
   if (typeof applyArgs !== "object") {
     throw new TypeError("Function#apply requires an object or nullish arguments value.");
   }
-  if (context?.getProperty === void 0 && Array.isArray(applyArgs))
-    return options.callClosure(target, applyArgs, stack, thisValue);
+  if (context?.getProperty === void 0 && Array.isArray(applyArgs)) {
+    const budget = options.budget ?? new Budget();
+    const length = applyArgs.length;
+    budget.allocateArrayLength(length);
+    const values = [];
+    for (let index = 0; index < length; index++) {
+      const descriptor = getSandboxPropertyDescriptor(applyArgs, String(index), budget);
+      if (descriptor !== void 0 && !("value" in descriptor)) break;
+      values.push(descriptor?.value);
+    }
+    if (values.length === length) {
+      for (let index = 0; index < length; index++) budget.visitNode();
+      return options.callClosure(target, values, stack, thisValue);
+    }
+  }
   return (async () => {
     const budget = options.budget ?? new Budget();
     const invocationContext = {
@@ -26162,7 +26268,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, {
@@ -26466,6 +26572,139 @@ async function dataViewIndex(value, budget, context) {
   return index;
 }
 
+// packages/safe-js/src/interp/globals/reflect.ts
+var nativeReflectPropertyNames = Object.getOwnPropertyNames(Reflect);
+function createReflectGlobal(budget) {
+  const methods2 = {
+    ownKeys: { length: 1, call: ([target]) => {
+      const properties = objectProperties(target);
+      return allocateProducedSandboxValue([...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(target)], budget);
+    } },
+    getOwnPropertyDescriptor: { length: 2, call: async ([target, key], context) => {
+      objectProperties(target);
+      const property = await toPropertyKey(key, budget, context);
+      const descriptor = Object.getOwnPropertyDescriptor(objectProperties(target), property);
+      return descriptor === void 0 ? void 0 : allocateProducedSandboxValue(exposePropertyDescriptor(descriptor), budget);
+    } },
+    getPrototypeOf: { length: 1, call: ([target]) => {
+      objectProperties(target);
+      return getSandboxPrototype(target, budget);
+    } },
+    has: { length: 2, call: async ([target, key], context) => {
+      objectProperties(target);
+      return getSandboxPropertyDescriptor(target, await toPropertyKey(key, budget, context), budget) !== void 0;
+    } },
+    isExtensible: { length: 1, call: ([target]) => Object.isExtensible(objectProperties(target)) },
+    preventExtensions: { length: 1, call: ([target]) => Reflect.preventExtensions(objectProperties(target, true)) },
+    deleteProperty: { length: 2, call: async ([target, key], context) => {
+      objectProperties(target, true);
+      const property = await toPropertyKey(key, budget, context);
+      return Reflect.deleteProperty(objectProperties(target, true), property);
+    } },
+    get: { length: 2, call: async (args, context) => {
+      const [target, key] = args;
+      objectProperties(target);
+      const property = await toPropertyKey(key, budget, context);
+      const descriptor = getSandboxPropertyDescriptor(target, property, budget);
+      return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, args.length > 2 ? args[2] : target, context);
+    } },
+    defineProperty: { length: 3, call: async ([target, key, input], context) => {
+      objectProperties(target, true);
+      const property = await toPropertyKey(key, budget, context);
+      const descriptor = await propertyDescriptor(input, budget, context);
+      return await defineDataProperty(target, property, descriptor, budget, context, false);
+    } },
+    setPrototypeOf: { length: 2, call: ([target, prototype]) => {
+      objectProperties(target, true);
+      if (prototype !== null) objectProperties(prototype);
+      return setSandboxPrototype(target, prototype, budget, false);
+    } },
+    set: { length: 3, call: async (args, context) => {
+      const [target, key, value] = args;
+      objectProperties(target, true);
+      const property = await toPropertyKey(key, budget, context);
+      const receiver = args.length > 3 ? args[3] : target;
+      let descriptor;
+      let depth = 0;
+      for (let current = target; current !== null; current = getSandboxPrototype(current, budget)) {
+        budget.visitNode();
+        assertSandboxDataDepth(depth++);
+        if (isNumericTypedArray(current) && typeof property === "string" && isTypedArrayIndex(property)) {
+          if (current === receiver) {
+            await setTypedArrayMember(current, property, value, budget, context);
+            return true;
+          }
+          if (Object.getOwnPropertyDescriptor(current, property) === void 0) return true;
+        }
+        descriptor = Object.getOwnPropertyDescriptor(objectProperties(current), property);
+        if (descriptor !== void 0) break;
+      }
+      if (descriptor !== void 0 && !("value" in descriptor)) {
+        const setter = accessorClosure(descriptor.set);
+        if (setter === void 0) return false;
+        await context.invokeClosure(setter, [value], receiver);
+        return true;
+      }
+      if (descriptor !== void 0 && !descriptor.writable) return false;
+      if (receiver === null || typeof receiver !== "object") return false;
+      const existing = Object.getOwnPropertyDescriptor(objectProperties(receiver, true), property);
+      if (existing !== void 0 && (!("value" in existing) || !existing.writable)) return false;
+      return await defineDataProperty(receiver, property, existing === void 0 ? { value, writable: true, enumerable: true, configurable: true } : { value }, budget, context, false);
+    } },
+    apply: { length: 3, call: ([target, receiver, values], context) => {
+      if (!isSandboxClosure(target)) throw new TypeError("Reflect.apply requires a callable target.");
+      objectProperties(values);
+      return callFunctionMethod(target, "apply", [receiver, values], {
+        budget,
+        callClosure: (callee, args, _stack, thisValue) => context.invokeClosure(callee, args, thisValue)
+      }, context.stack, context);
+    } },
+    construct: { length: 2, call: (args, context) => {
+      const [target, values] = args;
+      const newTarget = args.length > 2 ? args[2] : target;
+      if (!isSandboxClosure(target) || target.construct === void 0 || !isSandboxClosure(newTarget) || newTarget.construct === void 0)
+        throw new TypeError("Reflect.construct requires constructor targets.");
+      objectProperties(values);
+      return callFunctionMethod(target, "apply", [void 0, values], {
+        budget,
+        callClosure: (callee, items) => context.invokeClosure(callee, items, void 0, true, newTarget)
+      }, context.stack, context);
+    } }
+  };
+  const reflect = {};
+  for (const name of nativeReflectPropertyNames) {
+    const method = methods2[name];
+    if (method === void 0) continue;
+    const closure = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name,
+      length: method.length,
+      call: async (args, context) => {
+        const release = retainValues(budget, () => args);
+        try {
+          return await method.call(args, {
+            ...context,
+            stack: context?.stack ?? [],
+            thisValue: context?.thisValue,
+            invokeClosure: context?.invokeClosure ?? ((target, values, receiver, construct, newTarget) => invokeBuiltinClosure(target, values, budget, { ...context, stack: context?.stack ?? [], thisValue: receiver, newTarget }, receiver, construct))
+          });
+        } finally {
+          release();
+        }
+      }
+    });
+    Object.defineProperty(reflect, name, { value: closure, writable: true, configurable: true });
+  }
+  Object.defineProperty(reflect, Symbol.toStringTag, { value: "Reflect", configurable: true });
+  registerBuiltinIdentities(budget, { Reflect: reflect });
+  for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(reflect))) {
+    if (isSandboxClosure(descriptor.value)) registerIntrinsicFunction(budget, descriptor.value);
+  }
+  registerIntrinsicObject(budget, reflect);
+  return reflect;
+}
+
 // packages/safe-js/src/interp/globals.ts
 function createBuiltinBindings(options) {
   const bindings = {
@@ -26478,6 +26717,7 @@ function createBuiltinBindings(options) {
     ...createErrorGlobals({ ...options, errorPrototypes: options.errorPrototypes !== false }),
     ...createMathGlobals({ random: options.random, budget: options.budget }),
     ...createObjectArrayGlobals(options),
+    Reflect: createReflectGlobal(options.budget),
     ArrayBuffer: createArrayBufferGlobal(options.budget),
     DataView: createDataViewGlobal(options.budget),
     ...createMiscGlobals(options),
@@ -29069,7 +29309,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;
@@ -31158,6 +31398,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Promise",
   "RangeError",
   "ReferenceError",
+  "Reflect",
   "RegExp",
   "Set",
   "String",
@@ -43647,4 +43888,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-35DAUDMZ.js.map
+//# sourceMappingURL=chunk-7UITTELW.js.map