@lewin671/python-vm 0.1.0

package/dist/parser/statements.d.ts

@@ -0,0 +1,20 @@
+import type { Parser } from './parser';
+import { ASTNode } from '../types';
+export declare function parseExpressionStatement(this: Parser): ASTNode;
+export declare function parseExpressionList(this: Parser): ASTNode;
+export declare function parseAssignmentOrExpression(this: Parser): ASTNode;
+export declare function parseBlock(this: Parser): ASTNode[];
+export declare function parseIfStatement(this: Parser): ASTNode;
+export declare function parseWhileStatement(this: Parser): ASTNode;
+export declare function parseForStatement(this: Parser): ASTNode;
+export declare function parseFunctionParameters(this: Parser): ASTNode[];
+export declare function parseFunctionDef(this: Parser, decorators?: ASTNode[]): ASTNode;
+export declare function parseClassDef(this: Parser, decorators?: ASTNode[]): ASTNode;
+export declare function parseDecorators(this: Parser): ASTNode[];
+export declare function parseTryStatement(this: Parser): ASTNode;
+export declare function parseWithStatement(this: Parser): ASTNode;
+export declare function parseMatchStatement(this: Parser): ASTNode;
+export declare function parseImportStatement(this: Parser): ASTNode;
+export declare function parseStatement(this: Parser): ASTNode;
+export declare function parseProgram(this: Parser): ASTNode;
+//# sourceMappingURL=statements.d.ts.map

package/dist/parser/statements.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpressionStatement = parseExpressionStatement;
+exports.parseExpressionList = parseExpressionList;
+exports.parseAssignmentOrExpression = parseAssignmentOrExpression;
+exports.parseBlock = parseBlock;
+exports.parseIfStatement = parseIfStatement;
+exports.parseWhileStatement = parseWhileStatement;
+exports.parseForStatement = parseForStatement;
+exports.parseFunctionParameters = parseFunctionParameters;
+exports.parseFunctionDef = parseFunctionDef;
+exports.parseClassDef = parseClassDef;
+exports.parseDecorators = parseDecorators;
+exports.parseTryStatement = parseTryStatement;
+exports.parseWithStatement = parseWithStatement;
+exports.parseMatchStatement = parseMatchStatement;
+exports.parseImportStatement = parseImportStatement;
+exports.parseStatement = parseStatement;
+exports.parseProgram = parseProgram;
+const types_1 = require("../types");
+function parseExpressionStatement() {
+    return { type: types_1.ASTNodeType.EXPRESSION_STATEMENT, expression: this.parseExpression() };
+}
+function parseExpressionList() {
+    const first = this.parseExpression();
+    if (this.match(types_1.TokenType.COMMA)) {
+        const elements = [first];
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            if (this.match(types_1.TokenType.NEWLINE) || this.match(types_1.TokenType.RPAREN) || this.match(types_1.TokenType.RBRACKET) || this.match(types_1.TokenType.RBRACE))
+                break;
+            elements.push(this.parseExpression());
+        }
+        return { type: types_1.ASTNodeType.TUPLE_LITERAL, elements };
+    }
+    return first;
+}
+function parseAssignmentOrExpression() {
+    const startPos = this.pos;
+    const target = this.parseTarget();
+    if (this.match(types_1.TokenType.ASSIGN)) {
+        this.consume();
+        const value = this.parseExpressionList();
+        return { type: types_1.ASTNodeType.ASSIGNMENT, targets: [target], value };
+    }
+    if (this.match(types_1.TokenType.OPERATOR) && ['+=', '-=', '*=', '/=', '%=', '//=', '**='].includes(this.peek()?.value || '')) {
+        const op = this.consume().value;
+        const value = this.parseExpressionList();
+        return { type: types_1.ASTNodeType.AUG_ASSIGNMENT, target, operator: op, value };
+    }
+    this.pos = startPos;
+    return this.parseExpressionStatement();
+}
+function parseBlock() {
+    this.expect(types_1.TokenType.NEWLINE);
+    this.expect(types_1.TokenType.INDENT);
+    const body = [];
+    while (!this.match(types_1.TokenType.DEDENT) && !this.match(types_1.TokenType.EOF)) {
+        const stmt = this.parseStatement();
+        body.push(stmt);
+        this.skipNewlines();
+    }
+    this.expect(types_1.TokenType.DEDENT);
+    return body;
+}
+function parseIfStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'if');
+    const test = this.parseExpression();
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    const elifs = [];
+    while (this.match(types_1.TokenType.KEYWORD, 'elif')) {
+        this.consume();
+        const elifTest = this.parseExpression();
+        this.expect(types_1.TokenType.COLON);
+        const elifBody = this.parseBlock();
+        elifs.push({ test: elifTest, body: elifBody });
+    }
+    let orelse = [];
+    if (this.match(types_1.TokenType.KEYWORD, 'else')) {
+        this.consume();
+        this.expect(types_1.TokenType.COLON);
+        orelse = this.parseBlock();
+    }
+    return { type: types_1.ASTNodeType.IF_STATEMENT, test, body, elifs, orelse };
+}
+function parseWhileStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'while');
+    const test = this.parseExpression();
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    return { type: types_1.ASTNodeType.WHILE_STATEMENT, test, body };
+}
+function parseForStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'for');
+    const target = this.parseTarget();
+    this.expect(types_1.TokenType.KEYWORD, 'in');
+    const iter = this.parseExpression();
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    return { type: types_1.ASTNodeType.FOR_STATEMENT, target, iter, body };
+}
+function parseFunctionParameters() {
+    const params = [];
+    if (!this.match(types_1.TokenType.RPAREN)) {
+        while (true) {
+            if (this.match(types_1.TokenType.OPERATOR, '*')) {
+                this.consume();
+                const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+                params.push({ type: 'VarArg', name });
+            }
+            else if (this.match(types_1.TokenType.OPERATOR, '**')) {
+                this.consume();
+                const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+                params.push({ type: 'KwArg', name });
+            }
+            else if (this.match(types_1.TokenType.IDENTIFIER)) {
+                const name = this.consume().value;
+                let defaultValue = null;
+                if (this.match(types_1.TokenType.ASSIGN)) {
+                    this.consume();
+                    defaultValue = this.parseExpression();
+                }
+                params.push({ type: 'Param', name, defaultValue });
+            }
+            if (!this.match(types_1.TokenType.COMMA))
+                break;
+            this.consume();
+            if (this.match(types_1.TokenType.RPAREN))
+                break;
+        }
+    }
+    return params;
+}
+function parseFunctionDef(decorators = []) {
+    this.expect(types_1.TokenType.KEYWORD, 'def');
+    const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+    this.expect(types_1.TokenType.LPAREN);
+    const params = this.parseFunctionParameters();
+    this.expect(types_1.TokenType.RPAREN);
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    return { type: types_1.ASTNodeType.FUNCTION_DEF, name, params, body, decorators };
+}
+function parseClassDef(decorators = []) {
+    this.expect(types_1.TokenType.KEYWORD, 'class');
+    const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+    let bases = [];
+    if (this.match(types_1.TokenType.LPAREN)) {
+        this.consume();
+        if (!this.match(types_1.TokenType.RPAREN)) {
+            bases.push(this.parseExpression());
+            while (this.match(types_1.TokenType.COMMA)) {
+                this.consume();
+                if (this.match(types_1.TokenType.RPAREN))
+                    break;
+                bases.push(this.parseExpression());
+            }
+        }
+        this.expect(types_1.TokenType.RPAREN);
+    }
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    return { type: types_1.ASTNodeType.CLASS_DEF, name, bases, body, decorators };
+}
+function parseDecorators() {
+    const decorators = [];
+    while (this.match(types_1.TokenType.AT)) {
+        this.consume();
+        const decorator = this.parseExpression();
+        decorators.push(decorator);
+        this.expect(types_1.TokenType.NEWLINE);
+    }
+    return decorators;
+}
+function parseTryStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'try');
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    const handlers = [];
+    while (this.match(types_1.TokenType.KEYWORD, 'except')) {
+        this.consume();
+        let exceptionType = null;
+        let name = null;
+        if (!this.match(types_1.TokenType.COLON)) {
+            exceptionType = this.parseExpression();
+            if (this.match(types_1.TokenType.KEYWORD, 'as')) {
+                this.consume();
+                name = this.expect(types_1.TokenType.IDENTIFIER).value;
+            }
+        }
+        this.expect(types_1.TokenType.COLON);
+        const handlerBody = this.parseBlock();
+        handlers.push({ exceptionType, name, body: handlerBody });
+    }
+    let orelse = [];
+    if (this.match(types_1.TokenType.KEYWORD, 'else')) {
+        this.consume();
+        this.expect(types_1.TokenType.COLON);
+        orelse = this.parseBlock();
+    }
+    let finalbody = [];
+    if (this.match(types_1.TokenType.KEYWORD, 'finally')) {
+        this.consume();
+        this.expect(types_1.TokenType.COLON);
+        finalbody = this.parseBlock();
+    }
+    return { type: types_1.ASTNodeType.TRY_STATEMENT, body, handlers, orelse, finalbody };
+}
+function parseWithStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'with');
+    const items = [];
+    while (true) {
+        const context = this.parseExpression();
+        let target = null;
+        if (this.match(types_1.TokenType.KEYWORD, 'as')) {
+            this.consume();
+            target = this.parseTarget();
+        }
+        items.push({ context, target });
+        if (!this.match(types_1.TokenType.COMMA))
+            break;
+        this.consume();
+    }
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseBlock();
+    return { type: types_1.ASTNodeType.WITH_STATEMENT, items, body };
+}
+function parseMatchStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'match');
+    const subject = this.parseExpression();
+    this.expect(types_1.TokenType.COLON);
+    this.expect(types_1.TokenType.NEWLINE);
+    this.expect(types_1.TokenType.INDENT);
+    const cases = [];
+    while (!this.match(types_1.TokenType.DEDENT) && !this.match(types_1.TokenType.EOF)) {
+        this.expect(types_1.TokenType.KEYWORD, 'case');
+        const pattern = this.parsePattern();
+        let guard = null;
+        if (this.match(types_1.TokenType.KEYWORD, 'if')) {
+            this.consume();
+            guard = this.parseExpression();
+        }
+        this.expect(types_1.TokenType.COLON);
+        const body = this.parseBlock();
+        cases.push({ pattern, guard, body });
+    }
+    this.expect(types_1.TokenType.DEDENT);
+    return { type: types_1.ASTNodeType.MATCH_STATEMENT, subject, cases };
+}
+function parseImportStatement() {
+    this.expect(types_1.TokenType.KEYWORD, 'import');
+    const names = [];
+    const parseName = () => {
+        let name = this.expect(types_1.TokenType.IDENTIFIER).value;
+        while (this.match(types_1.TokenType.DOT)) {
+            this.consume();
+            name += `.${this.expect(types_1.TokenType.IDENTIFIER).value}`;
+        }
+        let alias = null;
+        if (this.match(types_1.TokenType.KEYWORD, 'as')) {
+            this.consume();
+            alias = this.expect(types_1.TokenType.IDENTIFIER).value;
+        }
+        names.push({ name, alias });
+    };
+    parseName();
+    while (this.match(types_1.TokenType.COMMA)) {
+        this.consume();
+        parseName();
+    }
+    return { type: types_1.ASTNodeType.IMPORT_STATEMENT, names };
+}
+function parseStatement() {
+    this.skipNewlines();
+    if (this.match(types_1.TokenType.AT)) {
+        const decorators = this.parseDecorators();
+        if (this.match(types_1.TokenType.KEYWORD, 'async')) {
+            this.consume();
+            if (!this.match(types_1.TokenType.KEYWORD, 'def'))
+                throw new Error('async must be followed by def');
+            const node = this.parseFunctionDef(decorators);
+            node.isAsync = true;
+            return node;
+        }
+        if (this.match(types_1.TokenType.KEYWORD, 'def'))
+            return this.parseFunctionDef(decorators);
+        if (this.match(types_1.TokenType.KEYWORD, 'class'))
+            return this.parseClassDef(decorators);
+        throw new Error('Decorator must be followed by def or class');
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'async')) {
+        this.consume();
+        if (!this.match(types_1.TokenType.KEYWORD, 'def'))
+            throw new Error('async must be followed by def');
+        const node = this.parseFunctionDef();
+        node.isAsync = true;
+        return node;
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'import'))
+        return this.parseImportStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'def'))
+        return this.parseFunctionDef();
+    if (this.match(types_1.TokenType.KEYWORD, 'class'))
+        return this.parseClassDef();
+    if (this.match(types_1.TokenType.KEYWORD, 'if'))
+        return this.parseIfStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'for'))
+        return this.parseForStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'while'))
+        return this.parseWhileStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'try'))
+        return this.parseTryStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'with'))
+        return this.parseWithStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'match'))
+        return this.parseMatchStatement();
+    if (this.match(types_1.TokenType.KEYWORD, 'return')) {
+        this.consume();
+        const value = this.match(types_1.TokenType.NEWLINE) ? null : this.parseExpressionList();
+        return { type: types_1.ASTNodeType.RETURN_STATEMENT, value };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'break')) {
+        this.consume();
+        return { type: types_1.ASTNodeType.BREAK_STATEMENT };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'continue')) {
+        this.consume();
+        return { type: types_1.ASTNodeType.CONTINUE_STATEMENT };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'pass')) {
+        this.consume();
+        return { type: types_1.ASTNodeType.PASS_STATEMENT };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'assert')) {
+        this.consume();
+        const test = this.parseExpression();
+        let message = null;
+        if (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            message = this.parseExpression();
+        }
+        return { type: types_1.ASTNodeType.ASSERT_STATEMENT, test, message };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'raise')) {
+        this.consume();
+        const exc = this.match(types_1.TokenType.NEWLINE) ? null : this.parseExpression();
+        return { type: types_1.ASTNodeType.RAISE_STATEMENT, exception: exc };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'global')) {
+        this.consume();
+        const names = [];
+        names.push(this.expect(types_1.TokenType.IDENTIFIER).value);
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            names.push(this.expect(types_1.TokenType.IDENTIFIER).value);
+        }
+        return { type: types_1.ASTNodeType.GLOBAL_STATEMENT, names };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'nonlocal')) {
+        this.consume();
+        const names = [];
+        names.push(this.expect(types_1.TokenType.IDENTIFIER).value);
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            names.push(this.expect(types_1.TokenType.IDENTIFIER).value);
+        }
+        return { type: types_1.ASTNodeType.NONLOCAL_STATEMENT, names };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'del')) {
+        this.consume();
+        const target = this.parseExpression();
+        return { type: types_1.ASTNodeType.DELETE_STATEMENT, target };
+    }
+    return this.parseAssignmentOrExpression();
+}
+function parseProgram() {
+    const body = [];
+    this.skipNewlines();
+    while (this.pos < this.tokens.length && !this.match(types_1.TokenType.EOF)) {
+        const stmt = this.parseStatement();
+        body.push(stmt);
+        this.skipNewlines();
+    }
+    this.expect(types_1.TokenType.EOF);
+    return { type: types_1.ASTNodeType.PROGRAM, body };
+}
+//# sourceMappingURL=statements.js.map

package/dist/parser/targets.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from './parser';
+import { ASTNode } from '../types';
+export declare function parsePostfixTarget(this: Parser): ASTNode;
+export declare function parseTargetElement(this: Parser): ASTNode;
+export declare function parseTarget(this: Parser): ASTNode;
+//# sourceMappingURL=targets.d.ts.map

package/dist/parser/targets.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePostfixTarget = parsePostfixTarget;
+exports.parseTargetElement = parseTargetElement;
+exports.parseTarget = parseTarget;
+const types_1 = require("../types");
+function parsePostfixTarget() {
+    let expr = this.parseAtom();
+    while (this.match(types_1.TokenType.LBRACKET) ||
+        (this.match(types_1.TokenType.DOT) && this.peek(1)?.type === types_1.TokenType.IDENTIFIER)) {
+        if (this.match(types_1.TokenType.LBRACKET)) {
+            this.consume();
+            const index = this.parseSlice();
+            this.expect(types_1.TokenType.RBRACKET);
+            expr = { type: types_1.ASTNodeType.SUBSCRIPT, object: expr, index };
+        }
+        else if (this.match(types_1.TokenType.DOT)) {
+            this.consume();
+            const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+            expr = { type: types_1.ASTNodeType.ATTRIBUTE, object: expr, name };
+        }
+    }
+    return expr;
+}
+function parseTargetElement() {
+    if (this.match(types_1.TokenType.OPERATOR, '*')) {
+        this.consume();
+        const target = this.parseTargetElement();
+        return { type: types_1.ASTNodeType.STARRED, target };
+    }
+    if (this.match(types_1.TokenType.IDENTIFIER))
+        return this.parsePostfixTarget();
+    if (this.match(types_1.TokenType.LPAREN)) {
+        this.consume();
+        const target = this.parseTarget();
+        this.expect(types_1.TokenType.RPAREN);
+        return target;
+    }
+    if (this.match(types_1.TokenType.LBRACKET)) {
+        this.consume();
+        const elements = [];
+        if (!this.match(types_1.TokenType.RBRACKET)) {
+            elements.push(this.parseTarget());
+            while (this.match(types_1.TokenType.COMMA)) {
+                this.consume();
+                if (this.match(types_1.TokenType.RBRACKET))
+                    break;
+                elements.push(this.parseTarget());
+            }
+        }
+        this.expect(types_1.TokenType.RBRACKET);
+        return { type: types_1.ASTNodeType.LIST_LITERAL, elements };
+    }
+    return this.parsePostfixTarget();
+}
+function parseTarget() {
+    if (this.match(types_1.TokenType.OPERATOR, '*')) {
+        this.consume();
+        const target = this.parseTargetElement();
+        return { type: types_1.ASTNodeType.STARRED, target };
+    }
+    const first = this.parseTargetElement();
+    if (this.match(types_1.TokenType.COMMA)) {
+        const elements = [first];
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            if (this.match(types_1.TokenType.NEWLINE) || this.match(types_1.TokenType.EOF))
+                break;
+            elements.push(this.parseTargetElement());
+        }
+        return { type: types_1.ASTNodeType.TUPLE_LITERAL, elements };
+    }
+    return first;
+}
+//# sourceMappingURL=targets.js.map

package/dist/types/ast.d.ts

@@ -0,0 +1,63 @@
+/**
+ * AST 节点类型定义
+ */
+export interface ASTNode {
+    type: string;
+    [key: string]: any;
+}
+export declare enum ASTNodeType {
+    PROGRAM = "Program",
+    ASSIGNMENT = "Assignment",
+    AUG_ASSIGNMENT = "AugAssignment",
+    EXPRESSION_STATEMENT = "ExpressionStatement",
+    IF_STATEMENT = "IfStatement",
+    WHILE_STATEMENT = "WhileStatement",
+    FOR_STATEMENT = "ForStatement",
+    FUNCTION_DEF = "FunctionDef",
+    RETURN_STATEMENT = "ReturnStatement",
+    BREAK_STATEMENT = "BreakStatement",
+    CONTINUE_STATEMENT = "ContinueStatement",
+    PASS_STATEMENT = "PassStatement",
+    IMPORT_STATEMENT = "ImportStatement",
+    CLASS_DEF = "ClassDef",
+    TRY_STATEMENT = "TryStatement",
+    WITH_STATEMENT = "WithStatement",
+    ASSERT_STATEMENT = "AssertStatement",
+    RAISE_STATEMENT = "RaiseStatement",
+    GLOBAL_STATEMENT = "GlobalStatement",
+    NONLOCAL_STATEMENT = "NonlocalStatement",
+    DELETE_STATEMENT = "DeleteStatement",
+    MATCH_STATEMENT = "MatchStatement",
+    MATCH_CASE = "MatchCase",
+    MATCH_PATTERN_VALUE = "MatchPatternValue",
+    MATCH_PATTERN_CAPTURE = "MatchPatternCapture",
+    MATCH_PATTERN_WILDCARD = "MatchPatternWildcard",
+    MATCH_PATTERN_OR = "MatchPatternOr",
+    MATCH_PATTERN_SEQUENCE = "MatchPatternSequence",
+    BINARY_OPERATION = "BinaryOperation",
+    UNARY_OPERATION = "UnaryOperation",
+    NUMBER_LITERAL = "NumberLiteral",
+    STRING_LITERAL = "StringLiteral",
+    BOOLEAN_LITERAL = "BooleanLiteral",
+    NONE_LITERAL = "NoneLiteral",
+    LIST_LITERAL = "ListLiteral",
+    TUPLE_LITERAL = "TupleLiteral",
+    DICT_LITERAL = "DictLiteral",
+    SET_LITERAL = "SetLiteral",
+    IDENTIFIER = "Identifier",
+    ATTRIBUTE = "Attribute",
+    SUBSCRIPT = "Subscript",
+    SLICE = "Slice",
+    CALL = "Call",
+    COMPARE = "Compare",
+    BOOL_OPERATION = "BoolOperation",
+    IF_EXPRESSION = "IfExpression",
+    LAMBDA = "Lambda",
+    LIST_COMP = "ListComp",
+    DICT_COMP = "DictComp",
+    SET_COMP = "SetComp",
+    GENERATOR_EXPR = "GeneratorExpr",
+    YIELD = "Yield",
+    STARRED = "Starred"
+}
+//# sourceMappingURL=ast.d.ts.map

package/dist/types/ast.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTNodeType = void 0;
+var ASTNodeType;
+(function (ASTNodeType) {
+    ASTNodeType["PROGRAM"] = "Program";
+    ASTNodeType["ASSIGNMENT"] = "Assignment";
+    ASTNodeType["AUG_ASSIGNMENT"] = "AugAssignment";
+    ASTNodeType["EXPRESSION_STATEMENT"] = "ExpressionStatement";
+    ASTNodeType["IF_STATEMENT"] = "IfStatement";
+    ASTNodeType["WHILE_STATEMENT"] = "WhileStatement";
+    ASTNodeType["FOR_STATEMENT"] = "ForStatement";
+    ASTNodeType["FUNCTION_DEF"] = "FunctionDef";
+    ASTNodeType["RETURN_STATEMENT"] = "ReturnStatement";
+    ASTNodeType["BREAK_STATEMENT"] = "BreakStatement";
+    ASTNodeType["CONTINUE_STATEMENT"] = "ContinueStatement";
+    ASTNodeType["PASS_STATEMENT"] = "PassStatement";
+    ASTNodeType["IMPORT_STATEMENT"] = "ImportStatement";
+    ASTNodeType["CLASS_DEF"] = "ClassDef";
+    ASTNodeType["TRY_STATEMENT"] = "TryStatement";
+    ASTNodeType["WITH_STATEMENT"] = "WithStatement";
+    ASTNodeType["ASSERT_STATEMENT"] = "AssertStatement";
+    ASTNodeType["RAISE_STATEMENT"] = "RaiseStatement";
+    ASTNodeType["GLOBAL_STATEMENT"] = "GlobalStatement";
+    ASTNodeType["NONLOCAL_STATEMENT"] = "NonlocalStatement";
+    ASTNodeType["DELETE_STATEMENT"] = "DeleteStatement";
+    ASTNodeType["MATCH_STATEMENT"] = "MatchStatement";
+    ASTNodeType["MATCH_CASE"] = "MatchCase";
+    ASTNodeType["MATCH_PATTERN_VALUE"] = "MatchPatternValue";
+    ASTNodeType["MATCH_PATTERN_CAPTURE"] = "MatchPatternCapture";
+    ASTNodeType["MATCH_PATTERN_WILDCARD"] = "MatchPatternWildcard";
+    ASTNodeType["MATCH_PATTERN_OR"] = "MatchPatternOr";
+    ASTNodeType["MATCH_PATTERN_SEQUENCE"] = "MatchPatternSequence";
+    ASTNodeType["BINARY_OPERATION"] = "BinaryOperation";
+    ASTNodeType["UNARY_OPERATION"] = "UnaryOperation";
+    ASTNodeType["NUMBER_LITERAL"] = "NumberLiteral";
+    ASTNodeType["STRING_LITERAL"] = "StringLiteral";
+    ASTNodeType["BOOLEAN_LITERAL"] = "BooleanLiteral";
+    ASTNodeType["NONE_LITERAL"] = "NoneLiteral";
+    ASTNodeType["LIST_LITERAL"] = "ListLiteral";
+    ASTNodeType["TUPLE_LITERAL"] = "TupleLiteral";
+    ASTNodeType["DICT_LITERAL"] = "DictLiteral";
+    ASTNodeType["SET_LITERAL"] = "SetLiteral";
+    ASTNodeType["IDENTIFIER"] = "Identifier";
+    ASTNodeType["ATTRIBUTE"] = "Attribute";
+    ASTNodeType["SUBSCRIPT"] = "Subscript";
+    ASTNodeType["SLICE"] = "Slice";
+    ASTNodeType["CALL"] = "Call";
+    ASTNodeType["COMPARE"] = "Compare";
+    ASTNodeType["BOOL_OPERATION"] = "BoolOperation";
+    ASTNodeType["IF_EXPRESSION"] = "IfExpression";
+    ASTNodeType["LAMBDA"] = "Lambda";
+    ASTNodeType["LIST_COMP"] = "ListComp";
+    ASTNodeType["DICT_COMP"] = "DictComp";
+    ASTNodeType["SET_COMP"] = "SetComp";
+    ASTNodeType["GENERATOR_EXPR"] = "GeneratorExpr";
+    ASTNodeType["YIELD"] = "Yield";
+    ASTNodeType["STARRED"] = "Starred";
+})(ASTNodeType || (exports.ASTNodeType = ASTNodeType = {}));
+//# sourceMappingURL=ast.js.map

package/dist/types/bytecode.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 字节码类型定义
+ */
+export interface ByteCode {
+    instructions: Instruction[];
+    constants: any[];
+    names: string[];
+    ast?: any;
+}
+export interface Instruction {
+    opcode: OpCode;
+    arg?: number;
+}
+export declare enum OpCode {
+    LOAD_CONST = 0,
+    LOAD_NAME = 1,
+    STORE_NAME = 2,
+    BINARY_ADD = 3,
+    BINARY_SUBTRACT = 4,
+    BINARY_MULTIPLY = 5,
+    BINARY_DIVIDE = 6,
+    BINARY_MODULO = 7,
+    BINARY_POWER = 8,
+    COMPARE_EQ = 9,
+    COMPARE_NE = 10,
+    COMPARE_LT = 11,
+    COMPARE_GT = 12,
+    COMPARE_LE = 13,
+    COMPARE_GE = 14,
+    LOGICAL_AND = 15,
+    LOGICAL_OR = 16,
+    LOGICAL_NOT = 17,
+    CALL_FUNCTION = 18,
+    RETURN_VALUE = 19,
+    PRINT_ITEM = 20,
+    PRINT_NEWLINE = 21
+}
+//# sourceMappingURL=bytecode.d.ts.map