poe-code 14.0.63 → 14.0.65

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

@@ -247,6 +247,46 @@ export type FunctionExpression = BaseNode & {
     method?: true;
     params: ArrowFunctionExpression["params"];
 };
+export type ClassElement = (BaseNode & {
+    type: "MethodDefinition";
+    computed: boolean;
+    key: Expression;
+    kind: "constructor" | "method";
+    static: boolean;
+    value: FunctionExpression;
+}) | (BaseNode & {
+    type: "PropertyDefinition";
+    computed: boolean;
+    key: Expression;
+    static: boolean;
+    value?: Expression;
+}) | (BaseNode & {
+    type: "StaticBlock";
+    body: BlockStatement;
+});
+export type ClassBody = BaseNode & {
+    type: "ClassBody";
+    body: ClassElement[];
+};
+export type ClassDeclaration = BaseNode & {
+    type: "ClassDeclaration";
+    id: Identifier;
+    superClass?: Expression;
+    body: ClassBody;
+};
+export type ClassExpression = BaseNode & {
+    type: "ClassExpression";
+    id?: Identifier;
+    superClass?: Expression;
+    body: ClassBody;
+};
+export type ClassNode = ClassDeclaration | ClassExpression;
+export type SuperExpression = BaseNode & {
+    type: "Super";
+};
+export type NewTargetExpression = BaseNode & {
+    type: "NewTargetExpression";
+};
 export type IfStatement = BaseNode & {
     type: "IfStatement";
     test: Expression;
@@ -339,7 +379,7 @@ export type Module = BaseNode & {
     type: "Module";
     body: Statement[];
 };
-export type Statement = BlockStatement | BreakStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | TryStatement | ContinueStatement | EmptyStatement | ExpressionStatement | FunctionDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | ReturnStatement | SwitchStatement | ThrowStatement | VariableDeclaration | WhileStatement;
+export type Statement = BlockStatement | ClassDeclaration | BreakStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | TryStatement | ContinueStatement | EmptyStatement | ExpressionStatement | FunctionDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | ReturnStatement | SwitchStatement | ThrowStatement | VariableDeclaration | WhileStatement;
 export type ArrowFunctionExpression = BaseNode & {
     type: "ArrowFunctionExpression";
     async: boolean;
@@ -348,7 +388,7 @@ export type ArrowFunctionExpression = BaseNode & {
     params: Array<AssignmentPattern | ArrayPattern | Identifier | ObjectPattern | RestElement>;
 };
 export type FunctionNode = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
-export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayExpression | AwaitExpression | BinaryExpression | BooleanLiteral | CallExpression | ConditionalExpression | FunctionExpression | Identifier | LogicalExpression | MemberExpression | MetaProperty | NewExpression | NullLiteral | NumericLiteral | ObjectExpression | RegexLiteral | SequenceExpression | StringLiteral | TaggedTemplateExpression | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression | UndefinedLiteral | YieldExpression;
+export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayExpression | AwaitExpression | BinaryExpression | BooleanLiteral | CallExpression | ConditionalExpression | ClassExpression | FunctionExpression | Identifier | LogicalExpression | MemberExpression | MetaProperty | NewExpression | NewTargetExpression | NullLiteral | NumericLiteral | ObjectExpression | RegexLiteral | SequenceExpression | StringLiteral | SuperExpression | TaggedTemplateExpression | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression | UndefinedLiteral | YieldExpression;
 export type ParseResult = Expression | Statement;
 export declare function parse(source: string, filename?: string, owner?: CompileOwner): ParseResult;
 export declare function parseModule(source: string, filename?: string, owner?: CompileOwner): Module;

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

@@ -27,6 +27,7 @@ const BITWISE_AND_OPERATORS = new Set(["&"]);
 const MAX_UNICODE_CODE_POINT = 0x10ffff;
 const TOP_LEVEL_STATEMENT_KEYWORDS = new Set([
     "break",
+    "class",
     "const",
     "continue",
     "do",
@@ -102,11 +103,16 @@ export function parseExecutableModule(source, filename = "<input>", owner) {
         compilation.dispose();
     }
 }
+const ordinaryFunctionContext = {
+    newTarget: true, superProperty: false, superCall: false,
+    arguments: true, return: true, await: true
+};
 class Parser {
     tokens;
     source;
     compilation;
     functionContext;
+    lexicalContext;
     index = 0;
     breakableDepth = 0;
     conditionalExpressionDepth = 0;
@@ -115,11 +121,12 @@ class Parser {
     scopes = [new Map()];
     functionScopes = new WeakSet();
     varNames = new WeakMap();
-    constructor(tokens, source, compilation, functionContext = "normal") {
+    constructor(tokens, source, compilation, functionContext = "normal", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
         this.tokens = tokens;
         this.source = source;
         this.compilation = compilation;
         this.functionContext = functionContext;
+        this.lexicalContext = lexicalContext;
         this.functionScopes.add(this.scopes[0]);
     }
     withFunctionSource(node) {
@@ -274,7 +281,9 @@ class Parser {
             }
         });
         this.expectPunctuator("=>");
-        const body = this.parseArrowFunctionBody(params);
+        const body = this.withLexicalContext({
+            ...this.lexicalContext, return: true, await: isAsync || this.lexicalContext.strictAwait !== true
+        }, () => this.parseArrowFunctionBody(params));
         return this.withFunctionSource({
             type: "ArrowFunctionExpression",
             async: isAsync,
@@ -366,6 +375,10 @@ class Parser {
             return this.parseLabeledStatement([token.value], token);
         }
         this.assertAllowedStatementStart(token);
+        if (token.value === "class")
+            return this.parseClass(true);
+        if (token.value === "return" && !this.lexicalContext.return)
+            throw new DisallowedSyntaxError("return in a static block", token.start);
         if (token.type === "punctuator" && token.value === "{") {
             return this.parseBlockStatement();
         }
@@ -914,17 +927,8 @@ class Parser {
         }
         const id = this.parseBindingIdentifier();
         this.declareBinding(id, "function");
-        const params = this.withScope(() => {
-            const parsedParams = this.parseArrowParameters();
-            for (const param of parsedParams) {
-                for (const identifier of boundIdentifiers(param)) {
-                    this.declareBinding(identifier);
-                }
-            }
-            return parsedParams;
-        });
         const generator = generatorToken !== undefined;
-        const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
+        const { params, body } = this.parseFunctionParts(generator, ordinaryFunctionContext);
         return this.withFunctionSource({
             type: "FunctionDeclaration",
             async: asyncToken !== undefined,
@@ -935,6 +939,132 @@ class Parser {
             span: createSpan(asyncToken?.start ?? functionToken.start, body.span.end)
         });
     }
+    parseClass(declaration) {
+        const start = this.expectKeyword("class");
+        const id = isIdentifierLikeToken(this.currentToken()) && this.currentToken().value !== "extends"
+            ? this.parseBindingIdentifier()
+            : undefined;
+        if (declaration && id === undefined)
+            throw unexpectedTokenError(this.currentToken());
+        if (declaration)
+            this.declareBinding(id);
+        return this.withScope(() => {
+            if (id !== undefined)
+                this.declareBinding(id);
+            const superClass = this.consumeKeyword("extends") === undefined
+                ? undefined
+                : this.parseLeftHandSideExpression().node;
+            const open = this.expectPunctuator("{");
+            const elements = [];
+            let constructorSeen = false;
+            while (this.consumePunctuator("}") === undefined) {
+                if (this.currentToken().type === "eof")
+                    throw unexpectedTokenError(this.currentToken());
+                if (this.consumePunctuator(";") !== undefined)
+                    continue;
+                const element = this.parseClassElement(superClass !== undefined);
+                if (element.type === "MethodDefinition" && element.kind === "constructor") {
+                    if (constructorSeen)
+                        throw new Error("A class may only have one constructor.");
+                    constructorSeen = true;
+                }
+                elements.push(element);
+            }
+            const body = {
+                type: "ClassBody", body: elements,
+                span: createSpan(open.start, this.previousToken().end)
+            };
+            return this.withFunctionSource({
+                type: declaration ? "ClassDeclaration" : "ClassExpression",
+                id, superClass, body, span: createSpan(start.start, body.span.end)
+            });
+        });
+    }
+    parseFunctionParts(generator, lexicalContext) {
+        return this.withLexicalContext(lexicalContext, () => {
+            const params = this.withScope(() => {
+                const parsed = this.parseArrowParameters();
+                for (const param of parsed)
+                    for (const identifier of boundIdentifiers(param))
+                        this.declareBinding(identifier);
+                return parsed;
+            });
+            const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
+            return { params, body };
+        });
+    }
+    parseClassElement(derived) {
+        const start = this.currentToken();
+        let isStatic = false;
+        if (start.value === "static" && !["(", "=", ";", "}"].includes(this.peekToken(1).value)) {
+            this.index++;
+            isStatic = true;
+            if (this.currentToken().value === "{") {
+                const body = this.withLexicalContext({
+                    newTarget: true, superProperty: true, superCall: false,
+                    arguments: false, return: false, await: false, strictAwait: true
+                }, () => this.withFunctionContext("normal", () => this.parseBlockStatement([])));
+                return { type: "StaticBlock", body, span: createSpan(start.start, body.span.end) };
+            }
+        }
+        const methodStart = this.currentToken();
+        let async = false;
+        if (methodStart.value === "async" && !hasLineBreakBetween(methodStart, this.peekToken(1)) &&
+            (this.peekToken(1).value === "*" || this.isObjectMethodStart())) {
+            this.index++;
+            async = true;
+        }
+        const generator = this.consumePunctuator("*") !== undefined;
+        if (async && generator)
+            throw new DisallowedSyntaxError("async generator", methodStart.start);
+        if ((this.currentToken().value === "get" || this.currentToken().value === "set") && this.isObjectMethodStart())
+            throw new DisallowedSyntaxError("class accessor", this.currentToken().start);
+        const computed = this.consumePunctuator("[") !== undefined;
+        const key = computed
+            ? this.parseExpression({ allowSequence: true }).node
+            : this.currentToken().type === "string"
+                ? createStringLiteral(this.tokens[this.index++])
+                : this.currentToken().type === "numeric"
+                    ? createNumericLiteral(this.tokens[this.index++])
+                    : this.parseIdentifierName();
+        if (computed)
+            this.expectPunctuator("]");
+        const name = computed ? undefined : key.type === "Identifier" ? key.name
+            : key.type === "StringLiteral" || key.type === "NumericLiteral" ? String(key.value) : undefined;
+        if (isStatic && name === "prototype")
+            throw new Error("A static class element cannot be named prototype.");
+        if (this.currentToken().value === "(") {
+            const constructor = !isStatic && name === "constructor";
+            if (constructor && (async || generator))
+                throw new Error("A class constructor cannot be async or a generator.");
+            const { params, body } = this.parseFunctionParts(generator, {
+                newTarget: true, superProperty: true, superCall: constructor && derived,
+                arguments: true, return: true, await: async, strictAwait: true
+            });
+            const value = this.withFunctionSource({
+                type: "FunctionExpression", async, generator, method: true, params, body,
+                span: createSpan(methodStart.start, body.span.end)
+            });
+            return {
+                type: "MethodDefinition", key, computed, static: isStatic,
+                kind: constructor ? "constructor" : "method", value,
+                span: createSpan(start.start, value.span.end)
+            };
+        }
+        if (async || generator)
+            throw unexpectedTokenError(this.currentToken());
+        if (name === "constructor")
+            throw new Error("A class field cannot be named constructor.");
+        const value = this.consumePunctuator("=") === undefined ? undefined : this.withLexicalContext({
+            newTarget: true, superProperty: true, superCall: false,
+            arguments: false, return: false, await: false, strictAwait: true
+        }, () => this.withFunctionContext("normal", () => this.parseExpression().node));
+        const end = value?.span.end ?? key.span.end;
+        if (this.consumePunctuator(";") === undefined && this.currentToken().value !== "}" &&
+            !hasLineBreakBetween(this.previousToken(), this.currentToken()))
+            throw unexpectedTokenError(this.currentToken());
+        return { type: "PropertyDefinition", key, computed, static: isStatic, value, span: createSpan(start.start, end) };
+    }
     parseVariableDeclarator(kind) {
         const id = this.parseBindingTarget();
         let init;
@@ -1544,6 +1674,8 @@ class Parser {
             };
         }
         if (token.type === "keyword" && token.value === "await") {
+            if (!this.lexicalContext.await)
+                throw new DisallowedSyntaxError("await in a class element", token.start);
             if (this.functionContext === "generator") {
                 throw new Error(`generators cannot await; use a regular async function at line ${token.start.line}, column ${token.start.column}.`);
             }
@@ -1677,6 +1809,7 @@ class Parser {
                 const quasi = createTemplateLiteral(this.currentToken(), {
                     allowMalformedEscapes: true,
                     functionContext: this.functionContext,
+                    lexicalContext: this.lexicalContext,
                     source: this.source
                 }, this.compilation);
                 this.index += 1;
@@ -1714,6 +1847,18 @@ class Parser {
     }
     parsePrimaryExpression() {
         const token = this.currentToken();
+        if (token.value === "class")
+            return { node: this.parseClass(false), parenthesized: false };
+        if (token.value === "super") {
+            const next = this.peekToken(1).value;
+            if (!(next === "(" ? this.lexicalContext.superCall :
+                (next === "." || next === "[") && this.lexicalContext.superProperty))
+                throw new DisallowedSyntaxError("super", token.start);
+            this.index++;
+            return { node: { type: "Super", span: createTokenSpan(token) }, parenthesized: false };
+        }
+        if (token.value === "arguments" && !this.lexicalContext.arguments)
+            throw new DisallowedSyntaxError("arguments in a class element", token.start);
         if (token.type === "keyword" && token.value === "this") {
             this.index += 1;
             return {
@@ -1769,6 +1914,7 @@ class Parser {
                 node: createTemplateLiteral(token, {
                     allowMalformedEscapes: false,
                     functionContext: this.functionContext,
+                    lexicalContext: this.lexicalContext,
                     source: this.source
                 }, this.compilation),
                 parenthesized: false
@@ -1815,7 +1961,11 @@ class Parser {
         const newToken = this.currentToken();
         this.index += 1;
         if (this.consumePunctuator(".") !== undefined) {
-            throw new DisallowedSyntaxError(newToken.value, newToken.start);
+            const target = this.currentToken();
+            if (target.value !== "target" || !this.lexicalContext.newTarget)
+                throw new DisallowedSyntaxError(newToken.value, newToken.start);
+            this.index++;
+            return { node: { type: "NewTargetExpression", span: createSpan(newToken.start, target.end) }, parenthesized: false };
         }
         let callee = this.parsePrimaryExpression();
         while (true) {
@@ -1855,6 +2005,8 @@ class Parser {
         const optional = this.consumePunctuator("?.");
         if (optional !== undefined)
             throw new DisallowedSyntaxError("new optional chain", optional.start);
+        if (callee.node.type === "Super")
+            throw new DisallowedSyntaxError("new super", newToken.start);
         const args = this.consumePunctuator("(") === undefined ? [] : this.parseArguments();
         const end = this.previousToken();
         return {
@@ -1877,17 +2029,8 @@ class Parser {
         const id = isIdentifierLikeToken(this.currentToken())
             ? this.parseBindingIdentifier()
             : undefined;
-        const params = this.withScope(() => {
-            const parsedParams = this.parseArrowParameters();
-            for (const param of parsedParams) {
-                for (const identifier of boundIdentifiers(param)) {
-                    this.declareBinding(identifier);
-                }
-            }
-            return parsedParams;
-        });
         const generator = generatorToken !== undefined;
-        const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
+        const { params, body } = this.parseFunctionParts(generator, ordinaryFunctionContext);
         return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
@@ -2142,16 +2285,7 @@ class Parser {
             this.peekToken(2).value === "(");
     }
     parseObjectMethod(asyncToken, methodStart) {
-        const params = this.withScope(() => {
-            const parsedParams = this.parseArrowParameters();
-            for (const param of parsedParams) {
-                for (const identifier of boundIdentifiers(param)) {
-                    this.declareBinding(identifier);
-                }
-            }
-            return parsedParams;
-        });
-        const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
+        const { params, body } = this.parseFunctionParts(false, ordinaryFunctionContext);
         return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
@@ -2578,6 +2712,16 @@ class Parser {
             this.functionContext = previousFunctionContext;
         }
     }
+    withLexicalContext(context, callback) {
+        const previous = this.lexicalContext;
+        this.lexicalContext = context;
+        try {
+            return callback();
+        }
+        finally {
+            this.lexicalContext = previous;
+        }
+    }
     withLoopContext(callback) {
         this.breakableDepth += 1;
         this.loopDepth += 1;
@@ -3046,7 +3190,7 @@ function createTemplateLiteral(token, options, compilation) {
             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), options.functionContext, options.source, compilation));
+            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), options.functionContext, options.lexicalContext, options.source, compilation));
             quasiStart = expressionEnd + 1;
             cursor = expressionEnd + 1;
             continue;
@@ -3407,13 +3551,13 @@ function decodeHexEscape(value, start) {
         end: index + 2
     };
 }
-function parseEmbeddedExpression(source, base, functionContext, fullSource, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, lexicalContext, fullSource, compilation) {
     const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
         ...token,
         start: rebasePosition(token.start, base),
         end: rebasePosition(token.end, base)
     }));
-    return new Parser(tokens, fullSource, compilation, functionContext).parseExpressionOnly();
+    return new Parser(tokens, fullSource, compilation, functionContext, lexicalContext).parseExpressionOnly();
 }
 export function findRegexLiteral(node) {
     if (node === null || node === undefined) {

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

@@ -1,5 +1,8 @@
 import { RegexCompileGuard } from "../interp/regex/compile-guard.js";
 const KEYWORDS = new Set([
+    "class",
+    "extends",
+    "super",
     "const",
     "let",
     "if",

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

@@ -1,4 +1,4 @@
 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";
+export type { ArrayPattern, ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, ClassBody, ClassDeclaration, ClassElement, ClassExpression, ClassNode, ConditionalExpression, ContinueStatement, DoWhileStatement, EmptyStatement, Expression, ExpressionStatement, ExportDefaultDeclaration, ExportNamedDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, LogicalExpression, MemberExpression, MetaProperty, NewExpression, NewTargetExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ParseResult, PatternTarget, Property, RegexLiteral, RestElement, ReturnStatement, SequenceExpression, SourceSpan, SpreadElement, Statement, StringLiteral, SuperExpression, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UndefinedLiteral, UpdateExpression, UpdateTarget, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement } from "./parse/parser.js";