@poe-platform/safe-js 0.1.388 → 0.1.389

package/dist/safe-js/chunks/{chunk-VQ4F2UCI.js → chunk-6Y27XODE.js}

@@ -26409,6 +26409,103 @@ function installIteratorFrom(constructor, budget) {
   }
 }
 
+// packages/safe-js/src/interp/globals/iterator-consumers.ts
+function installIteratorConsumers(prototype, budget) {
+  for (const name of ["toArray", "reduce", "forEach", "some", "every", "find"]) {
+    Object.defineProperty(prototype, name, { writable: true, configurable: true, value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name,
+      length: name === "toArray" ? 0 : 1,
+      call: async (args, context) => {
+        const receiver = context?.thisValue;
+        if (receiver === null || typeof receiver !== "object") throw new TypeError("Iterator consumer requires an object.");
+        const callback = args[0];
+        let next;
+        let accumulator = args[1];
+        let value;
+        const values = [];
+        const release = retainValues(budget, () => [receiver, callback, next, accumulator, value, values]);
+        const checkpoint = createDataCheckpoint(budget, context);
+        const iterator = {
+          asynchronous: true,
+          next: async () => {
+            if (!isSandboxClosure(next)) throw new TypeError("Iterator next must be callable.");
+            const result = await invokeBuiltinClosure(next, [], budget, context, receiver);
+            if (result === null || typeof result !== "object") throw new TypeError("Iterator result must be an object.");
+            return result;
+          },
+          getOperation: async () => {
+            const method = await read(receiver, "return", context);
+            if (method === void 0 || method === null) return void 0;
+            if (!isSandboxClosure(method)) throw new TypeError("Iterator return must be callable.");
+            return async () => await invokeBuiltinClosure(method, [], budget, context, receiver);
+          }
+        };
+        try {
+          if (name !== "toArray" && !isSandboxClosure(callback)) {
+            await closeIterator(iterator, true);
+            throw new TypeError("Iterator callback must be callable.");
+          }
+          next = await read(receiver, "next", context);
+          let initialized = name !== "reduce" || args.length > 1;
+          let index = 0;
+          while (true) {
+            budget.visitNode();
+            const result = await iterator.next();
+            if (await read(result, "done", context)) {
+              if (!initialized) throw new TypeError("Cannot reduce an empty iterator without an initial value.");
+              if (name === "toArray") return values;
+              if (name === "reduce") return accumulator;
+              if (name === "some") return false;
+              if (name === "every") return true;
+              return void 0;
+            }
+            value = await read(result, "value", context);
+            if (name === "toArray") {
+              values.push(value);
+              checkpoint(values, 0, true);
+            } else if (!initialized) {
+              accumulator = value;
+              initialized = true;
+            } else {
+              let selected;
+              try {
+                selected = await invokeBuiltinClosure(
+                  callback,
+                  name === "reduce" ? [accumulator, value, index] : [value, index],
+                  budget,
+                  context,
+                  void 0
+                );
+              } catch (error) {
+                if (!isFatalSandboxError(error)) await closeIterator(iterator, true);
+                throw error;
+              }
+              if (name === "reduce") accumulator = selected;
+              else if ((name === "some" || name === "find") && selected || name === "every" && !selected) {
+                await closeIterator(iterator);
+                return name === "find" ? value : name === "some";
+              }
+            }
+            value = void 0;
+            index++;
+          }
+        } finally {
+          release();
+        }
+      }
+    }) });
+  }
+  registerBuiltinIdentities(budget, { "%IteratorPrototype%": prototype });
+  registerIntrinsicObject(budget, prototype);
+  async function read(value, key, context) {
+    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, context);
+  }
+}
+
 // packages/safe-js/src/interp/globals/iterator.ts
 function createIteratorGlobal(budget) {
   const prototype = resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]');
@@ -26447,6 +26544,7 @@ function createIteratorGlobal(budget) {
   registerIntrinsicFunction(budget, getter);
   registerIntrinsicFunction(budget, setter);
   installIteratorFrom(constructor, budget);
+  installIteratorConsumers(prototype, budget);
   registerIntrinsicFunction(budget, constructor);
   registerIntrinsicObject(budget, prototype);
   return constructor;
@@ -44310,4 +44408,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-VQ4F2UCI.js.map
+//# sourceMappingURL=chunk-6Y27XODE.js.map