@poe-platform/safe-js 0.1.477 → 0.1.479

package/dist/safe-js/chunks/{chunk-7VEKZ6RN.js → chunk-OBSLXRJL.js}

@@ -2937,6 +2937,7 @@ function allHexDigits(value) {
 // packages/safe-js/src/parse/parser.ts
 var MAX_CONDITIONAL_EXPRESSION_DEPTH = 256;
 var MAX_IF_STATEMENT_DEPTH = 2048;
+var STRICT_BINDING_NAMES = /* @__PURE__ */ new Set(["eval", "arguments", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
 var DisallowedSyntaxError = class extends Error {
   constructor(syntax, position) {
     super(`Disallowed syntax '${syntax}' at line ${position.line}, column ${position.column}.`);
@@ -3057,12 +3058,13 @@ var ordinaryFunctionContext = {
   await: true
 };
 var Parser = class {
-  constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
+  constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }, allowImportMeta = true) {
     this.tokens = tokens;
     this.source = source;
     this.compilation = compilation;
     this.functionContext = functionContext;
     this.lexicalContext = lexicalContext;
+    this.allowImportMeta = allowImportMeta;
     this.functionScopes.add(this.scopes[0]);
   }
   tokens;
@@ -3070,6 +3072,7 @@ var Parser = class {
   compilation;
   functionContext;
   lexicalContext;
+  allowImportMeta;
   index = 0;
   breakableDepth = 0;
   conditionalExpressionDepth = 0;
@@ -3088,6 +3091,19 @@ var Parser = class {
     });
     return node;
   }
+  parseDynamicParameters() {
+    this.parseArrowParameters();
+    this.expectEof();
+  }
+  parseDynamicBody() {
+    this.parseBlockStatement([]);
+    this.expectEof();
+  }
+  parseDynamicExpression() {
+    const node = this.parseFunctionExpression();
+    this.expectEof();
+    return node;
+  }
   parseTopLevel() {
     if (this.isExportToken(this.currentToken())) {
       throw new DisallowedSyntaxError("export", this.currentToken().start);
@@ -3201,7 +3217,10 @@ var Parser = class {
     if (this.isAsyncArrowWithParenthesizedParams()) {
       const asyncToken = this.currentToken();
       this.index += 1;
-      const params = this.parseArrowParameters();
+      const params = this.withLexicalContext({
+        ...this.lexicalContext,
+        ...this.lexicalContext.grammar === void 0 ? {} : { grammar: { ...this.lexicalContext.grammar, await: true } }
+      }, () => this.parseArrowParameters());
       return this.finishArrowFunctionExpression(asyncToken.start, true, params);
     }
     if (this.isAsyncArrowWithSingleParam()) {
@@ -3231,7 +3250,8 @@ var Parser = class {
     const body = this.withLexicalContext({
       ...this.lexicalContext,
       return: true,
-      await: isAsync || this.lexicalContext.strictAwait !== true
+      await: isAsync || this.lexicalContext.strictAwait !== true,
+      ...this.lexicalContext.grammar === void 0 ? {} : { grammar: { ...this.lexicalContext.grammar, await: isAsync, yield: false } }
     }, () => this.parseArrowFunctionBody(params, isAsync));
     return this.withFunctionSource({
       type: "ArrowFunctionExpression",
@@ -3278,11 +3298,12 @@ var Parser = class {
     }
     return this.withFunctionContext(async ? "async" : "normal", () => this.parseExpression().node);
   }
-  parseBlockStatement(params, catchParam) {
+  parseBlockStatement(params, catchParam, allowDuplicateParameters = false) {
     const start = this.expectPunctuator("{");
     return this.withScope(() => {
       for (const param of params ?? []) {
         for (const identifier of boundIdentifiers(param)) {
+          if (allowDuplicateParameters && this.scopes[this.scopes.length - 1]?.has(identifier.name)) continue;
           this.declareBinding(identifier, "parameter");
         }
       }
@@ -3292,7 +3313,15 @@ var Parser = class {
         }
       }
       let directiveTokenIndex = this.index;
-      const body = this.parseBlockStatementBody(start);
+      const body = this.parseBlockStatementBody(start, params !== void 0);
+      if (params !== void 0 && this.lexicalContext.grammar?.strict) {
+        const names = /* @__PURE__ */ new Set();
+        for (const param of params) for (const identifier of boundIdentifiers(param)) {
+          if (names.has(identifier.name) || STRICT_BINDING_NAMES.has(identifier.name))
+            throw new Error(`Invalid strict function parameter '${identifier.name}'.`);
+          names.add(identifier.name);
+        }
+      }
       if (params?.some((param) => param.type !== "Identifier")) {
         for (const statement of body.body) {
           const token = this.tokens[directiveTokenIndex];
@@ -3307,18 +3336,26 @@ var Parser = class {
       return body;
     }, params !== void 0);
   }
-  parseBlockStatementBody(start) {
+  parseBlockStatementBody(start, functionBody = false) {
     const body = [];
+    let directivePrologue = functionBody;
     while (this.consumePunctuator("}") === void 0) {
       if (this.currentToken().type === "eof") {
         throw new Error(
           `Unterminated block at line ${start.start.line}, column ${start.start.column}.`
         );
       }
+      const firstToken = this.currentToken();
       const statement = this.parseStatement();
       body.push(statement);
+      if (directivePrologue && this.lexicalContext.grammar !== void 0) {
+        directivePrologue = statement.type === "ExpressionStatement" && statement.expression.type === "StringLiteral" && firstToken.type === "string" && statement.span.start.offset === firstToken.start.offset && statement.span.end.offset === firstToken.end.offset;
+        if (directivePrologue && statement.type === "ExpressionStatement" && statement.expression.type === "StringLiteral" && (statement.expression.raw === '"use strict"' || statement.expression.raw === "'use strict'"))
+          this.lexicalContext.grammar.strict = true;
+      }
+      let semicolons = 0;
       while (statement.type !== "EmptyStatement" && this.consumePunctuator(";") !== void 0) {
-        continue;
+        if (++semicolons > 1) directivePrologue = false;
       }
     }
     return {
@@ -3328,6 +3365,15 @@ var Parser = class {
     };
   }
   parseStatement(allowResourceDeclaration = true) {
+    const statement = this.parseStatementBody(allowResourceDeclaration);
+    if (this.lexicalContext.grammar !== void 0 && ["ExpressionStatement", "ReturnStatement", "ThrowStatement", "VariableDeclaration", "BreakStatement", "ContinueStatement"].includes(statement.type)) {
+      const next = this.currentToken();
+      if (next.type !== "eof" && next.value !== ";" && next.value !== "}" && next.start.line === statement.span.end.line)
+        throw unexpectedTokenError(next);
+    }
+    return statement;
+  }
+  parseStatementBody(allowResourceDeclaration) {
     const emptyStatement = this.parseEmptyStatement();
     if (emptyStatement !== void 0) {
       return emptyStatement;
@@ -3945,6 +3991,12 @@ var Parser = class {
     });
   }
   parseClass(declaration) {
+    return this.withLexicalContext({
+      ...this.lexicalContext,
+      ...this.lexicalContext.grammar === void 0 ? {} : { grammar: { ...this.lexicalContext.grammar, strict: true } }
+    }, () => this.parseClassBody(declaration));
+  }
+  parseClassBody(declaration) {
     const start = this.expectKeyword("class");
     const id = isIdentifierLikeToken(this.currentToken()) && this.currentToken().value !== "extends" ? this.parseBindingIdentifier() : void 0;
     if (declaration && id === void 0) throw unexpectedTokenError(this.currentToken());
@@ -3980,18 +4032,30 @@ var Parser = class {
     });
   }
   parseFunctionParts(generator, lexicalContext, accessor, async = false) {
+    const inheritedGrammar = this.lexicalContext.grammar;
+    if (inheritedGrammar !== void 0) lexicalContext = {
+      ...lexicalContext,
+      grammar: { await: async, yield: generator, strict: inheritedGrammar.strict }
+    };
     return this.withLexicalContext(lexicalContext, () => {
+      let allowDuplicateParameters = false;
       const params = this.withScope(() => {
         const parsed = this.parseArrowParameters();
+        allowDuplicateParameters = lexicalContext.grammar !== void 0 && !lexicalContext.grammar.strict && !lexicalContext.superProperty && parsed.every((param) => param.type === "Identifier");
+        const names = /* @__PURE__ */ new Set();
         for (const param of parsed)
-          for (const identifier of boundIdentifiers(param)) this.declareBinding(identifier);
+          for (const identifier of boundIdentifiers(param)) {
+            if (allowDuplicateParameters && names.has(identifier.name)) continue;
+            this.declareBinding(identifier);
+            names.add(identifier.name);
+          }
         return parsed;
       });
       if (accessor === "get" && params.length !== 0)
         throw new Error("A getter cannot have parameters.");
       if (accessor === "set" && (params.length !== 1 || params[0]?.type === "RestElement"))
         throw new Error("A setter must have exactly one non-rest parameter.");
-      const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : async ? "async" : "normal", () => this.parseBlockStatement(params));
+      const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : async ? "async" : "normal", () => this.parseBlockStatement(params, void 0, allowDuplicateParameters));
       return { params, body };
     });
   }
@@ -4158,7 +4222,7 @@ var Parser = class {
   }
   parseBindingTarget() {
     const token = this.currentToken();
-    if (isIdentifierLikeToken(token)) {
+    if (isIdentifierLikeToken(token) || this.isContextualIdentifier(token)) {
       return this.parseBindingIdentifier();
     }
     if (token.type === "punctuator" && token.value === "[") {
@@ -4171,12 +4235,18 @@ var Parser = class {
   }
   parseBindingIdentifier() {
     const token = this.currentToken();
-    if (!isIdentifierLikeToken(token)) {
+    if (this.lexicalContext.grammar?.strict && STRICT_BINDING_NAMES.has(token.value))
+      throw unexpectedTokenError(token);
+    if (!isIdentifierLikeToken(token) && !this.isContextualIdentifier(token)) {
       throw unexpectedTokenError(token);
     }
     this.index += 1;
     return createIdentifier2(token);
   }
+  isContextualIdentifier(token) {
+    const grammar = this.lexicalContext.grammar;
+    return grammar !== void 0 && token.type === "keyword" && (token.value === "await" && !grammar.await || token.value === "yield" && !grammar.yield && !grammar.strict);
+  }
   parseArrayPattern() {
     const start = this.expectPunctuator("[");
     const elements = [];
@@ -4700,7 +4770,7 @@ var Parser = class {
         parenthesized: false
       };
     }
-    if (token.type === "keyword" && token.value === "yield") {
+    if (token.type === "keyword" && token.value === "yield" && !this.isContextualIdentifier(token)) {
       if (this.functionContext !== "generator" && this.functionContext !== "async-generator") {
         throw new Error(
           `yield is only valid inside a generator body at line ${token.start.line}, column ${token.start.column}.`
@@ -4727,7 +4797,7 @@ var Parser = class {
         parenthesized: false
       };
     }
-    if (token.type === "keyword" && token.value === "await") {
+    if (token.type === "keyword" && token.value === "await" && !this.isContextualIdentifier(token)) {
       if (!this.lexicalContext.await) throw new DisallowedSyntaxError("await in a class element", token.start);
       if (this.functionContext === "generator") {
         throw new Error(
@@ -4933,7 +5003,7 @@ var Parser = class {
     if (isNewToken(token)) {
       return this.parseNewExpression();
     }
-    if (isIdentifierLikeToken(token)) {
+    if (isIdentifierLikeToken(token) || this.isContextualIdentifier(token)) {
       assertAllowedIdentifierReference(token);
       this.index += 1;
       return {
@@ -5788,6 +5858,8 @@ var Parser = class {
   }
   withLexicalContext(context, callback) {
     const previous = this.lexicalContext;
+    if (context.grammar === void 0 && previous.grammar !== void 0)
+      context = { ...context, grammar: { ...previous.grammar } };
     this.lexicalContext = context;
     try {
       return callback();
@@ -5927,6 +5999,7 @@ var Parser = class {
   }
   parseImportMeta() {
     const importToken = this.currentToken();
+    if (!this.allowImportMeta) throw new Error("import.meta is only valid in module source.");
     if (!this.isImportMetaStart()) {
       throw unexpectedTokenError(importToken);
     }
@@ -57191,4 +57264,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-7VEKZ6RN.js.map
+//# sourceMappingURL=chunk-OBSLXRJL.js.map