@poe-platform/safe-js 0.1.295 → 0.1.297

package/dist/safe-js/chunks/{chunk-CL6E5SM7.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 {
@@ -11608,6 +11659,30 @@ function createPrimitiveConstructor(options, budget) {
 }
 
 // packages/safe-js/src/interp/methods/array.ts
+async function arraySpeciesCreate(value, length, options) {
+  const receiver = arrayLikeSources.get(value) ?? value;
+  const read = (target, key) => options.context?.getProperty !== void 0 ? options.context.getProperty(target, key) : readPropertyDescriptor(getSandboxPropertyDescriptor(target, key, options.budget) ?? { value: void 0 }, target, options.context);
+  let constructor;
+  if (Array.isArray(receiver)) {
+    constructor = await read(receiver, "constructor");
+    if (typeof constructor === "object" && constructor !== null) {
+      constructor = await read(constructor, Symbol.species);
+      if (constructor === null) constructor = void 0;
+    }
+    if (constructor !== void 0) {
+      if (!isSandboxClosure(constructor) || constructor.construct === void 0)
+        throw new TypeError("Array species must be a constructor.");
+      return await invokeBuiltinClosure(constructor, [length], options.budget, options.context, void 0, true);
+    }
+  }
+  options.budget.allocateArrayLength(length);
+  return new Array(length);
+}
+function defineArrayResult(result, index, value, options) {
+  if (index >= Number.MAX_SAFE_INTEGER) throw new TypeError("Array result exceeds the safe integer limit.");
+  if (Array.isArray(result)) options.budget.allocateArrayLength(index + 1);
+  defineOwnDataProperty(objectProperties(result, true), String(index), value);
+}
 var arrayLikeSources = /* @__PURE__ */ new WeakMap();
 var activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
 var localeArrays = /* @__PURE__ */ new WeakSet();
@@ -11887,15 +11962,18 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
         ),
         options.budget
       );
-    case "flat":
+    case "flat": {
+      const length = value.length;
       return budgetProducedValue(
         await flattenArray(
           value,
           args[0] === void 0 ? 1 : toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context)),
-          options
+          options,
+          length
         ),
         options.budget
       );
+    }
     case "includes":
     case "indexOf":
     case "lastIndexOf": {
@@ -11933,22 +12011,23 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
       const final = end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
       const count = Math.max(final - first, 0);
-      options.budget.allocateArrayLength(count);
-      const result = new Array(count);
+      const result = await arraySpeciesCreate(value, count, options);
       const release = retainValues(options.budget, () => [result]);
       try {
         for (let index = 0; index < count; index += 1) {
           options.budget.visitNode();
           if (first + index in value)
-            result[index] = await readArrayElement(value, first + index, options);
+            defineArrayResult(result, index, await readArrayElement(value, first + index, options), options);
         }
+        await setSandboxProperty(result, "length", count, options.budget, true, options.context);
         return budgetProducedValue(result, options.budget);
       } finally {
         release();
       }
     }
     case "concat": {
-      const result = [];
+      const result = await arraySpeciesCreate(value, 0, options);
+      let targetIndex = 0;
       const retained = {};
       options.budget.setRetainedValues(retained, () => [result]);
       try {
@@ -11959,21 +12038,22 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
             spread = flag === void 0 ? Array.isArray(entry) : Boolean(flag);
           }
           if (!spread) {
-            options.budget.allocateArrayLength(result.length + 1);
-            result.push(entry);
+            defineArrayResult(result, targetIndex++, entry, options);
             continue;
           }
-          const start = result.length;
+          const start = targetIndex;
           const source = await arrayLikeView(entry, options);
           const length = source.length;
-          options.budget.allocateArrayLength(start + length);
-          result.length += length;
+          if (start + length > Number.MAX_SAFE_INTEGER) throw new TypeError("Array result exceeds the safe integer limit.");
+          if (Array.isArray(result)) options.budget.allocateArrayLength(start + length);
+          targetIndex += length;
           for (let index = 0; index < length; index++) {
             options.budget.visitNode();
             if (index in source)
-              result[start + index] = await readArrayElement(source, index, options);
+              defineArrayResult(result, start + index, await readArrayElement(source, index, options), options);
           }
         }
+        await setSandboxProperty(result, "length", targetIndex, options.budget, true, options.context);
         return budgetProducedValue(result, options.budget);
       } finally {
         options.budget.setRetainedValues(retained, void 0);
@@ -11998,16 +12078,16 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       const nextLength = length + inserted - deleted;
       if (nextLength > Number.MAX_SAFE_INTEGER)
         throw new TypeError("Array-like length exceeds the safe integer limit.");
-      options.budget.allocateArrayLength(deleted);
-      const removed = new Array(deleted);
+      const removed = await arraySpeciesCreate(value, deleted, options);
       const retained = {};
       options.budget.setRetainedValues(retained, () => [removed]);
       try {
         for (let index = 0; index < deleted; index++) {
           options.budget.visitNode();
           if (first + index in value)
-            removed[index] = await readArrayElement(value, first + index, options);
+            defineArrayResult(removed, index, await readArrayElement(value, first + index, options), options);
         }
+        await setSandboxProperty(removed, "length", deleted, options.budget, true, options.context);
         if (inserted < deleted) {
           for (let index = first; index < length - deleted; index++)
             await moveArrayElement(value, index + deleted, index + inserted, options);
@@ -12303,8 +12383,7 @@ async function moveArrayElement(value, from, to, options) {
 }
 async function mapArray(value, callback, options, stack, thisValue) {
   const length = value.length;
-  options.budget.allocateArrayLength(length);
-  const result = new Array(length);
+  const result = await arraySpeciesCreate(value, length, options);
   options.budget.setRetainedValues(result, () => [result]);
   try {
     for (let index = 0; index < length; index += 1) {
@@ -12312,7 +12391,7 @@ async function mapArray(value, callback, options, stack, thisValue) {
       if (!(index in value)) {
         continue;
       }
-      result[index] = await callArrayCallback(
+      defineArrayResult(result, index, await callArrayCallback(
         callback,
         await readArrayElement(value, index, options),
         index,
@@ -12320,7 +12399,7 @@ async function mapArray(value, callback, options, stack, thisValue) {
         options,
         stack,
         thisValue
-      );
+      ), options);
     }
     return result;
   } finally {
@@ -12329,7 +12408,8 @@ async function mapArray(value, callback, options, stack, thisValue) {
 }
 async function filterArray(value, callback, options, stack, thisValue) {
   const length = value.length;
-  const result = [];
+  const result = await arraySpeciesCreate(value, 0, options);
+  let targetIndex = 0;
   options.budget.setRetainedValues(result, () => [result]);
   try {
     for (let index = 0; index < length; index += 1) {
@@ -12339,7 +12419,7 @@ async function filterArray(value, callback, options, stack, thisValue) {
       }
       const entry = await readArrayElement(value, index, options);
       if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-        result.push(entry);
+        defineArrayResult(result, targetIndex++, entry, options);
       }
     }
     return result;
@@ -12543,7 +12623,8 @@ async function forEachArray(value, callback, options, stack, thisValue) {
 }
 async function flatMapArray(value, callback, options, stack, thisValue) {
   const length = value.length;
-  const result = [];
+  const result = await arraySpeciesCreate(value, 0, options);
+  let targetIndex = 0;
   options.budget.setRetainedValues(result, () => [result]);
   try {
     for (let index = 0; index < length; index += 1) {
@@ -12561,37 +12642,35 @@ async function flatMapArray(value, callback, options, stack, thisValue) {
         thisValue
       );
       if (Array.isArray(mapped)) {
-        for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
+        const mappedLength = mapped.length;
+        for (let mappedIndex = 0; mappedIndex < mappedLength; mappedIndex += 1) {
           options.budget.visitNode();
           if (!(mappedIndex in mapped)) {
             continue;
           }
-          result.push(await readArrayElement(mapped, mappedIndex, options));
-          options.budget.allocateArrayLength(result.length);
+          defineArrayResult(result, targetIndex++, await readArrayElement(mapped, mappedIndex, options), options);
         }
         continue;
       }
-      result.push(mapped);
-      options.budget.allocateArrayLength(result.length);
+      defineArrayResult(result, targetIndex++, mapped, options);
     }
     return result;
   } finally {
     options.budget.setRetainedValues(result, void 0);
   }
 }
-async function flattenArray(value, depth, options) {
-  const result = [];
+async function flattenArray(value, depth, options, length) {
+  const result = await arraySpeciesCreate(value, 0, options);
   const retained = {};
   options.budget.setRetainedValues(retained, () => [result]);
   try {
-    await appendFlattenedEntries(value, depth, result, options);
+    await appendFlattenedEntries(value, depth, result, options, 0, length);
     return result;
   } finally {
     options.budget.setRetainedValues(retained, void 0);
   }
 }
-async function appendFlattenedEntries(value, depth, result, options) {
-  const length = value.length;
+async function appendFlattenedEntries(value, depth, result, options, targetIndex, length = value.length) {
   for (let index = 0; index < length; index += 1) {
     options.budget.visitNode();
     if (!(index in value)) {
@@ -12599,12 +12678,12 @@ async function appendFlattenedEntries(value, depth, result, options) {
     }
     const entry = await readArrayElement(value, index, options);
     if (depth > 0 && Array.isArray(entry)) {
-      await appendFlattenedEntries(entry, depth - 1, result, options);
+      targetIndex = await appendFlattenedEntries(entry, depth - 1, result, options, targetIndex);
       continue;
     }
-    result.push(entry);
-    options.budget.allocateArrayLength(result.length);
+    defineArrayResult(result, targetIndex++, entry, options);
   }
+  return targetIndex;
 }
 async function sortArray(value, comparator, options, stack) {
   const length = value.length;
@@ -12701,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;
   }
@@ -13076,7 +13155,59 @@ function createArrayGlobal(budget) {
   });
   const properties = materializeFunctionProperties(constructor);
   Object.defineProperty(properties, "prototype", { value: prototype, writable: false });
+  Object.defineProperty(properties, Symbol.species, {
+    get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get [Symbol.species]",
+      length: 0,
+      call: (_args, context) => context?.thisValue
+    }), "get"),
+    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,
@@ -19973,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)
@@ -23992,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"]);
@@ -24050,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"]);
@@ -25904,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);
@@ -26083,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;
@@ -26447,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.");
   }
@@ -26569,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;
   }
@@ -40765,4 +40921,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CL6E5SM7.js.map
+//# sourceMappingURL=chunk-MQRGC4JQ.js.map