@poe-platform/safe-js 0.1.126 → 0.1.127

package/dist/safe-js/chunks/{chunk-AHZ74NTE.js → chunk-23ZKK6SC.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-D4YY44EF.js";
+} from "./chunk-MKJBQPBH.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-AHZ74NTE.js.map
+//# sourceMappingURL=chunk-23ZKK6SC.js.map

package/dist/safe-js/chunks/{chunk-D4YY44EF.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) {
@@ -33463,4 +33473,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-D4YY44EF.js.map
+//# sourceMappingURL=chunk-MKJBQPBH.js.map