poe-code 14.0.69 → 14.0.70

package/dist/index.js

@@ -123052,7 +123052,7 @@ var init_parser3 = __esm({
       await: true
     };
     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;
@@ -123225,7 +123225,7 @@ var init_parser3 = __esm({
           ...this.lexicalContext,
           return: true,
           await: isAsync || this.lexicalContext.strictAwait !== true
-        }, () => this.parseArrowFunctionBody(params));
+        }, () => this.parseArrowFunctionBody(params, isAsync));
         return this.withFunctionSource({
           type: "ArrowFunctionExpression",
           async: isAsync,
@@ -123265,11 +123265,11 @@ var init_parser3 = __esm({
           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("{");
@@ -123544,9 +123544,16 @@ var init_parser3 = __esm({
       }
       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");
@@ -123570,6 +123577,7 @@ var init_parser3 = __esm({
             const body2 = this.withLoopContext(() => this.parseStatement());
             return {
               type: "ForOfStatement",
+              ...awaitToken === void 0 ? {} : { await: true },
               left,
               right,
               body: body2,
@@ -123922,7 +123930,7 @@ var init_parser3 = __esm({
           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) {
@@ -129946,7 +129954,199 @@ var init_running_state = __esm({
   }
 });
 
+// packages/safe-js/src/interp/jobs.ts
+import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
+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);
+  }
+}
+var activeJob, SandboxJobQueue;
+var init_jobs4 = __esm({
+  "packages/safe-js/src/interp/jobs.ts"() {
+    "use strict";
+    activeJob = new AsyncLocalStorage7();
+    SandboxJobQueue = class {
+      running = false;
+      pending = [];
+      ready = [];
+      idle = [];
+      generation = 0;
+      acquire(job) {
+        return new Promise((resolve16) => {
+          this.pending.push(() => {
+            this.running = true;
+            this.generation += 1;
+            job.ownsExecution = true;
+            resolve16();
+          });
+          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((resolve16) => this.idle.push(resolve16));
+          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 resolve16 of this.idle.splice(0)) resolve16();
+        }
+      }
+    };
+  }
+});
+
 // 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 invoke3 = 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) => invoke3(next, args),
+        get return() {
+          const operation = iterator2.return;
+          return operation === void 0 || operation === null ? void 0 : (...args) => invoke3(operation, args);
+        },
+        get throw() {
+          const operation = iterator2.throw;
+          return operation === void 0 || operation === null ? void 0 : (...args) => invoke3(operation, args);
+        }
+      };
+    }
+  }
+  const iterator = getSandboxIterator(value, budget, context);
+  if (iterator === void 0) return void 0;
+  const invoke2 = 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 (error3) {
+      if (isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) throw error3;
+      if (!done && method !== "return") await closeIterator(iterator, true);
+      throw error3;
+    }
+  };
+  return {
+    asyncProtocol: true,
+    snapshotIndex: iterator.snapshotIndex,
+    get retainedValue() {
+      return iterator.retainedValue;
+    },
+    next: (...args) => invoke2("next", args),
+    return: (...args) => invoke2("return", args),
+    throw: (...args) => invoke2("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 (error3) {
+    if (!preserveThrow || isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) throw error3;
+  }
+}
 function getSandboxIterator(value, budget, context) {
   if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
     const primitive = boxedValue(value);
@@ -130102,108 +130302,12 @@ var init_iteration = __esm({
     init_budget2();
     init_string_coercion();
     init_cancel2();
+    init_host_call();
+    init_jobs4();
     asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
   }
 });
 
-// packages/safe-js/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
-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);
-  }
-}
-var activeJob, SandboxJobQueue;
-var init_jobs4 = __esm({
-  "packages/safe-js/src/interp/jobs.ts"() {
-    "use strict";
-    activeJob = new AsyncLocalStorage7();
-    SandboxJobQueue = class {
-      running = false;
-      pending = [];
-      ready = [];
-      idle = [];
-      generation = 0;
-      acquire(job) {
-        return new Promise((resolve16) => {
-          this.pending.push(() => {
-            this.running = true;
-            this.generation += 1;
-            job.ownsExecution = true;
-            resolve16();
-          });
-          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((resolve16) => this.idle.push(resolve16));
-          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 resolve16 of this.idle.splice(0)) resolve16();
-        }
-      }
-    };
-  }
-});
-
 // packages/safe-js/src/interp/promise.ts
 function isSandboxPromiseConstructor(value) {
   return isSandboxClosure(value) && promiseConstructors.has(value);
@@ -137557,7 +137661,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);
@@ -150217,7 +150321,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);
       }
     }
@@ -150226,7 +150330,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);
   }
@@ -150265,16 +150369,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.");
       }
@@ -150283,7 +150398,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.");
@@ -150578,7 +150693,7 @@ function createLoopIterationContext(context, scope) {
       if (context.activeLoopIterations.size === 0) return snapshot2;
       snapshot2.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}`;
           snapshot2.bindings[bindingName] = iteration.values;
           snapshot2.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -150689,7 +150804,7 @@ async function evaluateYieldExpression(node, context) {
   return generatorCompletionResult(completion);
 }
 async function yieldGeneratorValue(value, node, context) {
-  if (context.asyncGenerator) value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget));
+  if (context.asyncGenerator && !node.delegate) value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget));
   const completionPromise = context.generatorYield(allocateProducedSandboxValue(value, context.budget), node.nodeId);
   emitResumeBreakpoint(context, {
     kind: "generator-yield",
@@ -150711,8 +150826,7 @@ async function evaluateYieldDelegate(node, context) {
   if (argument.kind !== "normal") {
     return argument;
   }
-  const asyncDelegate = context.asyncGenerator && isSandboxGenerator(argument.value) && argument.value.async ? argument.value : void 0;
-  const iterator = asyncDelegate ? generatorIterator(asyncDelegate, context.budget) : getSandboxIterator(
+  const iterator = context.asyncGenerator ? getSandboxAsyncIterator(argument.value, context.budget, createCoercionContext(context), context.signal) : getSandboxIterator(
     argument.value,
     context.budget,
     createCoercionContext(context)
@@ -150747,16 +150861,7 @@ async function evaluateYieldDelegate(node, context) {
         throw new TypeError("Iterator result must be an object.");
       }
       const done = result.done;
-      let value = result.value;
-      if (context.asyncGenerator) {
-        try {
-          value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget));
-        } catch (error3) {
-          if (isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) throw error3;
-          if (!asyncDelegate && !done && method !== "return") await closeIterator(iterator, true);
-          throw error3;
-        }
-      }
+      const value = result.value;
       if (done) {
         if (completion.type === "return") {
           return generatorCompletionResult({ type: "return", value });
@@ -152055,21 +152160,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 (error3) {
-    if (!preserveThrow || isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) {
-      throw error3;
-    }
-  }
-}
 function defineSandboxProperty(target, key3, value) {
   Object.defineProperty(target, key3, {
     configurable: true,