@poe-platform/safe-js 0.1.489 → 0.1.491

package/dist/safe-js/chunks/{chunk-Y2KLKO2Y.js → chunk-CJDD5FTA.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-3IBFK7UI.js";
+} from "./chunk-NQKOR5UJ.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-Y2KLKO2Y.js.map
+//# sourceMappingURL=chunk-CJDD5FTA.js.map

package/dist/safe-js/chunks/{chunk-3IBFK7UI.js → chunk-NQKOR5UJ.js}

@@ -1009,6 +1009,7 @@ var Lexer = class {
   tokens = [];
   groupingStack = [];
   lastClosedControlParenthesis = false;
+  legacyStringEscape = false;
   tokenize() {
     while (!this.isAtEnd()) {
       this.skipTrivia();
@@ -1113,12 +1114,14 @@ var Lexer = class {
     this.pushToken(privateName ? "private-identifier" : KEYWORDS.has(value) ? "keyword" : "identifier", start, value);
   }
   readString(start, quote) {
+    this.legacyStringEscape = false;
     this.advance();
     while (!this.isAtEnd()) {
       const char = this.currentChar();
       if (char === quote) {
         this.advance();
         this.pushToken("string", start, this.source.slice(start.offset, this.index));
+        if (this.legacyStringEscape) this.tokens[this.tokens.length - 1].legacyEscape = true;
         return;
       }
       if (char === "\\") {
@@ -1390,6 +1393,23 @@ var Lexer = class {
         return this.source.slice(start.offset, this.index);
       }
       if (isDecimalDigit(prefix)) {
+        if (this.options.allowLegacyNumbers) {
+          let octal = true;
+          while (isDecimalDigit(this.currentChar())) {
+            if (!isOctalDigit(this.currentChar())) octal = false;
+            this.advance();
+          }
+          if (!octal) {
+            if (this.currentChar() === ".") {
+              this.advance();
+              this.consumeOptionalDecimalDigits();
+            }
+            this.consumeExponent();
+          }
+          this.rejectBigIntSuffix();
+          this.rejectInvalidNumericLiteralContinuation();
+          return this.source.slice(start.offset, this.index);
+        }
         this.advance();
         this.syntaxError("Legacy octal numeric literals are not supported in strict mode", start);
       }
@@ -1671,12 +1691,21 @@ var Lexer = class {
     if (escaped === "0") {
       this.advance();
       if (isDecimalDigit(this.currentChar())) {
-        this.syntaxError("Legacy octal escape sequences are not supported", escapeStart);
+        if (!this.options.allowLegacyEscapes)
+          this.syntaxError("Legacy octal escape sequences are not supported", escapeStart);
+        this.legacyStringEscape = true;
       }
       return;
     }
     if (isOctalDigit(escaped)) {
-      this.syntaxError("Legacy octal escape sequences are not supported", escapeStart);
+      if (!this.options.allowLegacyEscapes)
+        this.syntaxError("Legacy octal escape sequences are not supported", escapeStart);
+      this.legacyStringEscape = true;
+    }
+    if (escaped === "8" || escaped === "9") {
+      if (!this.options.allowLegacyEscapes)
+        this.syntaxError("Legacy decimal escape sequences are not supported", escapeStart);
+      this.legacyStringEscape = true;
     }
     this.advance();
   }
@@ -3339,6 +3368,7 @@ var Parser = class {
   parseBlockStatementBody(start, functionBody = false) {
     const body = [];
     let directivePrologue = functionBody;
+    let legacyDirective = false;
     while (this.consumePunctuator("}") === void 0) {
       if (this.currentToken().type === "eof") {
         throw new Error(
@@ -3350,8 +3380,11 @@ var Parser = class {
       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'"))
+        if (directivePrologue && statement.type === "ExpressionStatement" && statement.expression.type === "StringLiteral" && (statement.expression.raw === '"use strict"' || statement.expression.raw === "'use strict'")) {
+          if (legacyDirective) throw new Error("Legacy escape sequences are not supported in strict directives.");
           this.lexicalContext.grammar.strict = true;
+        }
+        if (directivePrologue && firstToken.legacyEscape) legacyDirective = true;
       }
       let semicolons = 0;
       while (statement.type !== "EmptyStatement" && this.consumePunctuator(";") !== void 0) {
@@ -5987,7 +6020,12 @@ var Parser = class {
     }
   }
   currentToken() {
-    return this.tokens[this.index] ?? this.tokens[this.tokens.length - 1];
+    const token = this.tokens[this.index] ?? this.tokens[this.tokens.length - 1];
+    if (this.lexicalContext.grammar?.strict !== false && token.legacyEscape)
+      throw new Error("Legacy escape sequences are not supported in strict mode.");
+    if (this.lexicalContext.grammar?.strict !== false && token.type === "numeric" && token.value[0] === "0" && isDecimalDigit3(token.value[1] ?? ""))
+      throw new Error("Legacy numeric literals are not supported in strict mode.");
+    return token;
   }
   peekToken(offset) {
     return this.tokens[this.index + offset] ?? this.tokens[this.tokens.length - 1];
@@ -6227,7 +6265,7 @@ function createNumericLiteral(token) {
   return {
     type: "NumericLiteral",
     raw: token.value,
-    value: Number(token.value.replaceAll("_", "")),
+    value: token.value.length > 1 && token.value[0] === "0" && [...token.value].every(isOctalDigit2) ? Number.parseInt(token.value, 8) : Number(token.value.replaceAll("_", "")),
     span: createTokenSpan(token)
   };
 }
@@ -6235,7 +6273,7 @@ function createStringLiteral(token) {
   return {
     type: "StringLiteral",
     raw: token.value,
-    value: decodeEscapedText(token.value.slice(1, -1)),
+    value: decodeEscapedText(token.value.slice(1, -1), token.legacyEscape),
     span: createTokenSpan(token)
   };
 }
@@ -6599,7 +6637,7 @@ function skipEscapedCharacter(raw, start) {
   }
   return Math.min(start + 2, raw.length);
 }
-function decodeEscapedText(value) {
+function decodeEscapedText(value, allowLegacy = false) {
   let decoded = "";
   let index = 0;
   while (index < value.length) {
@@ -6642,6 +6680,14 @@ function decodeEscapedText(value) {
         continue;
       }
     }
+    if (allowLegacy && isOctalDigit2(next)) {
+      const start = index + 1;
+      const limit = next <= "3" ? 3 : 2;
+      index = start + 1;
+      while (index < start + limit && isOctalDigit2(value[index] ?? "")) index++;
+      decoded += String.fromCharCode(Number.parseInt(value.slice(start, index), 8));
+      continue;
+    }
     decoded += decodeEscapeCharacter(next);
     index += 2;
   }
@@ -6702,7 +6748,12 @@ function decodeHexEscape(value, start) {
   };
 }
 function parseEmbeddedExpression(source, base, functionContext, lexicalContext, fullSource, compilation) {
-  const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
+  const tokens = tokenize(source, {
+    allowRegexLiterals: true,
+    allowLegacyNumbers: lexicalContext.grammar?.strict === false,
+    allowLegacyEscapes: lexicalContext.grammar?.strict === false,
+    compilation
+  }).map((token) => ({
     ...token,
     start: rebasePosition(token.start, base),
     end: rebasePosition(token.end, base)
@@ -57278,4 +57329,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-3IBFK7UI.js.map
+//# sourceMappingURL=chunk-NQKOR5UJ.js.map