@poe-platform/safe-js 0.1.294 → 0.1.296

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

@@ -11608,6 +11608,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 +11911,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 +11960,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 +11987,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 +12027,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 +12332,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 +12340,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 +12348,7 @@ async function mapArray(value, callback, options, stack, thisValue) {
         options,
         stack,
         thisValue
-      );
+      ), options);
     }
     return result;
   } finally {
@@ -12329,7 +12357,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 +12368,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 +12572,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 +12591,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 +12627,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;
@@ -13059,12 +13087,33 @@ function createArrayGlobal(budget) {
     guest: true,
     sandbox: true,
     call: (args) => createArrayFromConstructorArgs(args, budget),
-    construct: (args) => createArrayFromConstructorArgs(args, budget),
+    construct: async (args, context) => {
+      const target = context?.newTarget;
+      const parent = target === void 0 || target === constructor ? prototype : context?.getProperty === void 0 ? await readPropertyDescriptor(
+        getSandboxPropertyDescriptor(target, "prototype", budget) ?? { value: void 0 },
+        target,
+        context
+      ) : await context.getProperty(target, "prototype");
+      const value = createArrayFromConstructorArgs(args, budget);
+      if (parent !== prototype && typeof parent === "object" && parent !== null)
+        setSandboxPrototype(value, parent, budget);
+      return value;
+    },
     name: "Array",
     length: 1
   });
   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 });
   for (const name of arrayMethodNames) {
     const method = createSandboxClosure({
@@ -13103,7 +13152,33 @@ function createArrayGlobal(budget) {
   const statics = {
     isArray: createSandboxClosure({ sandbox: true, name: "isArray", call: ([value]) => Array.isArray(value) }),
     from: createSandboxClosure({ sandbox: true, name: "from", call: (args, context) => arrayFromSandboxValues(args, budget, context) }),
-    of: createSandboxClosure({ sandbox: true, name: "of", call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), budget) })
+    of: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "of",
+      length: 0,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        let result;
+        const release = retainValues(budget, () => [...args, target, result]);
+        try {
+          result = isSandboxClosure(target) && target.construct !== void 0 ? await invokeBuiltinClosure(target, [args.length], budget, context, void 0, true) : createArrayFromConstructorArgs([args.length], budget);
+          const checkData = createDataCheckpoint(budget, context);
+          checkData(result, 0, true);
+          for (let index = 0; index < args.length; index += 1) {
+            budget.visitNode();
+            if (Array.isArray(result)) budget.allocateArrayLength(index + 1);
+            defineOwnDataProperty(objectProperties(result, true), String(index), args[index]);
+            checkData(result, 0, true);
+          }
+          await setSandboxProperty(result, "length", args.length, budget, true, context);
+          checkData(result, 0, true);
+          return allocateProducedSandboxValue(result, budget);
+        } finally {
+          release();
+        }
+      }
+    })
   };
   for (const [name, value] of Object.entries(statics))
     Object.defineProperty(properties, name, { value, writable: true, configurable: true });
@@ -13410,7 +13485,7 @@ async function arrayFromSandboxValues(args, budget, context) {
       }
       index += 1;
     }
-    setSandboxProperty(result, "length", index, budget);
+    await setSandboxProperty(result, "length", index, budget, true, context);
     checkData(result, 0, true);
     return allocateProducedSandboxValue(result, budget);
   } finally {
@@ -13419,11 +13494,11 @@ async function arrayFromSandboxValues(args, budget, context) {
 }
 function createArrayFromConstructorArgs(args, budget) {
   if (args.length !== 1) {
-    return budgetSandboxValue(Reflect.apply(Array, Array, [...args]), budget);
+    return allocateProducedSandboxValue([...args], budget);
   }
   const [lengthOrValue] = args;
   if (typeof lengthOrValue !== "number") {
-    return budgetSandboxValue([lengthOrValue], budget);
+    return allocateProducedSandboxValue([lengthOrValue], budget);
   }
   if (!Number.isInteger(lengthOrValue) || lengthOrValue < 0 || lengthOrValue > 4294967295) {
     throw new RangeError("Invalid array length.");
@@ -40728,4 +40803,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-DB2DTDG3.js.map
+//# sourceMappingURL=chunk-2Y6SJCIT.js.map