@poe-platform/safe-js 0.1.99 → 0.1.100

package/dist/safe-js/chunks/{chunk-ZFJQGJ3M.js → chunk-GUU3L2FD.js}

@@ -8184,6 +8184,28 @@ function isCounter(value) {
 // packages/safe-js/src/interp/cancel.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 
+// packages/safe-js/src/interp/builtin-call.ts
+async function invokeBuiltinClosure(closure, args, budget, context, thisValue, construct = false) {
+  if (context?.invokeClosure !== void 0) {
+    return context.invokeClosure(closure, args, thisValue, construct);
+  }
+  const leaveCall = budget.enterCall();
+  try {
+    const invoke = construct ? closure.construct : closure.call;
+    if (invoke === void 0) throw new TypeError("Value is not a constructor.");
+    const result = await invoke(args, {
+      ...context,
+      stack: context?.stack ?? [],
+      thisValue,
+      invokeClosure: (target, values, receiver, asConstructor) => invokeBuiltinClosure(target, values, budget, context, receiver, asConstructor)
+    });
+    if (isSandboxPromise(result)) await result.synchronousPrefix;
+    return result;
+  } finally {
+    leaveCall();
+  }
+}
+
 // packages/safe-js/src/interp/regex/engine.ts
 function matchRegex(pattern, input, lastIndex = 0) {
   const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
@@ -8485,49 +8507,39 @@ function toMatchArray(match, input) {
 
 // packages/safe-js/src/interp/string-coercion.ts
 var defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
+var defaultValueHook = /* @__PURE__ */ Symbol("defaultValueHook");
+function sandboxNumber(value, budget, context) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
+    return Number(value);
+  }
+  return objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number").then(Number);
+}
 function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value !== "object") {
     if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
     return budget.allocateString(String(value));
   }
-  const invocation = context?.invokeClosure !== void 0 ? context : {
-    ...context,
-    stack: context?.stack ?? [],
-    thisValue: context?.thisValue,
-    invokeClosure: async (closure, args, thisValue) => {
-      const leaveCall = budget.enterCall();
-      try {
-        const result = closure.call(args, { ...invocation, thisValue });
-        if (isSandboxPromise(result)) {
-          await result.synchronousPrefix;
-          return result;
-        }
-        return await result;
-      } finally {
-        leaveCall();
-      }
-    }
-  };
-  return stringifyObject(value, budget, invocation, joining);
+  return objectToPrimitive(value, budget, context, joining, "string").then((primitive) => budget.allocateString(String(primitive)));
 }
-async function stringifyObject(value, budget, context, joining) {
+async function objectToPrimitive(value, budget, context, joining, hint) {
   const leaveCall = budget.enterCall();
   try {
     budget.visitNode();
-    for (const name of ["toString", "valueOf"]) {
+    for (const name of hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"]) {
       const hook = conversionHook(value, name, budget);
       let result;
       if (hook === defaultStringHook) {
         result = await defaultToString(value, budget, context, joining);
+      } else if (hook === defaultValueHook) {
+        result = isSandboxDate(value) ? dateTime(value) : value;
       } else {
         if (!isSandboxClosure(hook)) continue;
-        if (context?.invokeClosure === void 0) {
-          throw new TypeError("String hooks require a sandbox call context.");
-        }
-        result = await context.invokeClosure(hook, [], value);
+        result = await invokeBuiltinClosure(hook, [], budget, context, value);
       }
       if (result === null || typeof result !== "object") {
-        return sandboxString(result, budget, context, joining);
+        if (typeof result === "function") throw new TypeError("Expected a sandbox value.");
+        return result;
       }
     }
     throw new TypeError("Cannot convert object to primitive value");
@@ -8549,7 +8561,7 @@ function conversionHook(value, name, budget) {
     }
     const parent = getSandboxPrototype(current, budget);
     if (current === value && (implicitBuiltin || parent === null && !hasExplicitSandboxPrototype(value))) {
-      return name === "toString" ? defaultStringHook : void 0;
+      return name === "toString" ? defaultStringHook : defaultValueHook;
     }
     current = parent;
     if (current !== null) {
@@ -8574,10 +8586,7 @@ async function defaultToString(value, budget, context, joining) {
       const join = ownDataValue(value, "join");
       if (!isSandboxClosure(join))
         return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
-      if (context?.invokeClosure === void 0) {
-        throw new TypeError("String hooks require a sandbox call context.");
-      }
-      return context.invokeClosure(join, [], value);
+      return invokeBuiltinClosure(join, [], budget, context, value);
     }
     if (joining.has(value)) return "";
     joining.add(value);
@@ -28080,7 +28089,9 @@ function createCoercionContext(context) {
     stack: context.callStack,
     thisValue: void 0,
     compilation: context.compilation,
-    invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue)
+    getProperty: (value, property) => getPropertyValue(value, property, context),
+    reconcileData: (value) => reconcileDataBudget(context.budget, context.stats, context.scope, value, context.compilation, context.compilation?.parent),
+    invokeClosure: (closure, args, thisValue, construct) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue, construct)
   };
 }
 function hasSandboxProperty(value, key, context) {
@@ -28457,7 +28468,9 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
         stack,
         thisValue,
         compilation: context.compilation,
-        invokeClosure: (closure, argumentsList, receiver) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver),
+        getProperty: (value, property) => getPropertyValue(value, property, context),
+        reconcileData: (value) => reconcileDataBudget(context.budget, context.stats, context.scope, value, context.compilation, context.compilation?.parent),
+        invokeClosure: (closure, argumentsList, receiver, asConstructor) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver, asConstructor),
         ...span === void 0 ? {} : { span }
       }
     ]);
@@ -30153,7 +30166,7 @@ async function stringifyValue(value, state, indent) {
     return stringifyArray(value, state, indent);
   }
   if (isStringifyObject(value)) {
-    return stringifyObject2(value, state, indent);
+    return stringifyObject(value, state, indent);
   }
   return void 0;
 }
@@ -30179,7 +30192,7 @@ ${indent}]`;
     leaveStringifyObject(value, state);
   }
 }
-async function stringifyObject2(value, state, indent) {
+async function stringifyObject(value, state, indent) {
   enterStringifyObject(value, state);
   try {
     const nextIndent = indent + state.gap;
@@ -30550,7 +30563,7 @@ function createObjectArrayGlobals(options) {
         }),
         from: createSandboxClosure({
           sandbox: true,
-          call: (args) => arrayFromSandboxValues(args, options.budget),
+          call: (args, context) => arrayFromSandboxValues(args, options.budget, context),
           name: "from"
         }),
         of: createSandboxClosure({
@@ -30730,40 +30743,86 @@ function defineDataProperty2(target, key, descriptor, budget) {
 function isAssignableSandboxTarget(value) {
   return typeof value === "object" && value !== null && !isSandboxClosure(value) && !isSandboxGenerator(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value);
 }
-async function arrayFromSandboxValues(args, budget) {
+async function arrayFromSandboxValues(args, budget, context) {
   const [items, mapFn, thisValue] = args;
+  if (mapFn !== void 0 && !isSandboxClosure(mapFn)) {
+    throw new TypeError("Array.from mapping callback must be a function.");
+  }
+  if (items === null || items === void 0) {
+    throw new TypeError("Array.from requires a non-null input.");
+  }
+  const read = (property) => context?.getProperty !== void 0 ? context.getProperty(items, property) : getSandboxDataProperty(items, property, budget);
   const iterator = getSandboxIterator(items);
-  if (isGuestHostObject(items) && iterator !== void 0) {
-    if (mapFn !== void 0 && !isSandboxClosure(mapFn))
-      throw new TypeError("Array.from mapping callback must be a function.");
-    const values2 = [];
-    while (true) {
-      const next = await iterator.next();
-      if (next.done) break;
-      budget.allocateArrayLength(values2.length + 1);
-      const value = mapFn === void 0 ? next.value : await mapFn.call([next.value, values2.length], { stack: [], thisValue });
-      if (isSandboxPromise(value) && value.synchronousPrefix !== void 0)
-        await value.synchronousPrefix;
-      values2.push(value);
+  const constructor = context?.thisValue;
+  let result;
+  let currentValue;
+  let failure;
+  let estimatedDataSize = 0;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [items, mapFn, constructor, result, currentValue, failure]);
+  const checkData = (growth = 0, force = false) => {
+    const limit = budget.limits.dataSize;
+    if (limit === void 0) return;
+    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+    if (!force && estimatedDataSize <= limit) return;
+    if (context?.reconcileData !== void 0) context.reconcileData(result);
+    else reconcileCompiledValues(budget, [], context?.compilation);
+    estimatedDataSize = budget.currentDataSize;
+  };
+  const closeOnThrow = async (error) => {
+    failure = isCapturedException(error) ? error.reason : error;
+    try {
+      await iterator?.return?.();
+    } catch (closeError) {
+      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
     }
-    return allocateProducedSandboxValue(values2, budget);
-  }
-  const values = iterator === void 0 ? Reflect.apply(Array.from, Array, [items]) : await collectIteratorValues(iterator);
-  if (mapFn === void 0 || !isSandboxClosure(mapFn)) {
-    if (mapFn !== void 0) {
-      throw new TypeError("Array.from mapping callback must be a function.");
+    throw error;
+  };
+  try {
+    let length = 0;
+    if (iterator === void 0) {
+      const number = await sandboxNumber(read("length"), budget, context);
+      length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
     }
-    return budgetSandboxValue2(values, budget);
-  }
-  const mappedValues = [];
-  for (const [index, value] of values.entries()) {
-    const result = await mapFn.call([value, index], { stack: [], thisValue });
-    if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
-      await result.synchronousPrefix;
+    result = isSandboxClosure(constructor) && constructor.construct !== void 0 ? await invokeBuiltinClosure(constructor, iterator === void 0 ? [length] : [], budget, context, void 0, true) : createArrayFromConstructorArgs([length], budget);
+    checkData(0, true);
+    let index = 0;
+    while (iterator !== void 0 || index < length) {
+      try {
+        budget.visitNode();
+        if (iterator !== void 0 && index >= Number.MAX_SAFE_INTEGER) throw new TypeError("Array.from input is too long.");
+      } catch (error) {
+        await closeOnThrow(error);
+      }
+      if (iterator !== void 0) {
+        const next = await iterator.next();
+        if (typeof next !== "object" || next === null) throw new TypeError("Iterator result must be an object.");
+        if (next.done) break;
+        currentValue = next.value;
+      } else {
+        currentValue = read(index);
+      }
+      try {
+        if (Array.isArray(result)) budget.allocateArrayLength(index + 1);
+        if (mapFn !== void 0) currentValue = await invokeBuiltinClosure(mapFn, [currentValue, index], budget, context, thisValue);
+        const key = String(index);
+        const growth = key.length + 1 + (Array.isArray(result) ? Math.max(0, index + 1 - result.length) : 0) + (typeof currentValue === "string" ? currentValue.length : 0);
+        const graphChanged = typeof currentValue === "object" && currentValue !== null || isSandboxClosure(result);
+        budget.visitNode();
+        defineOwnDataProperty(objectProperties(result, true), key, currentValue);
+        currentValue = void 0;
+        checkData(growth, graphChanged);
+      } catch (error) {
+        await closeOnThrow(error);
+      }
+      index += 1;
     }
-    mappedValues.push(result);
+    setSandboxProperty(result, "length", index, budget);
+    checkData(0, true);
+    return allocateProducedSandboxValue(result, budget);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
   }
-  return budgetSandboxValue2(mappedValues, budget);
 }
 function createArrayFromConstructorArgs(args, budget) {
   if (args.length !== 1) {
@@ -30777,14 +30836,11 @@ function createArrayFromConstructorArgs(args, budget) {
     throw new RangeError("Invalid array length.");
   }
   budget.allocateArrayLength(lengthOrValue);
-  return new Array(lengthOrValue);
-}
-async function collectIteratorValues(iterator) {
-  const values = [];
-  while (true) {
-    const result = await iterator.next();
-    if (result.done) return values;
-    values.push(result.value);
+  const release = budget.provisionDataUsage(lengthOrValue + 1);
+  try {
+    return new Array(lengthOrValue);
+  } finally {
+    release();
   }
 }
 function getOwnEnumerableKeys(value) {
@@ -32944,4 +33000,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-ZFJQGJ3M.js.map
+//# sourceMappingURL=chunk-GUU3L2FD.js.map