@poe-platform/safe-js 0.1.154 → 0.1.156

package/dist/safe-js/chunks/{chunk-KHKBLB42.js → chunk-4DTGT4CA.js}

@@ -2547,7 +2547,7 @@ var ordinaryFunctionContext = {
   await: true
 };
 var Parser = class {
-  constructor(tokens, source, compilation, functionContext = "normal", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
+  constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
     this.tokens = tokens;
     this.source = source;
     this.compilation = compilation;
@@ -2720,7 +2720,7 @@ var Parser = class {
       ...this.lexicalContext,
       return: true,
       await: isAsync || this.lexicalContext.strictAwait !== true
-    }, () => this.parseArrowFunctionBody(params));
+    }, () => this.parseArrowFunctionBody(params, isAsync));
     return this.withFunctionSource({
       type: "ArrowFunctionExpression",
       async: isAsync,
@@ -2760,11 +2760,11 @@ var Parser = class {
       this.conditionalExpressionDepth -= 1;
     }
   }
-  parseArrowFunctionBody(params) {
+  parseArrowFunctionBody(params, async) {
     if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-      return this.withFunctionContext("normal", () => this.parseBlockStatement(params));
+      return this.withFunctionContext(async ? "async" : "normal", () => this.parseBlockStatement(params));
     }
-    return this.withFunctionContext("normal", () => this.parseExpression().node);
+    return this.withFunctionContext(async ? "async" : "normal", () => this.parseExpression().node);
   }
   parseBlockStatement(params, catchParam) {
     const start = this.expectPunctuator("{");
@@ -3039,9 +3039,16 @@ var Parser = class {
   }
   parseForStatement(labels) {
     const forToken = this.expectKeyword("for");
+    const awaitToken = this.consumeKeyword("await");
+    if (awaitToken !== void 0 && this.functionContext !== "top-level" && this.functionContext !== "async" && this.functionContext !== "async-generator") {
+      throw new Error("for await is only valid at top level or inside an async function.");
+    }
     return this.withScope(() => {
       this.expectPunctuator("(");
       const iterationOperator = this.findTopLevelForIterationOperator(this.index);
+      if (awaitToken !== void 0 && iterationOperator?.value !== "of") {
+        throw new Error("for await requires an of loop.");
+      }
       if (iterationOperator?.value === "in") {
         const left = this.parseForInLeft();
         this.expectKeyword("in");
@@ -3065,6 +3072,7 @@ var Parser = class {
         const body2 = this.withLoopContext(() => this.parseStatement());
         return {
           type: "ForOfStatement",
+          ...awaitToken === void 0 ? {} : { await: true },
           left,
           right,
           body: body2,
@@ -3417,7 +3425,7 @@ var Parser = class {
       if (accessor === "set" && (params.length !== 1 || params[0]?.type === "RestElement"))
         throw new Error("A setter must have exactly one non-rest parameter.");
       const bodyTokenIndex = this.index;
-      const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : "normal", () => this.parseBlockStatement(params));
+      const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : async ? "async" : "normal", () => this.parseBlockStatement(params));
       if (accessor === "set" && params[0]?.type !== "Identifier") {
         let directiveTokenIndex = bodyTokenIndex + 1;
         for (const statement of body.body) {
@@ -9920,7 +9928,193 @@ function assertSnapshotInactive(snapshot) {
   }
 }
 
+// packages/safe-js/src/interp/jobs.ts
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var activeJob = new AsyncLocalStorage4();
+var SandboxJobQueue = class {
+  running = false;
+  pending = [];
+  ready = [];
+  idle = [];
+  generation = 0;
+  acquire(job) {
+    return new Promise((resolve) => {
+      this.pending.push(() => {
+        this.running = true;
+        this.generation += 1;
+        job.ownsExecution = true;
+        resolve();
+      });
+      this.advance();
+    });
+  }
+  release(job) {
+    job.prefixParent = void 0;
+    if (!job.ownsExecution) return;
+    job.ownsExecution = false;
+    this.running = false;
+    this.advance();
+  }
+  async run(task) {
+    const job = { queue: this, ownsExecution: false };
+    await this.acquire(job);
+    return activeJob.run(job, async () => {
+      try {
+        return await task();
+      } finally {
+        this.release(job);
+      }
+    });
+  }
+  async drain() {
+    let idleTurns = 0;
+    while (idleTurns < 20) {
+      const generation = this.generation;
+      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
+      await Promise.resolve();
+      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+    }
+  }
+  advance() {
+    if (this.running) return;
+    if (this.ready.length === 0 && this.pending.length > 0) {
+      const empty = this.ready;
+      this.ready = this.pending.reverse();
+      this.pending = empty;
+    }
+    const next = this.ready.pop();
+    if (next !== void 0) {
+      next();
+    } else {
+      for (const resolve of this.idle.splice(0)) resolve();
+    }
+  }
+};
+function runPromiseJob(task) {
+  const job = activeJob.getStore();
+  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
+}
+function runAsyncPrefix(task) {
+  const parent = activeJob.getStore();
+  if (parent === void 0) return task();
+  let owner = parent;
+  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
+  if (owner === void 0) return parent.queue.run(task);
+  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
+  return activeJob.run(job, async () => {
+    try {
+      return await task();
+    } finally {
+      job.queue.release(job);
+    }
+  });
+}
+async function suspendJob(pending) {
+  const job = activeJob.getStore();
+  if (job === void 0) return pending;
+  job.queue.release(job);
+  try {
+    return await pending;
+  } finally {
+    await job.queue.acquire(job);
+  }
+}
+
 // packages/safe-js/src/interp/iteration.ts
+function getSandboxAsyncIterator(value, budget, context, signal) {
+  if (isSandboxGenerator(value) && value.async) {
+    return { ...generatorIterator(value, budget), asyncProtocol: true };
+  }
+  if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
+    const method = value[Symbol.asyncIterator];
+    if (method !== void 0 && method !== null) {
+      if (typeof method !== "function") throw new TypeError("Async iterator method must be callable.");
+      const iterator2 = Reflect.apply(method, value, []);
+      if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null) {
+        throw new TypeError("Async iterator must be an object.");
+      }
+      const next = iterator2.next;
+      const invoke2 = async (operation, args) => {
+        if (typeof operation !== "function") throw new TypeError("Async iterator operation must be callable.");
+        const pending = Promise.resolve(Reflect.apply(operation, iterator2, args)).then((result2) => ({ result: result2 }));
+        const { result } = await awaitWithSignal(pending, signal);
+        if (typeof result !== "object" && typeof result !== "function" || result === null) {
+          throw new TypeError("Iterator result must be an object.");
+        }
+        return {
+          get done() {
+            return result.done;
+          },
+          get value() {
+            return result.value;
+          }
+        };
+      };
+      return {
+        asyncProtocol: true,
+        retainedValue: value,
+        next: (...args) => invoke2(next, args),
+        get return() {
+          const operation = iterator2.return;
+          return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
+        },
+        get throw() {
+          const operation = iterator2.throw;
+          return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
+        }
+      };
+    }
+  }
+  const iterator = getSandboxIterator(value, budget, context);
+  if (iterator === void 0) return void 0;
+  const invoke = async (method, args) => {
+    const operation = iterator[method];
+    if (operation === void 0) {
+      if (method === "throw") {
+        await closeIterator(iterator);
+        throw new TypeError("Delegated iterator does not provide a throw method.");
+      }
+      return { done: true, value: args[0] };
+    }
+    const returned = operation(...args);
+    const result = iterator.generator || iterator.asynchronous ? await returned : returned;
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      throw new TypeError("Iterator result must be an object.");
+    }
+    const done = Boolean(result.done);
+    const resultValue = result.value;
+    try {
+      return { done, value: await awaitSandboxValue(resultValue, signal, budget) };
+    } catch (error) {
+      if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+      if (!done && method !== "return") await closeIterator(iterator, true);
+      throw error;
+    }
+  };
+  return {
+    asyncProtocol: true,
+    snapshotIndex: iterator.snapshotIndex,
+    get retainedValue() {
+      return iterator.retainedValue;
+    },
+    next: (...args) => invoke("next", args),
+    return: (...args) => invoke("return", args),
+    throw: (...args) => invoke("throw", args)
+  };
+}
+async function closeIterator(iterator, preserveThrow = false) {
+  try {
+    const close = iterator.return;
+    if (close === void 0) return;
+    const returned = close();
+    const result = iterator.asyncProtocol ? await suspendJob(Promise.resolve(returned)) : iterator.generator || iterator.asynchronous ? await returned : returned;
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      throw new TypeError("Iterator return result must be an object.");
+    }
+  } catch (error) {
+    if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+  }
+}
 function getSandboxIterator(value, budget, context) {
   if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
     const primitive = boxedValue(value);
@@ -10065,98 +10259,6 @@ function syncIterator(iterator) {
   };
 }
 
-// packages/safe-js/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
-var activeJob = new AsyncLocalStorage4();
-var SandboxJobQueue = class {
-  running = false;
-  pending = [];
-  ready = [];
-  idle = [];
-  generation = 0;
-  acquire(job) {
-    return new Promise((resolve) => {
-      this.pending.push(() => {
-        this.running = true;
-        this.generation += 1;
-        job.ownsExecution = true;
-        resolve();
-      });
-      this.advance();
-    });
-  }
-  release(job) {
-    job.prefixParent = void 0;
-    if (!job.ownsExecution) return;
-    job.ownsExecution = false;
-    this.running = false;
-    this.advance();
-  }
-  async run(task) {
-    const job = { queue: this, ownsExecution: false };
-    await this.acquire(job);
-    return activeJob.run(job, async () => {
-      try {
-        return await task();
-      } finally {
-        this.release(job);
-      }
-    });
-  }
-  async drain() {
-    let idleTurns = 0;
-    while (idleTurns < 20) {
-      const generation = this.generation;
-      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
-      await Promise.resolve();
-      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
-    }
-  }
-  advance() {
-    if (this.running) return;
-    if (this.ready.length === 0 && this.pending.length > 0) {
-      const empty = this.ready;
-      this.ready = this.pending.reverse();
-      this.pending = empty;
-    }
-    const next = this.ready.pop();
-    if (next !== void 0) {
-      next();
-    } else {
-      for (const resolve of this.idle.splice(0)) resolve();
-    }
-  }
-};
-function runPromiseJob(task) {
-  const job = activeJob.getStore();
-  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
-}
-function runAsyncPrefix(task) {
-  const parent = activeJob.getStore();
-  if (parent === void 0) return task();
-  let owner = parent;
-  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
-  if (owner === void 0) return parent.queue.run(task);
-  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
-  return activeJob.run(job, async () => {
-    try {
-      return await task();
-    } finally {
-      job.queue.release(job);
-    }
-  });
-}
-async function suspendJob(pending) {
-  const job = activeJob.getStore();
-  if (job === void 0) return pending;
-  job.queue.release(job);
-  try {
-    return await pending;
-  } finally {
-    await job.queue.acquire(job);
-  }
-}
-
 // packages/safe-js/src/interp/promise.ts
 var promiseConstructors = /* @__PURE__ */ new WeakSet();
 var intrinsicPromiseConstructors = /* @__PURE__ */ new WeakMap();
@@ -17811,7 +17913,7 @@ function statementContainsAwait(node) {
       return (node.init?.type === "VariableDeclaration" ? variableDeclarationContainsAwait(node.init) : node.init !== void 0 && expressionContainsAwait(node.init)) || node.test !== void 0 && expressionContainsAwait(node.test) || node.update !== void 0 && expressionContainsAwait(node.update) || statementContainsAwait(node.body);
     case "ForInStatement":
     case "ForOfStatement":
-      return node.left.type === "VariableDeclaration" && variableDeclarationContainsAwait(node.left) || node.left.type !== "VariableDeclaration" && assignmentTargetContainsAwait(node.left) || expressionContainsAwait(node.right) || statementContainsAwait(node.body);
+      return node.type === "ForOfStatement" && node.await === true || node.left.type === "VariableDeclaration" && variableDeclarationContainsAwait(node.left) || node.left.type !== "VariableDeclaration" && assignmentTargetContainsAwait(node.left) || expressionContainsAwait(node.right) || statementContainsAwait(node.body);
     case "WhileStatement":
     case "DoWhileStatement":
       return expressionContainsAwait(node.test) || statementContainsAwait(node.body);
@@ -29772,7 +29874,7 @@ async function evaluateForOfStatement(node, context) {
     const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
     if (restored.found && Array.isArray(restored.value)) {
       restoredEntry = { done: false, value: restored.value[1] };
-      if (isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
+      if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
         return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
       }
     }
@@ -29781,7 +29883,7 @@ async function evaluateForOfStatement(node, context) {
   if (iterable.kind !== "normal") {
     return iterable;
   }
-  const values = snapshotableIterationValues(iterable.value);
+  const values = node.await ? void 0 : snapshotableIterationValues(iterable.value);
   if (values === void 0) {
     return evaluateForOfIterator(node, iterable.value, context, restoredEntry);
   }
@@ -29820,16 +29922,27 @@ async function evaluateForOfStatement(node, context) {
   };
 }
 async function evaluateForOfIterator(node, value, context, restoredEntry) {
-  const iterator = getSandboxIterator(value, context.budget, createCoercionContext(context));
+  const iterator = node.await ? getSandboxAsyncIterator(value, context.budget, createCoercionContext(context), context.signal) : getSandboxIterator(value, context.budget, createCoercionContext(context));
   if (iterator === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
   }
+  const nextIteration = async () => {
+    const pending = Promise.resolve(iterator.next());
+    if (!node.await) return pending;
+    context.onSuspend?.();
+    const leaveAwait = context.budget.enterAwait();
+    try {
+      return await suspendJob(pending);
+    } finally {
+      leaveAwait();
+    }
+  };
   const releaseIterator = retainValues(context.budget, () => [value, iterator.retainedValue]);
   try {
     const nodeId = node.nodeId ?? -1;
     let index = consumeRestoredLoopIterationIndex(node, context);
     for (let skipped = 0; skipped < index; skipped += 1) {
-      const skippedIteration = await iterator.next();
+      const skippedIteration = await nextIteration();
       if (typeof skippedIteration !== "object" || skippedIteration === null) {
         throw new TypeError("Iterator result must be an object.");
       }
@@ -29838,7 +29951,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
       }
     }
     while (true) {
-      const iteration = restoredEntry ?? await iterator.next();
+      const iteration = restoredEntry ?? await nextIteration();
       restoredEntry = void 0;
       if (typeof iteration !== "object" || iteration === null) {
         throw new TypeError("Iterator result must be an object.");
@@ -30133,7 +30246,7 @@ function createLoopIterationContext(context, scope) {
       if (context.activeLoopIterations.size === 0) return snapshot;
       snapshot.loopIterations = {};
       for (const [nodeId, iteration] of context.activeLoopIterations) {
-        if (typeof iteration !== "number" && (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
+        if (typeof iteration !== "number" && (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
           const bindingName = `#for-of:${nodeId}`;
           snapshot.bindings[bindingName] = iteration.values;
           snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -31610,21 +31723,6 @@ function describeObjectSpreadValue(value) {
   }
   return typeof value;
 }
-async function closeIterator(iterator, preserveThrow = false) {
-  try {
-    const close = iterator.return;
-    if (close === void 0) return;
-    const returned = close();
-    const result = iterator.generator || iterator.asynchronous ? await returned : returned;
-    if (typeof result !== "object" && typeof result !== "function" || result === null) {
-      throw new TypeError("Iterator return result must be an object.");
-    }
-  } catch (error) {
-    if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) {
-      throw error;
-    }
-  }
-}
 function defineSandboxProperty(target, key, value) {
   Object.defineProperty(target, key, {
     configurable: true,
@@ -35610,4 +35708,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-KHKBLB42.js.map
+//# sourceMappingURL=chunk-4DTGT4CA.js.map