@poe-platform/safe-js 0.1.296 → 0.1.297

package/dist/safe-js/chunks/{chunk-2Y6SJCIT.js → chunk-MQRGC4JQ.js}

@@ -7163,11 +7163,28 @@ function nativeIterator(collection, method) {
   return collection.kind === "map" ? collection.entries[method]() : collection.values[method]();
 }
 
-// packages/safe-js/src/interp/regexp-iterator.ts
+// packages/safe-js/src/interp/array-iterator.ts
 var states2 = /* @__PURE__ */ new WeakMap();
-function isSandboxRegExpIterator(value) {
+function isSandboxArrayIterator(value) {
   return typeof value === "object" && value !== null && states2.has(value);
 }
+function restoreSandboxArrayIterator(state, target = /* @__PURE__ */ Object.create(null)) {
+  if (!Number.isSafeInteger(state.index) || state.index < 0 || !["keys", "values", "entries"].includes(state.method) || state.source !== void 0 && (state.source === null || typeof state.source !== "object"))
+    throw new TypeError("Invalid Array iterator state.");
+  states2.set(target, { ...state });
+  return target;
+}
+function arrayIteratorState(value) {
+  const state = states2.get(value);
+  if (state === void 0) throw new TypeError("Array iterator next requires an Array iterator receiver.");
+  return state;
+}
+
+// packages/safe-js/src/interp/regexp-iterator.ts
+var states3 = /* @__PURE__ */ new WeakMap();
+function isSandboxRegExpIterator(value) {
+  return typeof value === "object" && value !== null && states3.has(value);
+}
 function restoreSandboxRegExpIterator(state, target = /* @__PURE__ */ Object.create(null)) {
   if ((state.global !== void 0 || state.unicode !== void 0) && (typeof state.global !== "boolean" || typeof state.unicode !== "boolean"))
     throw new TypeError("Invalid RegExp iterator modes.");
@@ -7175,11 +7192,11 @@ function restoreSandboxRegExpIterator(state, target = /* @__PURE__ */ Object.cre
     throw new TypeError("Invalid RegExp iterator matcher.");
   if (!state.exhausted && (state.matcher === void 0 || state.input === void 0))
     throw new TypeError("A live RegExp iterator requires its matcher and input.");
-  states2.set(target, state.exhausted ? { ...state, matcher: void 0, input: void 0, exhausted: true } : { ...state });
+  states3.set(target, state.exhausted ? { ...state, matcher: void 0, input: void 0, exhausted: true } : { ...state });
   return target;
 }
 function regexpIteratorState(value) {
-  const state = states2.get(value);
+  const state = states3.get(value);
   if (state === void 0) throw new TypeError("Expected a RegExp string iterator.");
   return state;
 }
@@ -7359,6 +7376,7 @@ function graphEntries(value) {
   }
   const entries = [];
   if (isSandboxCollectionIterator(value)) entries.push([".<collection>", collectionIteratorState(value).collection]);
+  if (isSandboxArrayIterator(value)) entries.push([".<source>", arrayIteratorState(value).source]);
   if (isSandboxRegExpIterator(value)) entries.push([".<matcher>", regexpIteratorState(value).matcher]);
   for (const key of Object.keys(value)) {
     const descriptor = Object.getOwnPropertyDescriptor(value, key);
@@ -9375,6 +9393,7 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
   if (context.getProperty === void 0 || isGuestHostObject(value))
     return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
   if (getSandboxPropertyDescriptor(value, key, budget) === void 0 && !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)) {
+    if (!asyncProtocol && Array.isArray(value) && getSandboxPrototype(value, budget) !== null) return void 0;
     if (!asyncProtocol) return getSandboxIterator(value, budget, context);
     if (isSandboxGenerator(value) && value.async)
       return getSandboxAsyncIterator(value, budget, context, signal);
@@ -9382,6 +9401,11 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
   }
   const factory = await context.getProperty(value, key);
+  if (!asyncProtocol && factory === void 0 && Array.isArray(value) && !hasExplicitSandboxPrototype(value)) {
+    const installed = getSandboxPropertyDescriptor(value, key, budget)?.value;
+    if (typeof installed === "object" && installed !== null && getIntrinsicIdentity(installed) === JSON.stringify(["Array", "prototype", "values"]))
+      return arrayIterator(value, context, budget);
+  }
   if (!asyncProtocol && (isSandboxMap(value) || isSandboxSet(value)) && typeof factory === "object" && factory !== null && getIntrinsicIdentity(factory) === JSON.stringify(isSandboxMap(value) ? ["Map", "prototype", "entries"] : ["Set", "prototype", "values"])) {
     return getSandboxIterator(value, budget, context);
   }
@@ -10423,6 +10447,33 @@ function createDataCheckpoint(budget, context) {
   };
 }
 
+// packages/safe-js/src/interp/methods/array-iterator.ts
+async function nextArrayIterator(value, budget, context) {
+  if (!isSandboxArrayIterator(value)) throw new TypeError("Array iterator next requires an Array iterator receiver.");
+  const state = arrayIteratorState(value);
+  const source = state.source;
+  if (source === void 0) return { value: void 0, done: true };
+  const index = state.index;
+  const release = retainValues(budget, () => [value, source]);
+  const read = (key) => context?.getProperty !== void 0 ? context.getProperty(source, key) : readPropertyDescriptor((isFloat32Array(source) ? Object.getOwnPropertyDescriptor(source, key) : void 0) ?? getSandboxPropertyDescriptor(source, key, budget) ?? { value: void 0 }, source, context);
+  try {
+    budget.visitNode();
+    const number = isFloat32Array(source) ? float32Storage(source).length : await sandboxNumber(await read("length"), budget, context);
+    const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+    if (index >= length) {
+      state.source = void 0;
+      return { value: void 0, done: true };
+    }
+    state.index = index + 1;
+    if (state.method === "keys") return { value: index, done: false };
+    const entry = await read(String(index));
+    if (state.method === "entries") budget.allocateArrayLength(2);
+    return { value: state.method === "entries" ? [index, entry] : entry, done: false };
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/globals/numeric-parsers.ts
 function createNumericParsers(budget) {
   return {
@@ -12729,8 +12780,8 @@ function allocateProducedValue(value, budget, seen) {
       return;
     }
     seen.add(value);
-    for (const entry of value) {
-      allocateProducedValue(entry, budget, seen);
+    for (let index = 0; index < value.length; index++) {
+      allocateProducedValue(value[index], budget, seen);
     }
     return;
   }
@@ -13115,6 +13166,48 @@ function createArrayGlobal(budget) {
     configurable: true
   });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+  const iteratorPrototype = /* @__PURE__ */ Object.create(null);
+  const iterablePrototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(iterablePrototype, Symbol.iterator, { value: createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.iterator]",
+    length: 0,
+    call: (_args, context) => context?.thisValue
+  }), writable: true, configurable: true });
+  setSandboxPrototype(iterablePrototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  setSandboxPrototype(iteratorPrototype, iterablePrototype);
+  Object.defineProperties(iteratorPrototype, {
+    next: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "next",
+      length: 0,
+      call: (_args, context) => nextArrayIterator(context?.thisValue, budget, context)
+    }), writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Array Iterator", configurable: true }
+  });
+  registerBuiltinIdentities(budget, { "%ArrayIteratorPrototype%": iteratorPrototype, "%IteratorPrototype%": iterablePrototype });
+  registerIntrinsicObject(budget, iterablePrototype);
+  registerIntrinsicObject(budget, iteratorPrototype);
+  for (const method of ["keys", "values", "entries"]) {
+    const closure = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        if (receiver === null || receiver === void 0) throw new TypeError("Array iterator method requires a receiver.");
+        const source = typeof receiver === "object" ? receiver : createSandboxBox(receiver);
+        const iterator = restoreSandboxArrayIterator({ source, index: 0, method });
+        setSandboxPrototype(iterator, iteratorPrototype, budget);
+        return iterator;
+      }
+    });
+    Object.defineProperty(prototype, method, { value: closure, writable: true, configurable: true });
+    if (method === "values") Object.defineProperty(prototype, Symbol.iterator, { value: closure, writable: true, configurable: true });
+  }
   for (const name of arrayMethodNames) {
     const method = createSandboxClosure({
       guest: true,
@@ -20011,6 +20104,16 @@ function captureGuestHeapNode(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)) {
+    const cursor = arrayIteratorState(value);
+    return {
+      kind: "array-iterator",
+      source: encode(cursor.source),
+      index: cursor.index,
+      method: cursor.method,
+      state: captureObjectState(value, encode)
+    };
+  }
   const classOrigin = classOrigins.get(value);
   if (classOrigin !== void 0) {
     if (!classOrigin.initialized || classOrigin.node.nodeId === void 0)
@@ -24030,7 +24133,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", "map", "set"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "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"]);
@@ -24088,6 +24191,15 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     fields(node, ["kind", "id"], ["state"]);
     if (typeof node.id !== "string" || !intrinsicCatalogue().has(node.id)) throw new TypeError("Unknown intrinsic identity.");
     if (Object.hasOwn(node, "state")) state(node.state);
+  } else if (node.kind === "array-iterator") {
+    fields(node, ["kind", "source", "index", "method", "state"]);
+    integer(node.index);
+    if (!["keys", "values", "entries"].includes(String(node.method))) throw new TypeError("Invalid Array iterator method.");
+    if (!absent(node.source)) {
+      const source = reference(node.source);
+      if (source.kind === "scope-frame" || source.kind === "symbol") throw new TypeError("Invalid Array iterator source.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-object" || node.kind === "guest-array") {
     fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : []);
     if (Object.hasOwn(node, "templateOwner")) reference(node.templateOwner, ["guest-array"]);
@@ -25942,6 +26054,7 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    if (isSandboxArrayIterator(value)) visit(arrayIteratorState(value).source, depth + 1);
     if (isSandboxRegExpIterator(value)) {
       const state = regexpIteratorState(value);
       visit(state.matcher, depth + 1);
@@ -26121,6 +26234,10 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxPromise(value)) {
     return value;
   }
+  if (isSandboxArrayIterator(value)) {
+    if (!cloneSandboxCollections) return value;
+    throw new TypeError("Array iterators require a portable guest snapshot, not a data copy.");
+  }
   if (isSandboxRegExpIterator(value)) {
     if (hasGuestObjectState(value)) throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     if (!cloneSandboxCollections) return value;
@@ -26485,6 +26602,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
   if (isSandboxGenerator(value)) {
     throw new TypeError("Sandbox generators cannot cross into host values.");
   }
+  if (isSandboxArrayIterator(value)) throw new TypeError("Sandbox Array iterators cannot cross into host values.");
   if (isSandboxCollectionIterator(value)) {
     throw new TypeError("Sandbox collection iterators cannot cross into host values.");
   }
@@ -26607,8 +26725,8 @@ function allocateSandboxValue2(value, budget, seen) {
     }
     seen.add(value);
     budget.allocateArrayLength(value.length);
-    for (const entry of value) {
-      allocateSandboxValue2(entry, budget, seen);
+    for (let index = 0; index < value.length; index++) {
+      allocateSandboxValue2(value[index], budget, seen);
     }
     return;
   }
@@ -40803,4 +40921,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-2Y6SJCIT.js.map
+//# sourceMappingURL=chunk-MQRGC4JQ.js.map