poe-code 13.0.3 → 13.0.4

package/packages/safe-js/dist/parse/parser.js

@@ -5,6 +5,8 @@ import { formatParseError } from "./format-error.js";
 import { createExportDefaultDeclaration, createExportNamedDeclaration } from "./parse-export.js";
 import { createImportMeta, isImportMetaTokenSequence } from "./parse-import-meta.js";
 import { parseRegex } from "../interp/regex/parse.js";
+import { CompileScope, RegexCompileGuard } from "../interp/regex/compile-guard.js";
+import { SandboxError } from "../interp/budget.js";
 const MAX_CONDITIONAL_EXPRESSION_DEPTH = 256;
 const MAX_IF_STATEMENT_DEPTH = 2_048;
 export class DisallowedSyntaxError extends Error {
@@ -37,9 +39,10 @@ const TOP_LEVEL_STATEMENT_KEYWORDS = new Set([
     "try",
     "while"
 ]);
-export function parse(source, filename = "<input>") {
+export function parse(source, filename = "<input>", owner) {
+    const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseTokens(tokenize(source, { allowRegexLiterals: true })));
+        const result = assignIds(parseTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
         const regexLiteral = findRegexLiteral(result);
         if (regexLiteral !== undefined) {
             throw new Error(`Regular expression literals are not supported at line ${regexLiteral.span.start.line}, column ${regexLiteral.span.start.column}.`);
@@ -48,7 +51,7 @@ export function parse(source, filename = "<input>") {
         return result;
     }
     catch (error) {
-        if (error instanceof DisallowedSyntaxError) {
+        if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
             throw error;
         }
         if (error instanceof Error) {
@@ -56,13 +59,17 @@ export function parse(source, filename = "<input>") {
         }
         throw error;
     }
+    finally {
+        compilation.dispose();
+    }
 }
-export function parseModule(source, filename = "<input>") {
+export function parseModule(source, filename = "<input>", owner) {
+    const compilation = new CompileScope(owner);
     try {
-        return assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true })));
+        return assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
     }
     catch (error) {
-        if (error instanceof DisallowedSyntaxError) {
+        if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
             throw error;
         }
         if (error instanceof Error) {
@@ -70,15 +77,19 @@ export function parseModule(source, filename = "<input>") {
         }
         throw error;
     }
+    finally {
+        compilation.dispose();
+    }
 }
-export function parseExecutableModule(source, filename = "<input>") {
+export function parseExecutableModule(source, filename = "<input>", owner) {
+    const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true })));
+        const result = assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
         throwIfImportMetaAssignment(result);
         return result;
     }
     catch (error) {
-        if (error instanceof DisallowedSyntaxError) {
+        if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
             throw error;
         }
         if (error instanceof Error) {
@@ -86,18 +97,22 @@ export function parseExecutableModule(source, filename = "<input>") {
         }
         throw error;
     }
+    finally {
+        compilation.dispose();
+    }
 }
-function parseTokens(tokens) {
-    return new Parser(tokens).parseTopLevel();
+function parseTokens(tokens, compilation) {
+    return new Parser(tokens, compilation).parseTopLevel();
 }
-function parseModuleTokens(tokens) {
-    return new Parser(tokens).parseModule();
+function parseModuleTokens(tokens, compilation) {
+    return new Parser(tokens, compilation).parseModule();
 }
-function parseExpressionTokens(tokens) {
-    return new Parser(tokens).parseExpressionOnly();
+function parseExpressionTokens(tokens, compilation) {
+    return new Parser(tokens, compilation).parseExpressionOnly();
 }
 class Parser {
     tokens;
+    compilation;
     index = 0;
     breakableDepth = 0;
     conditionalExpressionDepth = 0;
@@ -107,8 +122,9 @@ class Parser {
     scopes = [new Map()];
     functionScopes = new WeakSet();
     varNames = new WeakMap();
-    constructor(tokens) {
+    constructor(tokens, compilation) {
         this.tokens = tokens;
+        this.compilation = compilation;
         this.functionScopes.add(this.scopes[0]);
     }
     parseTopLevel() {
@@ -1646,7 +1662,7 @@ class Parser {
                 continue;
             }
             if (this.currentToken().type === "template") {
-                const quasi = createTemplateLiteral(this.currentToken(), { allowMalformedEscapes: true });
+                const quasi = createTemplateLiteral(this.currentToken(), { allowMalformedEscapes: true }, this.compilation);
                 this.index += 1;
                 expression = {
                     node: {
@@ -1727,14 +1743,14 @@ class Parser {
         if (token.type === "regex") {
             this.index += 1;
             return {
-                node: createRegexLiteral(token),
+                node: createRegexLiteral(token, this.compilation),
                 parenthesized: false
             };
         }
         if (token.type === "template") {
             this.index += 1;
             return {
-                node: createTemplateLiteral(token, { allowMalformedEscapes: false }),
+                node: createTemplateLiteral(token, { allowMalformedEscapes: false }, this.compilation),
                 parenthesized: false
             };
         }
@@ -2918,10 +2934,16 @@ function createStringLiteral(token) {
         span: createTokenSpan(token)
     };
 }
-function createRegexLiteral(token) {
+function createRegexLiteral(token, parent) {
+    const compilation = new CompileScope(parent?.owner);
+    const guard = new RegexCompileGuard(compilation);
     const lastSlash = token.value.lastIndexOf("/");
     try {
-        parseRegex(token.value.slice(1, lastSlash), token.value.slice(lastSlash + 1));
+        guard.checkLength(Math.max(0, lastSlash - 1));
+        guard.checkLength(token.value.length - lastSlash - 1, true);
+        guard.allocate(Math.max(0, token.value.length - 2));
+        guard.work(Math.max(0, token.value.length - 2));
+        parseRegex(token.value.slice(1, lastSlash), token.value.slice(lastSlash + 1), compilation);
     }
     catch (error) {
         if (error instanceof SyntaxError) {
@@ -2933,6 +2955,10 @@ function createRegexLiteral(token) {
         }
         throw error;
     }
+    finally {
+        guard.close();
+        compilation.dispose();
+    }
     return {
         type: "RegexLiteral",
         raw: token.value,
@@ -2983,7 +3009,7 @@ function createLiteralFromToken(token) {
     }
     return createKeywordLiteral(token);
 }
-function createTemplateLiteral(token, options = { allowMalformedEscapes: false }) {
+function createTemplateLiteral(token, options = { allowMalformedEscapes: false }, compilation) {
     const raw = token.value;
     const expressions = [];
     const quasis = [];
@@ -2999,7 +3025,7 @@ function createTemplateLiteral(token, options = { allowMalformedEscapes: false }
             quasis.push(createTemplateElement(token.start, raw, quasiStart, cursor, false, options));
             const expressionStart = cursor + 2;
             const expressionEnd = findTemplateExpressionEnd(raw, expressionStart);
-            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart)));
+            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), compilation));
             quasiStart = expressionEnd + 1;
             cursor = expressionEnd + 1;
             continue;
@@ -3360,15 +3386,15 @@ function decodeHexEscape(value, start) {
         end: index + 2
     };
 }
-function parseEmbeddedExpression(source, base) {
-    const tokens = tokenize(source, { allowRegexLiterals: true }).map((token) => ({
+function parseEmbeddedExpression(source, base, compilation) {
+    const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
         ...token,
         start: rebasePosition(token.start, base),
         end: rebasePosition(token.end, base)
     }));
-    return parseExpressionTokens(tokens);
+    return parseExpressionTokens(tokens, compilation);
 }
-function findRegexLiteral(node) {
+export function findRegexLiteral(node) {
     if (node === null || node === undefined) {
         return undefined;
     }

package/packages/safe-js/dist/parse/tokenizer.d.ts

@@ -1,3 +1,4 @@
+import { type CompileScope } from "../interp/regex/compile-guard.js";
 export type Position = {
     line: number;
     column: number;
@@ -19,6 +20,7 @@ export type Comment = {
 export type TokenizeOptions = {
     allowRegexLiterals?: boolean;
     comments?: Comment[];
+    compilation?: CompileScope;
 };
 export declare function tokenize(source: string, options?: TokenizeOptions): Token[];
 export declare function collectComments(source: string): Comment[];

package/packages/safe-js/dist/parse/tokenizer.js

@@ -1,3 +1,4 @@
+import { RegexCompileGuard } from "../interp/regex/compile-guard.js";
 const KEYWORDS = new Set([
     "const",
     "let",
@@ -646,37 +647,58 @@ class Lexer {
         return undefined;
     }
     scanRegexLiteral(start) {
-        this.advance();
-        let inCharacterClass = false;
-        while (!this.isAtEnd()) {
-            const char = this.currentChar();
-            if (char === "\\") {
-                this.advance();
-                if (!this.isAtEnd()) {
-                    this.advance();
+        const guard = new RegexCompileGuard(this.options.compilation);
+        try {
+            guard.work(1);
+            this.advance();
+            const patternStart = this.index;
+            let inCharacterClass = false;
+            const advancePattern = () => {
+                const width = this.currentChar() === "\r" && this.peekChar(1) === "\n" ? 2 : 1;
+                guard.checkLength(this.index - patternStart + width);
+                guard.work(width);
+                this.advance();
+            };
+            while (!this.isAtEnd()) {
+                const char = this.currentChar();
+                if (char === "\\") {
+                    advancePattern();
+                    if (!this.isAtEnd())
+                        advancePattern();
+                    continue;
                 }
-                continue;
-            }
-            if (char === "[" && !inCharacterClass) {
-                inCharacterClass = true;
-                this.advance();
-                continue;
-            }
-            if (char === "]" && inCharacterClass) {
-                inCharacterClass = false;
-                this.advance();
-                continue;
-            }
-            if (char === "/" && !inCharacterClass) {
-                this.advance();
-                while (!this.isAtEnd() && isAsciiLetter(this.currentChar())) {
+                if (char === "[" && !inCharacterClass) {
+                    inCharacterClass = true;
+                    advancePattern();
+                    continue;
+                }
+                if (char === "]" && inCharacterClass) {
+                    inCharacterClass = false;
+                    advancePattern();
+                    continue;
+                }
+                if (char === "/" && !inCharacterClass) {
+                    guard.work(1);
                     this.advance();
+                    const flagsStart = this.index;
+                    while (!this.isAtEnd() && isAsciiLetter(this.currentChar())) {
+                        guard.checkLength(this.index - flagsStart + 1, true);
+                        guard.work(1);
+                        this.advance();
+                    }
+                    break;
                 }
-                break;
+                advancePattern();
             }
-            this.advance();
+            guard.allocate(this.index - start.offset);
+            guard.work(this.index - start.offset);
+            const raw = this.source.slice(start.offset, this.index);
+            guard.retainScratch();
+            return raw;
+        }
+        finally {
+            guard.close();
         }
-        return this.source.slice(start.offset, this.index);
     }
     pushToken(type, start, value) {
         const previousToken = this.lastSignificantToken();

package/packages/safe-js/dist/parse.d.ts

@@ -1,2 +1,4 @@
-export { DisallowedSyntaxError, parse } from "./parse/parser.js";
+import { type ParseResult as ParsedNode } from "./parse/parser.js";
+export { DisallowedSyntaxError } from "./parse/parser.js";
+export declare const parse: (source: string, filename?: string) => ParsedNode;
 export type { ArrayPattern, ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, ConditionalExpression, ContinueStatement, DoWhileStatement, EmptyStatement, Expression, ExpressionStatement, ExportDefaultDeclaration, ExportNamedDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, LogicalExpression, MemberExpression, MetaProperty, NewExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ParseResult, PatternTarget, Property, RegexLiteral, RestElement, ReturnStatement, SequenceExpression, SourceSpan, SpreadElement, Statement, StringLiteral, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UndefinedLiteral, UpdateExpression, UpdateTarget, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement } from "./parse/parser.js";

package/packages/safe-js/dist/parse.js

@@ -1 +1,3 @@
-export { DisallowedSyntaxError, parse } from "./parse/parser.js";
+import { parse as parseInternal } from "./parse/parser.js";
+export { DisallowedSyntaxError } from "./parse/parser.js";
+export const parse = parseInternal;

package/packages/safe-js/dist/restore.d.ts

@@ -1,3 +1,4 @@
+import type { CompileOwner } from "./interp/budget.js";
 import { type SnapshotMigration } from "./snapshot/migration.js";
 export type SafeJSSnapshot = {
     version?: number;
@@ -22,4 +23,4 @@ export declare class SnapshotMismatchError extends Error {
     readonly expectedHash: string;
     constructor(expectedHash: string, actualHash: string);
 }
-export declare function restore<TSnapshot extends SafeJSSnapshot>(snapshot: TSnapshot, options: RestoreOptions): TSnapshot;
+export declare function restore<TSnapshot extends SafeJSSnapshot>(snapshot: TSnapshot, options: RestoreOptions, owner?: CompileOwner): TSnapshot;

package/packages/safe-js/dist/restore.js

@@ -15,10 +15,10 @@ export class SnapshotMismatchError extends Error {
         replaceErrorStack(this);
     }
 }
-export function restore(snapshot, options) {
+export function restore(snapshot, options, owner) {
     assertSnapshotInactive(snapshot);
     validateDumpEnvelope(snapshot);
-    validateSnapshotMigration(snapshot.migration, snapshot.sourceHash);
+    validateSnapshotMigration(snapshot.migration, snapshot.sourceHash, owner);
     if (snapshot.executionSemantics !== EXECUTION_SEMANTICS &&
         snapshot.executionSemantics !== "jobs-v6" &&
         (snapshot.executionSemantics !== undefined ||
@@ -27,7 +27,7 @@ export function restore(snapshot, options) {
             snapshot.initialInputs !== undefined)) {
         throw new SnapshotValidationError("unsupportedVersion", "$.executionSemantics", "incompatible execution semantics; resume with the SafeJS version that created this snapshot. Migration requires explicit reconciliation, not changing its version marker.");
     }
-    const currentSourceHash = hashSource(options.source);
+    const currentSourceHash = hashSource(options.source, owner);
     if (snapshot.sourceHash !== currentSourceHash) {
         throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
     }