poe-code 14.0.59 → 14.0.60

package/dist/index.js

@@ -122161,9 +122161,6 @@ function parseTokens(tokens, compilation) {
 function parseModuleTokens(tokens, compilation) {
   return new Parser(tokens, compilation).parseModule();
 }
-function parseExpressionTokens(tokens, compilation) {
-  return new Parser(tokens, compilation).parseExpressionOnly();
-}
 function createIdentifier2(token) {
   return {
     type: "Identifier",
@@ -122451,7 +122448,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 = [];
@@ -122471,6 +122468,7 @@ function createTemplateLiteral(token, options = { allowMalformedEscapes: false }
         parseEmbeddedExpression(
           raw.slice(expressionStart, expressionEnd),
           positionWithinRaw(token.start, raw, expressionStart),
+          options.functionContext,
           compilation
         )
       );
@@ -122833,13 +122831,13 @@ function decodeHexEscape(value, start) {
     end: index + 2
   };
 }
-function parseEmbeddedExpression(source, base, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, compilation) {
   const tokens = tokenize3(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) {
@@ -123024,19 +123022,20 @@ var init_parser3 = __esm({
       "while"
     ]);
     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();
@@ -123222,9 +123221,9 @@ var init_parser3 = __esm({
       }
       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("{");
@@ -123828,7 +123827,7 @@ var init_parser3 = __esm({
           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,
@@ -123863,32 +123862,34 @@ var init_parser3 = __esm({
         };
       }
       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) {
@@ -124442,7 +124443,7 @@ var init_parser3 = __esm({
           };
         }
         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}.`
             );
@@ -124469,11 +124470,16 @@ var init_parser3 = __esm({
           };
         }
         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 {
@@ -124598,7 +124604,7 @@ var init_parser3 = __esm({
           if (this.currentToken().type === "template") {
             const quasi = createTemplateLiteral(
               this.currentToken(),
-              { allowMalformedEscapes: true },
+              { allowMalformedEscapes: true, functionContext: this.functionContext },
               this.compilation
             );
             this.index += 1;
@@ -124685,7 +124691,11 @@ var init_parser3 = __esm({
         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
           };
         }
@@ -124801,7 +124811,7 @@ var init_parser3 = __esm({
           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,
@@ -125045,7 +125055,7 @@ var init_parser3 = __esm({
           }
           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,
@@ -125450,19 +125460,19 @@ var init_parser3 = __esm({
       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) {