poe-code 14.0.58 → 14.0.60

package/packages/safe-js/dist/chunks/{chunk-DHD453E5.js → chunk-MKJBQPBH.js}

@@ -2525,23 +2525,21 @@ function parseTokens(tokens, compilation) {
 function parseModuleTokens(tokens, compilation) {
   return new Parser(tokens, compilation).parseModule();
 }
-function parseExpressionTokens(tokens, compilation) {
-  return new Parser(tokens, compilation).parseExpressionOnly();
-}
 var Parser = class {
-  constructor(tokens, compilation) {
+  constructor(tokens, compilation, functionContext = "normal") {
     this.tokens = tokens;
     this.compilation = compilation;
+    this.functionContext = functionContext;
     this.functionScopes.add(this.scopes[0]);
   }
   tokens;
   compilation;
+  functionContext;
   index = 0;
   breakableDepth = 0;
   conditionalExpressionDepth = 0;
   ifStatementDepth = 0;
   loopDepth = 0;
-  generatorBody = false;
   scopes = [/* @__PURE__ */ new Map()];
   functionScopes = /* @__PURE__ */ new WeakSet();
   varNames = /* @__PURE__ */ new WeakMap();
@@ -2727,9 +2725,9 @@ var Parser = class {
   }
   parseArrowFunctionBody(params) {
     if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-      return this.withFunctionContext(false, () => this.parseBlockStatement(params));
+      return this.withFunctionContext("normal", () => this.parseBlockStatement(params));
     }
-    return this.withFunctionContext(false, () => this.parseExpression().node);
+    return this.withFunctionContext("normal", () => this.parseExpression().node);
   }
   parseBlockStatement(params, catchParam) {
     const start = this.expectPunctuator("{");
@@ -3333,7 +3331,7 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionDeclaration",
       async: asyncToken !== void 0,
@@ -3368,32 +3366,34 @@ var Parser = class {
     };
   }
   parseArrowParameters() {
-    this.expectPunctuator("(");
-    const params = [];
-    if (this.consumePunctuator(")") !== void 0) {
-      return params;
-    }
-    while (true) {
-      const param = this.parseBindingElement();
-      params.push(param);
-      const comma = this.consumePunctuator(",");
-      if (comma === void 0) {
-        break;
+    return this.withFunctionContext("parameters", () => {
+      this.expectPunctuator("(");
+      const params = [];
+      if (this.consumePunctuator(")") !== void 0) {
+        return params;
       }
-      if (param.type === "RestElement") {
+      while (true) {
+        const param = this.parseBindingElement();
+        params.push(param);
+        const comma = this.consumePunctuator(",");
+        if (comma === void 0) {
+          break;
+        }
+        if (param.type === "RestElement") {
+          if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
+            throw unexpectedTokenError(comma);
+          }
+          throw new Error(
+            `Rest element must be the last parameter at line ${comma.start.line}, column ${comma.start.column}.`
+          );
+        }
         if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
-          throw unexpectedTokenError(comma);
+          break;
         }
-        throw new Error(
-          `Rest element must be the last parameter at line ${comma.start.line}, column ${comma.start.column}.`
-        );
-      }
-      if (this.currentToken().type === "punctuator" && this.currentToken().value === ")") {
-        break;
       }
-    }
-    this.expectPunctuator(")");
-    return params;
+      this.expectPunctuator(")");
+      return params;
+    });
   }
   parseBindingElement() {
     if (this.consumePunctuator("...") !== void 0) {
@@ -3947,7 +3947,7 @@ var Parser = class {
       };
     }
     if (token.type === "keyword" && token.value === "yield") {
-      if (!this.generatorBody) {
+      if (this.functionContext !== "generator") {
         throw new Error(
           `yield is only valid inside a generator body at line ${token.start.line}, column ${token.start.column}.`
         );
@@ -3974,11 +3974,16 @@ var Parser = class {
       };
     }
     if (token.type === "keyword" && token.value === "await") {
-      if (this.generatorBody) {
+      if (this.functionContext === "generator") {
         throw new Error(
           `generators cannot await; use a regular async function at line ${token.start.line}, column ${token.start.column}.`
         );
       }
+      if (this.functionContext === "parameters") {
+        throw new Error(
+          `await is not valid in function parameters at line ${token.start.line}, column ${token.start.column}.`
+        );
+      }
       this.index += 1;
       const argument = this.parseUnaryExpression();
       return {
@@ -4103,7 +4108,7 @@ var Parser = class {
       if (this.currentToken().type === "template") {
         const quasi = createTemplateLiteral(
           this.currentToken(),
-          { allowMalformedEscapes: true },
+          { allowMalformedEscapes: true, functionContext: this.functionContext },
           this.compilation
         );
         this.index += 1;
@@ -4190,7 +4195,11 @@ var Parser = class {
     if (token.type === "template") {
       this.index += 1;
       return {
-        node: createTemplateLiteral(token, { allowMalformedEscapes: false }, this.compilation),
+        node: createTemplateLiteral(
+          token,
+          { allowMalformedEscapes: false, functionContext: this.functionContext },
+          this.compilation
+        ),
         parenthesized: false
       };
     }
@@ -4306,7 +4315,7 @@ var Parser = class {
       return parsedParams;
     });
     const generator = generatorToken !== void 0;
-    const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionExpression",
       async: asyncToken !== void 0,
@@ -4550,7 +4559,7 @@ var Parser = class {
       }
       return parsedParams;
     });
-    const body = this.withFunctionContext(false, () => this.parseBlockStatement(params));
+    const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
     return {
       type: "FunctionExpression",
       async: asyncToken !== void 0,
@@ -4955,19 +4964,19 @@ var Parser = class {
   hasReturnArgument(returnToken, nextToken) {
     return !(hasLineBreakBetween(returnToken, nextToken) || nextToken.type === "punctuator" && (nextToken.value === ";" || nextToken.value === "}") || nextToken.type === "eof");
   }
-  withFunctionContext(generatorBody, callback) {
+  withFunctionContext(functionContext, callback) {
     const previousBreakableDepth = this.breakableDepth;
     const previousLoopDepth = this.loopDepth;
-    const previousGeneratorBody = this.generatorBody;
+    const previousFunctionContext = this.functionContext;
     this.breakableDepth = 0;
     this.loopDepth = 0;
-    this.generatorBody = generatorBody;
+    this.functionContext = functionContext;
     try {
       return callback();
     } finally {
       this.breakableDepth = previousBreakableDepth;
       this.loopDepth = previousLoopDepth;
-      this.generatorBody = previousGeneratorBody;
+      this.functionContext = previousFunctionContext;
     }
   }
   withLoopContext(callback) {
@@ -5402,7 +5411,7 @@ function createLiteralFromToken(token) {
   }
   return createKeywordLiteral(token);
 }
-function createTemplateLiteral(token, options = { allowMalformedEscapes: false }, compilation) {
+function createTemplateLiteral(token, options, compilation) {
   const raw = token.value;
   const expressions = [];
   const quasis = [];
@@ -5422,6 +5431,7 @@ function createTemplateLiteral(token, options = { allowMalformedEscapes: false }
         parseEmbeddedExpression(
           raw.slice(expressionStart, expressionEnd),
           positionWithinRaw(token.start, raw, expressionStart),
+          options.functionContext,
           compilation
         )
       );
@@ -5784,13 +5794,13 @@ function decodeHexEscape(value, start) {
     end: index + 2
   };
 }
-function parseEmbeddedExpression(source, base, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, compilation) {
   const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
     ...token,
     start: rebasePosition(token.start, base),
     end: rebasePosition(token.end, base)
   }));
-  return parseExpressionTokens(tokens, compilation);
+  return new Parser(tokens, compilation, functionContext).parseExpressionOnly();
 }
 function findRegexLiteral(node) {
   if (node === null || node === void 0) {
@@ -26595,89 +26605,110 @@ async function evaluateEmptyStatement(_node, _context) {
 }
 async function evaluateArrayExpression(node, context) {
   const values = [];
-  for (const element of node.elements) {
-    if (element.type === "UndefinedLiteral" && element.elision === true) {
-      values.length += 1;
-      context.budget.allocateArrayLength(values.length);
-      continue;
-    }
-    if (element.type === "SpreadElement") {
-      const spreadValues = await evaluateSpreadElement(element, context);
-      if (!spreadValues.ok) {
-        return spreadValues.result;
+  const release = retainValues(context.budget, () => [values]);
+  try {
+    for (const element of node.elements) {
+      if (element.type === "UndefinedLiteral" && element.elision === true) {
+        values.length += 1;
+        context.budget.allocateArrayLength(values.length);
+        continue;
       }
-      appendArrayValues2(values, spreadValues.value);
+      if (element.type === "SpreadElement") {
+        const spreadValues = await evaluateSpreadElement(element, context);
+        if (!spreadValues.ok) {
+          return spreadValues.result;
+        }
+        appendArrayValues2(values, spreadValues.value);
+        context.budget.allocateArrayLength(values.length);
+        continue;
+      }
+      const result = await evaluateNode(element, context);
+      if (result.kind !== "normal") {
+        return result;
+      }
+      values.push(result.value);
       context.budget.allocateArrayLength(values.length);
-      continue;
     }
-    const result = await evaluateNode(element, context);
-    if (result.kind !== "normal") {
-      return result;
-    }
-    values.push(result.value);
-    context.budget.allocateArrayLength(values.length);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: values
+    };
+  } finally {
+    release();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: values
-  };
 }
 async function evaluateObjectExpression(node, context) {
   const object = /* @__PURE__ */ Object.create(null);
-  for (const property of node.properties) {
-    if (property.type === "SpreadElement") {
-      const spreadEntries = await evaluateObjectSpread(property, context);
-      if (!spreadEntries.ok) {
-        return spreadEntries.result;
+  const release = retainValues(context.budget, () => [object]);
+  try {
+    for (const property of node.properties) {
+      if (property.type === "SpreadElement") {
+        const spreadEntries = await evaluateObjectSpread(property, context);
+        if (!spreadEntries.ok) {
+          return spreadEntries.result;
+        }
+        for (const [key2, value2] of spreadEntries.value) {
+          defineSandboxProperty(object, key2, value2);
+        }
+        continue;
       }
-      for (const [key2, value2] of spreadEntries.value) {
-        defineSandboxProperty(object, key2, value2);
+      const key = await evaluateObjectPropertyKey(property, context);
+      if (!key.ok) {
+        return key.result;
       }
-      continue;
-    }
-    const key = await evaluateObjectPropertyKey(property, context);
-    if (!key.ok) {
-      return key.result;
-    }
-    const value = await evaluateNode(property.value, context);
-    if (value.kind !== "normal") {
-      return value;
-    }
-    if (isObjectPrototypeSetterProperty(property, key.value)) {
-      if (value.value === null || typeof value.value === "object") {
-        setSandboxPrototype(object, value.value, context.budget);
+      const releaseKey = retainValues(context.budget, () => [key.value]);
+      let value;
+      try {
+        value = await evaluateNode(property.value, context);
+      } finally {
+        releaseKey();
       }
-      continue;
+      if (value.kind !== "normal") {
+        return value;
+      }
+      if (isObjectPrototypeSetterProperty(property, key.value)) {
+        if (value.value === null || typeof value.value === "object") {
+          setSandboxPrototype(object, value.value, context.budget);
+        }
+        continue;
+      }
+      defineSandboxProperty(object, String(key.value), value.value);
     }
-    defineSandboxProperty(object, String(key.value), value.value);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: object
+    };
+  } finally {
+    release();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: object
-  };
 }
 function isObjectPrototypeSetterProperty(property, key) {
   return !property.computed && !property.shorthand && key === "__proto__";
 }
 async function evaluateTemplateLiteral(node, context) {
   let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
-  for (let index = 0; index < node.expressions.length; index += 1) {
-    const expression = await evaluateNode(node.expressions[index], context);
-    if (expression.kind !== "normal") {
-      return expression;
+  const release = retainValues(context.budget, () => [value]);
+  try {
+    for (let index = 0; index < node.expressions.length; index += 1) {
+      const expression = await evaluateNode(node.expressions[index], context);
+      if (expression.kind !== "normal") {
+        return expression;
+      }
+      const expressionText = context.budget.allocateString(String(expression.value));
+      value = context.budget.allocateString(value + expressionText);
+      const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
+      value = context.budget.allocateString(value + quasiText);
     }
-    const expressionText = context.budget.allocateString(String(expression.value));
-    value = context.budget.allocateString(value + expressionText);
-    const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
-    value = context.budget.allocateString(value + quasiText);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value
+    };
+  } finally {
+    release();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value
-  };
 }
 async function evaluateTaggedTemplateExpression(node, context) {
   const tag = await evaluateNode(node.tag, context);
@@ -26704,20 +26735,25 @@ async function evaluateTaggedTemplateExpression(node, context) {
 }
 async function evaluateTemplateExpressionValues(node, context) {
   const values = [];
-  for (const expressionNode of node.expressions) {
-    const expression = await evaluateNode(expressionNode, context);
-    if (expression.kind !== "normal") {
-      return {
-        ok: false,
-        result: expression
-      };
+  const release = retainValues(context.budget, () => values);
+  try {
+    for (const expressionNode of node.expressions) {
+      const expression = await evaluateNode(expressionNode, context);
+      if (expression.kind !== "normal") {
+        return {
+          ok: false,
+          result: expression
+        };
+      }
+      values.push(expression.value);
     }
-    values.push(expression.value);
+    return {
+      ok: true,
+      value: values
+    };
+  } finally {
+    release();
   }
-  return {
-    ok: true,
-    value: values
-  };
 }
 function createTaggedTemplateStrings(node, context) {
   context.budget.allocateArrayLength(node.quasis.length);
@@ -26765,23 +26801,30 @@ async function evaluateBinaryExpression(node, context) {
   if (left.kind !== "normal") {
     return left;
   }
-  const right = await evaluateNode(node.right, context);
-  if (right.kind !== "normal") {
-    return right;
-  }
-  let leftValue = left.value;
-  if (node.operator === "in") {
-    if (typeof right.value !== "object" || right.value === null) {
-      throw new TypeError("Right-hand side of 'in' must be an object.");
+  let rightValue;
+  const release = retainValues(context.budget, () => [left.value, rightValue]);
+  try {
+    const right = await evaluateNode(node.right, context);
+    if (right.kind !== "normal") {
+      return right;
+    }
+    rightValue = right.value;
+    let leftValue = left.value;
+    if (node.operator === "in") {
+      if (typeof right.value !== "object" || right.value === null) {
+        throw new TypeError("Right-hand side of 'in' must be an object.");
+      }
+      leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
     }
-    leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
+    const value = applyBinaryOperator(node, leftValue, right.value, context);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value
+    };
+  } finally {
+    release();
   }
-  const value = applyBinaryOperator(node, leftValue, right.value, context);
-  return {
-    kind: "normal",
-    hasValue: true,
-    value
-  };
 }
 async function evaluateAssignmentExpression(node, context) {
   if (node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern") {
@@ -26888,21 +26931,29 @@ async function evaluateMemberAssignmentExpression(node, context) {
         value: current
       };
     }
-    const right = await evaluateNode(node.right, context);
-    if (right.kind !== "normal") {
-      return right;
-    }
-    const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-    if (member.object === null || member.object === void 0) {
-      throw new TypeError("Cannot assign properties of null or undefined.");
+    let operands = [current, property];
+    const release = retainValues(context.budget, () => operands);
+    try {
+      const right = await evaluateNode(node.right, context);
+      if (right.kind !== "normal") {
+        return right;
+      }
+      operands.push(right.value);
+      const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+      if (member.object === null || member.object === void 0) {
+        throw new TypeError("Cannot assign properties of null or undefined.");
+      }
+      operands = [value];
+      property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+      setSandboxProperty(member.object, property, value, context.budget);
+      return {
+        kind: "normal",
+        hasValue: true,
+        value
+      };
+    } finally {
+      release();
     }
-    property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    setSandboxProperty(member.object, property, value, context.budget);
-    return {
-      kind: "normal",
-      hasValue: true,
-      value
-    };
   });
 }
 async function evaluateLogicalExpression(node, context) {
@@ -28081,12 +28132,8 @@ async function evaluateMemberAccess(node, context, consume) {
   if ((object.value === null || object.value === void 0) && node.optional) {
     return consume({ kind: "nullish" });
   }
-  const retained = {};
   let property;
-  context.budget.setRetainedValues(retained, () => [object.value, property]);
-  const release = () => context.budget.setRetainedValues(retained, void 0);
-  const pending = runResources.getStore()?.referenceReleases;
-  pending?.add(release);
+  const release = retainValues(context.budget, () => [object.value, property]);
   try {
     const result = node.computed ? await evaluateNode(node.property, context) : { kind: "normal", value: getStaticPropertyName2(node.property) };
     if (result.kind !== "normal") return result;
@@ -28094,9 +28141,19 @@ async function evaluateMemberAccess(node, context, consume) {
     return await consume({ kind: "resolved", object: object.value, property });
   } finally {
     release();
-    pending?.delete(release);
   }
 }
+function retainValues(budget, values) {
+  const retained = {};
+  budget.setRetainedValues(retained, values);
+  const pending = runResources.getStore()?.referenceReleases;
+  const release = () => {
+    budget.setRetainedValues(retained, void 0);
+    pending?.delete(release);
+  };
+  pending?.add(release);
+  return release;
+}
 async function evaluateMemberProperty(node, context) {
   const property = await evaluateNode(node, context);
   if (property.kind !== "normal") {
@@ -28892,30 +28949,35 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
 }
 async function evaluateCallArguments(args, context) {
   const values = [];
-  for (const arg of args) {
-    if (arg.type === "SpreadElement") {
-      const spreadValues = await evaluateSpreadElement(arg, context);
-      if (!spreadValues.ok) {
-        return spreadValues;
+  const release = retainValues(context.budget, () => values);
+  try {
+    for (const arg of args) {
+      if (arg.type === "SpreadElement") {
+        const spreadValues = await evaluateSpreadElement(arg, context);
+        if (!spreadValues.ok) {
+          return spreadValues;
+        }
+        appendArrayValues2(values, spreadValues.value);
+        context.budget.allocateArrayLength(values.length);
+        continue;
       }
-      appendArrayValues2(values, spreadValues.value);
+      const result = await evaluateNode(arg, context);
+      if (result.kind !== "normal") {
+        return {
+          ok: false,
+          result
+        };
+      }
+      values.push(result.value);
       context.budget.allocateArrayLength(values.length);
-      continue;
-    }
-    const result = await evaluateNode(arg, context);
-    if (result.kind !== "normal") {
-      return {
-        ok: false,
-        result
-      };
     }
-    values.push(result.value);
-    context.budget.allocateArrayLength(values.length);
+    return {
+      ok: true,
+      value: values
+    };
+  } finally {
+    release();
   }
-  return {
-    ok: true,
-    value: values
-  };
 }
 async function evaluateSpreadElement(node, context) {
   const value = await evaluateNode(node.argument, context);
@@ -28930,21 +28992,26 @@ async function evaluateSpreadElement(node, context) {
     throw new TypeError("Spread arguments must evaluate to an iterable.");
   }
   const spreadValues = [];
-  while (true) {
-    const next = await iterator.next();
-    if (typeof next !== "object" || next === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    if (next.done === true) {
-      break;
+  const release = retainValues(context.budget, () => [value.value, ...spreadValues]);
+  try {
+    while (true) {
+      const next = await iterator.next();
+      if (typeof next !== "object" || next === null) {
+        throw new TypeError("Iterator result must be an object.");
+      }
+      if (next.done === true) {
+        break;
+      }
+      spreadValues.push(next.value);
+      context.budget.allocateArrayLength(spreadValues.length);
     }
-    spreadValues.push(next.value);
-    context.budget.allocateArrayLength(spreadValues.length);
+    return {
+      ok: true,
+      value: spreadValues
+    };
+  } finally {
+    release();
   }
-  return {
-    ok: true,
-    value: spreadValues
-  };
 }
 async function evaluateObjectSpread(node, context) {
   const value = await evaluateNode(node.argument, context);
@@ -33406,4 +33473,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-DHD453E5.js.map
+//# sourceMappingURL=chunk-MKJBQPBH.js.map