@poe-platform/safe-js 0.1.375 → 0.1.376

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

@@ -8411,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)) {
@@ -8422,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;
@@ -8458,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
   );
@@ -15156,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();
       }
@@ -15174,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);
@@ -15728,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 = {
@@ -26519,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 = {
@@ -26531,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),
@@ -31211,6 +31398,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Promise",
   "RangeError",
   "ReferenceError",
+  "Reflect",
   "RegExp",
   "Set",
   "String",
@@ -43700,4 +43888,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-M22DVZY3.js.map
+//# sourceMappingURL=chunk-7UITTELW.js.map