@poe-platform/safe-js 0.1.295 → 0.1.296

package/dist/safe-js/chunks/{chunk-CL6E5SM7.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;
@@ -13076,6 +13104,16 @@ 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 });
   for (const name of arrayMethodNames) {
     const method = createSandboxClosure({
@@ -40765,4 +40803,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CL6E5SM7.js.map
+//# sourceMappingURL=chunk-2Y6SJCIT.js.map