@poe-platform/safe-js 0.1.303 → 0.1.305

package/dist/safe-js/chunks/{chunk-S5C5SAU4.js → chunk-JIC2DHRN.js}

@@ -14080,6 +14080,34 @@ function functionString(value) {
   return `function ${name}() { [native code] }`;
 }
 
+// packages/safe-js/src/interp/bound-function-state.ts
+var boundFunctionStates = /* @__PURE__ */ new WeakMap();
+
+// packages/safe-js/src/interp/bound-function.ts
+function createBoundFunction(state, name, length, callClosure) {
+  const bound = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name,
+    length,
+    boundTarget: state.target,
+    retainedValues: () => [state.target, state.thisValue, ...state.args, bound.name],
+    call: (args, context) => callClosure(state.target, [...state.args, ...args], context?.stack ?? [], state.thisValue),
+    ...state.target.construct === void 0 ? {} : {
+      construct: (args, context) => callClosure(
+        state.target,
+        [...state.args, ...args],
+        context?.stack ?? [],
+        void 0,
+        true,
+        context?.newTarget === bound ? state.target : context?.newTarget
+      )
+    }
+  });
+  boundFunctionStates.set(bound, state);
+  return bound;
+}
+
 // packages/safe-js/src/interp/methods/function.ts
 var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call", "toString"]);
 function getFunctionMember(target, property, options) {
@@ -14134,25 +14162,7 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
     const explicitPrototype = hasExplicitSandboxPrototype(target);
     const prototype = getSandboxPrototype(target, options.budget);
     const bind = (length, name) => {
-      const bound = createSandboxClosure({
-        guest: true,
-        sandbox: true,
-        name: `bound ${name}`,
-        length,
-        boundTarget: target,
-        retainedValues: () => [target, thisValue, ...boundArgs, bound.name],
-        call: (callArgs, context2) => options.callClosure(target, [...boundArgs, ...callArgs], context2?.stack ?? [], thisValue),
-        ...target.construct === void 0 ? {} : {
-          construct: (callArgs, context2) => options.callClosure(
-            target,
-            [...boundArgs, ...callArgs],
-            context2?.stack ?? [],
-            void 0,
-            true,
-            context2?.newTarget === bound ? target : context2?.newTarget
-          )
-        }
-      });
+      const bound = createBoundFunction({ target, thisValue, args: boundArgs }, `bound ${name}`, length, options.callClosure);
       if (explicitPrototype) setSandboxPrototype(bound, prototype, options.budget);
       return bound;
     };
@@ -14185,25 +14195,37 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
   if (applyArgs === null || applyArgs === void 0) {
     return options.callClosure(target, [], stack, thisValue);
   }
-  if (!Array.isArray(applyArgs)) {
-    throw new TypeError("Function#apply requires an array or nullish arguments value.");
+  if (typeof applyArgs !== "object") {
+    throw new TypeError("Function#apply requires an object or nullish arguments value.");
   }
-  if (context?.getProperty === void 0)
+  if (context?.getProperty === void 0 && Array.isArray(applyArgs))
     return options.callClosure(target, applyArgs, stack, thisValue);
   return (async () => {
+    const budget = options.budget ?? new Budget();
+    const invocationContext = {
+      ...context,
+      stack,
+      thisValue: context?.thisValue,
+      invokeClosure: context?.invokeClosure ?? ((callee, values2, receiver) => Promise.resolve(options.callClosure(callee, values2, stack, receiver)))
+    };
+    const read = (value, key) => {
+      if (context?.getProperty !== void 0) return context.getProperty(value, key);
+      const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+      return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, invocationContext);
+    };
     const values = [];
-    const length = applyArgs.length;
-    options.budget?.allocateArrayLength(length);
-    const retained = {};
-    options.budget?.setRetainedValues(retained, () => values);
+    const release = retainValues(budget, () => [applyArgs, ...values]);
     try {
+      const number = await sandboxNumber(await read(applyArgs, "length"), budget, invocationContext);
+      const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+      budget.allocateArrayLength(length);
       for (let index = 0; index < length; index++) {
-        options.budget?.visitNode();
-        values.push(await context.getProperty(applyArgs, index));
+        budget.visitNode();
+        values.push(await read(applyArgs, String(index)));
       }
       return await options.callClosure(target, values, stack, thisValue);
     } finally {
-      options.budget?.setRetainedValues(retained, void 0);
+      release();
     }
   })();
 }
@@ -20281,6 +20303,18 @@ function captureGuestHeapNode(value, encode) {
     const state2 = captureObjectState(value, encode);
     return { kind: "intrinsic", id: intrinsic, ...state2 === void 0 ? {} : { state: state2 } };
   }
+  const bound = boundFunctionStates.get(value);
+  if (bound !== void 0 && isSandboxClosure(value)) {
+    return {
+      kind: "bound-function",
+      target: encode(bound.target),
+      thisValue: encode(bound.thisValue),
+      args: bound.args.map(encode),
+      length: encode(value.length),
+      ...value.name === void 0 ? {} : { name: value.name },
+      state: captureObjectState(value, encode)
+    };
+  }
   if (isSandboxMap(value)) return { kind: "map", entries: [...value.entries].map(([key, entry]) => [encode(key), encode(entry)]), ...serializeCollectionProperties(value, encode) };
   if (isSandboxSet(value)) return { kind: "set", values: [...value.values].map(encode), ...serializeCollectionProperties(value, encode) };
   if (isSandboxArrayIterator(value)) {
@@ -24401,7 +24435,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -24412,7 +24446,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   };
   const callable = (value) => {
     if (absent(value)) return;
-    const target = reference(value, ["intrinsic", "guest-function", "guest-class"]);
+    const target = reference(value, ["intrinsic", "bound-function", "guest-function", "guest-class"]);
     if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
@@ -24508,6 +24542,22 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (descriptor.kind !== "data" || descriptor.writable !== false || descriptor.enumerable !== false || descriptor.configurable !== false)
       throw new TypeError("Invalid class prototype descriptor.");
     reference(descriptor.value, ["object", "guest-object"]);
+  } else if (node.kind === "bound-function") {
+    fields(node, ["kind", "target", "thisValue", "args", "length", "state"], ["name"]);
+    if (Object.hasOwn(node, "name") && typeof node.name !== "string") throw new TypeError("Invalid bound function name.");
+    if (array(node.args).length > maxArrayLength) throw new TypeError("Bound arguments exceed allocation limit.");
+    if (!absent(node.length) && !(typeof node.length === "number" && node.length >= 0) && !(record3(node.length).kind === "number" && record3(node.length).value === "Infinity"))
+      throw new TypeError("Invalid bound function length.");
+    const visited = /* @__PURE__ */ new Set([raw]);
+    let current = node;
+    while (current.kind === "bound-function") {
+      assertSnapshotDataDepth(visited.size, "<bound-target>");
+      callable(current.target);
+      current = reference(current.target);
+      if (visited.has(current)) throw new TypeError("Cyclic bound function target.");
+      visited.add(current);
+    }
+    state(node.state);
   } else if (node.kind === "guest-function") {
     fields(node, ["kind", "astNodeId", "scope", "state"], ["name", "environment"]);
     if (integer(node.astNodeId) < 1) throw new TypeError("Invalid guest AST identity.");
@@ -41201,4 +41251,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-S5C5SAU4.js.map
+//# sourceMappingURL=chunk-JIC2DHRN.js.map