@lewin671/python-vm 0.1.0

package/dist/parser/expressions.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringLiteral = parseStringLiteral;
+exports.parseLiteral = parseLiteral;
+exports.parseIdentifier = parseIdentifier;
+exports.parseArguments = parseArguments;
+exports.parseSlice = parseSlice;
+exports.parsePatternAtom = parsePatternAtom;
+exports.parsePattern = parsePattern;
+exports.parseLambdaParameters = parseLambdaParameters;
+exports.parseLambda = parseLambda;
+exports.parseAtom = parseAtom;
+exports.parsePostfix = parsePostfix;
+exports.parseUnary = parseUnary;
+exports.parsePower = parsePower;
+exports.parseFactor = parseFactor;
+exports.parseTerm = parseTerm;
+exports.parseShift = parseShift;
+exports.parseBitAnd = parseBitAnd;
+exports.parseBitXor = parseBitXor;
+exports.parseBitOr = parseBitOr;
+exports.parseComparison = parseComparison;
+exports.parseNot = parseNot;
+exports.parseAnd = parseAnd;
+exports.parseOr = parseOr;
+exports.parseIfExpression = parseIfExpression;
+exports.parseExpression = parseExpression;
+exports.parseExpressionNoIf = parseExpressionNoIf;
+exports.parseComprehension = parseComprehension;
+const types_1 = require("../types");
+function parseStringLiteral() {
+    let value = '';
+    while (this.match(types_1.TokenType.STRING))
+        value += this.consume().value;
+    return { type: types_1.ASTNodeType.STRING_LITERAL, value };
+}
+function parseLiteral() {
+    const token = this.peek();
+    if (!token)
+        throw new Error('Expected literal');
+    if (token.type === types_1.TokenType.NUMBER) {
+        this.consume();
+        return { type: types_1.ASTNodeType.NUMBER_LITERAL, value: token.value };
+    }
+    if (token.type === types_1.TokenType.STRING)
+        return this.parseStringLiteral();
+    if (token.type === types_1.TokenType.BOOLEAN) {
+        this.consume();
+        return { type: types_1.ASTNodeType.BOOLEAN_LITERAL, value: token.value === 'True' };
+    }
+    if (token.type === types_1.TokenType.NONE) {
+        this.consume();
+        return { type: types_1.ASTNodeType.NONE_LITERAL, value: null };
+    }
+    throw new Error(`Unexpected token type for literal: ${types_1.TokenType[token.type]}`);
+}
+function parseIdentifier() {
+    const token = this.expect(types_1.TokenType.IDENTIFIER);
+    return { type: types_1.ASTNodeType.IDENTIFIER, name: token.value };
+}
+function parseArguments() {
+    const args = [];
+    if (!this.match(types_1.TokenType.RPAREN)) {
+        while (true) {
+            if (this.match(types_1.TokenType.OPERATOR, '*') || this.match(types_1.TokenType.OPERATOR, '**')) {
+                const op = this.consume().value;
+                const value = this.parseExpression();
+                args.push({ type: op === '*' ? 'StarArg' : 'KwArg', value });
+            }
+            else if (this.match(types_1.TokenType.IDENTIFIER) && this.peek(1)?.type === types_1.TokenType.ASSIGN) {
+                const name = this.consume().value;
+                this.consume();
+                const value = this.parseExpression();
+                args.push({ type: 'KeywordArg', name, value });
+            }
+            else {
+                args.push(this.parseExpression());
+            }
+            if (!this.match(types_1.TokenType.COMMA))
+                break;
+            this.consume();
+            if (this.match(types_1.TokenType.RPAREN))
+                break;
+        }
+    }
+    return args;
+}
+function parseSlice() {
+    let start = null;
+    let end = null;
+    let step = null;
+    if (!this.match(types_1.TokenType.COLON))
+        start = this.parseExpression();
+    if (this.match(types_1.TokenType.COLON)) {
+        this.consume();
+        if (!this.match(types_1.TokenType.COLON) && !this.match(types_1.TokenType.RBRACKET))
+            end = this.parseExpression();
+        if (this.match(types_1.TokenType.COLON)) {
+            this.consume();
+            if (!this.match(types_1.TokenType.RBRACKET))
+                step = this.parseExpression();
+        }
+        return { type: types_1.ASTNodeType.SLICE, start, end, step };
+    }
+    return start;
+}
+function parsePatternAtom() {
+    if (this.match(types_1.TokenType.NUMBER) || this.match(types_1.TokenType.STRING) || this.match(types_1.TokenType.BOOLEAN) || this.match(types_1.TokenType.NONE)) {
+        return { type: types_1.ASTNodeType.MATCH_PATTERN_VALUE, value: this.parseLiteral() };
+    }
+    if (this.match(types_1.TokenType.IDENTIFIER)) {
+        const name = this.consume().value;
+        if (name === '_')
+            return { type: types_1.ASTNodeType.MATCH_PATTERN_WILDCARD };
+        return { type: types_1.ASTNodeType.MATCH_PATTERN_CAPTURE, name };
+    }
+    if (this.match(types_1.TokenType.LBRACKET)) {
+        this.consume();
+        const elements = [];
+        if (!this.match(types_1.TokenType.RBRACKET)) {
+            elements.push(this.parsePattern());
+            while (this.match(types_1.TokenType.COMMA)) {
+                this.consume();
+                if (this.match(types_1.TokenType.RBRACKET))
+                    break;
+                elements.push(this.parsePattern());
+            }
+        }
+        this.expect(types_1.TokenType.RBRACKET);
+        return { type: types_1.ASTNodeType.MATCH_PATTERN_SEQUENCE, elements };
+    }
+    throw new Error(`Unexpected token in pattern: ${this.peek()?.value}`);
+}
+function parsePattern() {
+    let pattern = this.parsePatternAtom();
+    if (this.match(types_1.TokenType.OPERATOR, '|')) {
+        const patterns = [pattern];
+        while (this.match(types_1.TokenType.OPERATOR, '|')) {
+            this.consume();
+            patterns.push(this.parsePatternAtom());
+        }
+        pattern = { type: types_1.ASTNodeType.MATCH_PATTERN_OR, patterns };
+    }
+    return pattern;
+}
+function parseLambdaParameters() {
+    const params = [];
+    if (this.match(types_1.TokenType.COLON))
+        return params;
+    while (true) {
+        if (this.match(types_1.TokenType.OPERATOR, '*')) {
+            this.consume();
+            params.push(`*${this.expect(types_1.TokenType.IDENTIFIER).value}`);
+        }
+        else if (this.match(types_1.TokenType.OPERATOR, '**')) {
+            this.consume();
+            params.push(`**${this.expect(types_1.TokenType.IDENTIFIER).value}`);
+        }
+        else {
+            const name = this.expect(types_1.TokenType.IDENTIFIER).value;
+            if (this.match(types_1.TokenType.ASSIGN)) {
+                this.consume();
+                this.parseExpression();
+            }
+            params.push(name);
+        }
+        if (!this.match(types_1.TokenType.COMMA))
+            break;
+        this.consume();
+    }
+    return params;
+}
+function parseLambda() {
+    this.consume(); // lambda
+    const params = this.parseLambdaParameters();
+    this.expect(types_1.TokenType.COLON);
+    const body = this.parseExpression();
+    return { type: types_1.ASTNodeType.LAMBDA, params, body };
+}
+function parseAtom() {
+    if (this.match(types_1.TokenType.LPAREN)) {
+        this.consume();
+        if (this.match(types_1.TokenType.RPAREN)) {
+            this.consume();
+            return { type: types_1.ASTNodeType.TUPLE_LITERAL, elements: [] };
+        }
+        const expr = this.parseExpression();
+        if (this.match(types_1.TokenType.KEYWORD, 'for')) {
+            const comprehension = this.parseComprehension(expr);
+            this.expect(types_1.TokenType.RPAREN);
+            return { type: types_1.ASTNodeType.GENERATOR_EXPR, expression: expr, comprehension };
+        }
+        if (this.match(types_1.TokenType.COMMA)) {
+            const elements = [expr];
+            while (this.match(types_1.TokenType.COMMA)) {
+                this.consume();
+                if (this.match(types_1.TokenType.RPAREN))
+                    break;
+                elements.push(this.parseExpression());
+            }
+            this.expect(types_1.TokenType.RPAREN);
+            return { type: types_1.ASTNodeType.TUPLE_LITERAL, elements };
+        }
+        this.expect(types_1.TokenType.RPAREN);
+        return expr;
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'yield')) {
+        this.consume();
+        const value = this.match(types_1.TokenType.NEWLINE) || this.match(types_1.TokenType.COMMA) || this.match(types_1.TokenType.RPAREN) ? null : this.parseExpression();
+        return { type: types_1.ASTNodeType.YIELD, value };
+    }
+    if (this.match(types_1.TokenType.KEYWORD, 'lambda')) {
+        return this.parseLambda();
+    }
+    if (this.match(types_1.TokenType.LBRACKET)) {
+        this.consume();
+        if (this.match(types_1.TokenType.RBRACKET)) {
+            this.consume();
+            return { type: types_1.ASTNodeType.LIST_LITERAL, elements: [] };
+        }
+        const first = this.parseExpression();
+        if (this.match(types_1.TokenType.KEYWORD, 'for')) {
+            const comprehension = this.parseComprehension(first);
+            this.expect(types_1.TokenType.RBRACKET);
+            return { type: types_1.ASTNodeType.LIST_COMP, expression: first, comprehension };
+        }
+        const elements = [first];
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            if (this.match(types_1.TokenType.RBRACKET))
+                break;
+            elements.push(this.parseExpression());
+        }
+        this.expect(types_1.TokenType.RBRACKET);
+        return { type: types_1.ASTNodeType.LIST_LITERAL, elements };
+    }
+    if (this.match(types_1.TokenType.LBRACE)) {
+        this.consume();
+        if (this.match(types_1.TokenType.RBRACE)) {
+            this.consume();
+            return { type: types_1.ASTNodeType.DICT_LITERAL, entries: [] };
+        }
+        const key = this.parseExpression();
+        if (this.match(types_1.TokenType.COLON)) {
+            this.consume();
+            const value = this.parseExpression();
+            if (this.match(types_1.TokenType.KEYWORD, 'for')) {
+                const comprehension = this.parseComprehension({ type: 'KeyValue', key, value });
+                this.expect(types_1.TokenType.RBRACE);
+                return { type: types_1.ASTNodeType.DICT_COMP, key, value, comprehension };
+            }
+            const entries = [{ key, value }];
+            while (this.match(types_1.TokenType.COMMA)) {
+                this.consume();
+                if (this.match(types_1.TokenType.RBRACE))
+                    break;
+                const k = this.parseExpression();
+                this.expect(types_1.TokenType.COLON);
+                const v = this.parseExpression();
+                entries.push({ key: k, value: v });
+            }
+            this.expect(types_1.TokenType.RBRACE);
+            return { type: types_1.ASTNodeType.DICT_LITERAL, entries };
+        }
+        if (this.match(types_1.TokenType.KEYWORD, 'for')) {
+            const comprehension = this.parseComprehension(key);
+            this.expect(types_1.TokenType.RBRACE);
+            return { type: types_1.ASTNodeType.SET_COMP, expression: key, comprehension };
+        }
+        const elements = [key];
+        while (this.match(types_1.TokenType.COMMA)) {
+            this.consume();
+            if (this.match(types_1.TokenType.RBRACE))
+                break;
+            elements.push(this.parseExpression());
+        }
+        this.expect(types_1.TokenType.RBRACE);
+        return { type: types_1.ASTNodeType.SET_LITERAL, elements };
+    }
+    if (this.match(types_1.TokenType.IDENTIFIER)) {
+        const name = this.consume().value;
+        return { type: types_1.ASTNodeType.IDENTIFIER, name };
+    }
+    return this.parseLiteral();
+}
+function parsePostfix() {
+    let expr = this.parseAtom();
+    while (this.match(types_1.TokenType.LPAREN) ||
+        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.LPAREN)) {
+            this.consume();
+            const args = this.parseArguments();
+            this.expect(types_1.TokenType.RPAREN);
+            expr = { type: types_1.ASTNodeType.CALL, callee: expr, args };
+        }
+        else 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 parseUnary() {
+    if (this.match(types_1.TokenType.OPERATOR, '+') || this.match(types_1.TokenType.OPERATOR, '-') || this.match(types_1.TokenType.OPERATOR, '~')) {
+        const operator = this.consume().value;
+        const operand = this.parseUnary();
+        return { type: types_1.ASTNodeType.UNARY_OPERATION, operator, operand };
+    }
+    if (this.match(types_1.TokenType.KEYWORD) && this.peek()?.value === 'not') {
+        this.consume();
+        const operand = this.parseUnary();
+        return { type: types_1.ASTNodeType.UNARY_OPERATION, operator: 'not', operand };
+    }
+    return this.parsePostfix();
+}
+function parsePower() {
+    let left = this.parseUnary();
+    if (this.match(types_1.TokenType.OPERATOR, '**')) {
+        this.consume();
+        const right = this.parsePower();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator: '**', left, right };
+    }
+    return left;
+}
+function parseFactor() {
+    let left = this.parsePower();
+    while (this.match(types_1.TokenType.OPERATOR, '*') || this.match(types_1.TokenType.OPERATOR, '/') || this.match(types_1.TokenType.OPERATOR, '//') || this.match(types_1.TokenType.OPERATOR, '%')) {
+        const operator = this.consume().value;
+        const right = this.parsePower();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator, left, right };
+    }
+    return left;
+}
+function parseTerm() {
+    let left = this.parseFactor();
+    while (this.match(types_1.TokenType.OPERATOR, '+') || this.match(types_1.TokenType.OPERATOR, '-')) {
+        const operator = this.consume().value;
+        const right = this.parseFactor();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator, left, right };
+    }
+    return left;
+}
+function parseShift() {
+    let left = this.parseTerm();
+    while (this.match(types_1.TokenType.OPERATOR, '<<') || this.match(types_1.TokenType.OPERATOR, '>>')) {
+        const operator = this.consume().value;
+        const right = this.parseTerm();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator, left, right };
+    }
+    return left;
+}
+function parseBitAnd() {
+    let left = this.parseShift();
+    while (this.match(types_1.TokenType.OPERATOR, '&')) {
+        this.consume();
+        const right = this.parseShift();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator: '&', left, right };
+    }
+    return left;
+}
+function parseBitXor() {
+    let left = this.parseBitAnd();
+    while (this.match(types_1.TokenType.OPERATOR, '^')) {
+        this.consume();
+        const right = this.parseBitAnd();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator: '^', left, right };
+    }
+    return left;
+}
+function parseBitOr() {
+    let left = this.parseBitXor();
+    while (this.match(types_1.TokenType.OPERATOR, '|')) {
+        this.consume();
+        const right = this.parseBitXor();
+        left = { type: types_1.ASTNodeType.BINARY_OPERATION, operator: '|', left, right };
+    }
+    return left;
+}
+function parseComparison() {
+    let left = this.parseBitOr();
+    const operators = [];
+    const comparators = [];
+    while (true) {
+        if (this.match(types_1.TokenType.KEYWORD, 'not') && this.peek(1)?.type === types_1.TokenType.KEYWORD && this.peek(1)?.value === 'in') {
+            this.consume();
+            this.consume();
+            operators.push('not in');
+            comparators.push(this.parseBitOr());
+            continue;
+        }
+        if (this.match(types_1.TokenType.KEYWORD, 'is') && this.peek(1)?.type === types_1.TokenType.KEYWORD && this.peek(1)?.value === 'not') {
+            this.consume();
+            this.consume();
+            operators.push('is not');
+            comparators.push(this.parseBitOr());
+            continue;
+        }
+        if (this.match(types_1.TokenType.OPERATOR, '==') ||
+            this.match(types_1.TokenType.OPERATOR, '!=') ||
+            this.match(types_1.TokenType.OPERATOR, '<') ||
+            this.match(types_1.TokenType.OPERATOR, '>') ||
+            this.match(types_1.TokenType.OPERATOR, '<=') ||
+            this.match(types_1.TokenType.OPERATOR, '>=') ||
+            this.match(types_1.TokenType.KEYWORD, 'in') ||
+            this.match(types_1.TokenType.KEYWORD, 'is')) {
+            operators.push(this.consume().value);
+            comparators.push(this.parseBitOr());
+            continue;
+        }
+        break;
+    }
+    if (operators.length === 0)
+        return left;
+    return { type: types_1.ASTNodeType.COMPARE, left, ops: operators, comparators };
+}
+function parseNot() {
+    if (this.match(types_1.TokenType.KEYWORD, 'not')) {
+        this.consume();
+        const operand = this.parseNot();
+        return { type: types_1.ASTNodeType.UNARY_OPERATION, operator: 'not', operand };
+    }
+    return this.parseComparison();
+}
+function parseAnd() {
+    let left = this.parseNot();
+    while (this.match(types_1.TokenType.KEYWORD, 'and')) {
+        this.consume();
+        const right = this.parseNot();
+        left = { type: types_1.ASTNodeType.BOOL_OPERATION, operator: 'and', values: [left, right] };
+    }
+    return left;
+}
+function parseOr() {
+    let left = this.parseAnd();
+    while (this.match(types_1.TokenType.KEYWORD, 'or')) {
+        this.consume();
+        const right = this.parseAnd();
+        left = { type: types_1.ASTNodeType.BOOL_OPERATION, operator: 'or', values: [left, right] };
+    }
+    return left;
+}
+function parseIfExpression() {
+    const expr = this.parseOr();
+    if (this.match(types_1.TokenType.KEYWORD, 'if')) {
+        this.consume();
+        const test = this.parseOr();
+        this.expect(types_1.TokenType.KEYWORD, 'else');
+        const alternate = this.parseIfExpression();
+        return { type: types_1.ASTNodeType.IF_EXPRESSION, test, consequent: expr, alternate };
+    }
+    return expr;
+}
+function parseExpression() {
+    return this.parseIfExpression();
+}
+function parseExpressionNoIf() {
+    return this.parseOr();
+}
+function parseComprehension(expression) {
+    const clauses = [];
+    while (this.match(types_1.TokenType.KEYWORD, 'for')) {
+        this.consume();
+        const target = this.parseTarget();
+        this.expect(types_1.TokenType.KEYWORD, 'in');
+        const iter = this.parseExpressionNoIf();
+        const ifs = [];
+        while (this.match(types_1.TokenType.KEYWORD, 'if')) {
+            this.consume();
+            ifs.push(this.parseExpression());
+        }
+        clauses.push({ target, iter, ifs });
+    }
+    return { clauses, expression };
+}
+//# sourceMappingURL=expressions.js.map

package/dist/parser/index.d.ts

@@ -0,0 +1,2 @@
+export { Parser } from './parser';
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+//# sourceMappingURL=index.js.map

package/dist/parser/parser.d.ts

@@ -0,0 +1,63 @@
+import { Token, TokenType, ASTNode } from '../types';
+import * as Expr from './expressions';
+import * as Target from './targets';
+import * as Stmt from './statements';
+export declare class Parser {
+    tokens: Token[];
+    pos: number;
+    constructor(tokens: Token[]);
+    peek(offset?: number): Token | null;
+    consume(): Token;
+    match(type: TokenType, value?: string): boolean;
+    expect(type: TokenType, value?: string): Token;
+    skipNewlines(): void;
+    parseStringLiteral: typeof Expr.parseStringLiteral;
+    parseLiteral: typeof Expr.parseLiteral;
+    parseIdentifier: typeof Expr.parseIdentifier;
+    parseArguments: typeof Expr.parseArguments;
+    parseSlice: typeof Expr.parseSlice;
+    parsePatternAtom: typeof Expr.parsePatternAtom;
+    parsePattern: typeof Expr.parsePattern;
+    parseLambdaParameters: typeof Expr.parseLambdaParameters;
+    parseLambda: typeof Expr.parseLambda;
+    parseAtom: typeof Expr.parseAtom;
+    parsePostfix: typeof Expr.parsePostfix;
+    parsePostfixTarget: typeof Target.parsePostfixTarget;
+    parseTargetElement: typeof Target.parseTargetElement;
+    parseTarget: typeof Target.parseTarget;
+    parseUnary: typeof Expr.parseUnary;
+    parsePower: typeof Expr.parsePower;
+    parseFactor: typeof Expr.parseFactor;
+    parseTerm: typeof Expr.parseTerm;
+    parseShift: typeof Expr.parseShift;
+    parseBitAnd: typeof Expr.parseBitAnd;
+    parseBitXor: typeof Expr.parseBitXor;
+    parseBitOr: typeof Expr.parseBitOr;
+    parseComparison: typeof Expr.parseComparison;
+    parseNot: typeof Expr.parseNot;
+    parseAnd: typeof Expr.parseAnd;
+    parseOr: typeof Expr.parseOr;
+    parseIfExpression: typeof Expr.parseIfExpression;
+    parseExpression: typeof Expr.parseExpression;
+    parseExpressionNoIf: typeof Expr.parseExpressionNoIf;
+    parseComprehension: typeof Expr.parseComprehension;
+    parseExpressionStatement: typeof Stmt.parseExpressionStatement;
+    parseExpressionList: typeof Stmt.parseExpressionList;
+    parseAssignmentOrExpression: typeof Stmt.parseAssignmentOrExpression;
+    parseBlock: typeof Stmt.parseBlock;
+    parseIfStatement: typeof Stmt.parseIfStatement;
+    parseWhileStatement: typeof Stmt.parseWhileStatement;
+    parseForStatement: typeof Stmt.parseForStatement;
+    parseFunctionParameters: typeof Stmt.parseFunctionParameters;
+    parseFunctionDef: typeof Stmt.parseFunctionDef;
+    parseClassDef: typeof Stmt.parseClassDef;
+    parseDecorators: typeof Stmt.parseDecorators;
+    parseTryStatement: typeof Stmt.parseTryStatement;
+    parseWithStatement: typeof Stmt.parseWithStatement;
+    parseMatchStatement: typeof Stmt.parseMatchStatement;
+    parseImportStatement: typeof Stmt.parseImportStatement;
+    parseStatement: typeof Stmt.parseStatement;
+    parseProgram: typeof Stmt.parseProgram;
+    parse(): ASTNode;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser/parser.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const types_1 = require("../types");
+const Expr = __importStar(require("./expressions"));
+const Target = __importStar(require("./targets"));
+const Stmt = __importStar(require("./statements"));
+class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        // Expression parsing
+        this.parseStringLiteral = Expr.parseStringLiteral;
+        this.parseLiteral = Expr.parseLiteral;
+        this.parseIdentifier = Expr.parseIdentifier;
+        this.parseArguments = Expr.parseArguments;
+        this.parseSlice = Expr.parseSlice;
+        this.parsePatternAtom = Expr.parsePatternAtom;
+        this.parsePattern = Expr.parsePattern;
+        this.parseLambdaParameters = Expr.parseLambdaParameters;
+        this.parseLambda = Expr.parseLambda;
+        this.parseAtom = Expr.parseAtom;
+        this.parsePostfix = Expr.parsePostfix;
+        this.parsePostfixTarget = Target.parsePostfixTarget;
+        this.parseTargetElement = Target.parseTargetElement;
+        this.parseTarget = Target.parseTarget;
+        this.parseUnary = Expr.parseUnary;
+        this.parsePower = Expr.parsePower;
+        this.parseFactor = Expr.parseFactor;
+        this.parseTerm = Expr.parseTerm;
+        this.parseShift = Expr.parseShift;
+        this.parseBitAnd = Expr.parseBitAnd;
+        this.parseBitXor = Expr.parseBitXor;
+        this.parseBitOr = Expr.parseBitOr;
+        this.parseComparison = Expr.parseComparison;
+        this.parseNot = Expr.parseNot;
+        this.parseAnd = Expr.parseAnd;
+        this.parseOr = Expr.parseOr;
+        this.parseIfExpression = Expr.parseIfExpression;
+        this.parseExpression = Expr.parseExpression;
+        this.parseExpressionNoIf = Expr.parseExpressionNoIf;
+        this.parseComprehension = Expr.parseComprehension;
+        // Statement parsing
+        this.parseExpressionStatement = Stmt.parseExpressionStatement;
+        this.parseExpressionList = Stmt.parseExpressionList;
+        this.parseAssignmentOrExpression = Stmt.parseAssignmentOrExpression;
+        this.parseBlock = Stmt.parseBlock;
+        this.parseIfStatement = Stmt.parseIfStatement;
+        this.parseWhileStatement = Stmt.parseWhileStatement;
+        this.parseForStatement = Stmt.parseForStatement;
+        this.parseFunctionParameters = Stmt.parseFunctionParameters;
+        this.parseFunctionDef = Stmt.parseFunctionDef;
+        this.parseClassDef = Stmt.parseClassDef;
+        this.parseDecorators = Stmt.parseDecorators;
+        this.parseTryStatement = Stmt.parseTryStatement;
+        this.parseWithStatement = Stmt.parseWithStatement;
+        this.parseMatchStatement = Stmt.parseMatchStatement;
+        this.parseImportStatement = Stmt.parseImportStatement;
+        this.parseStatement = Stmt.parseStatement;
+        this.parseProgram = Stmt.parseProgram;
+        this.tokens = tokens;
+    }
+    peek(offset = 0) {
+        return this.pos + offset < this.tokens.length ? this.tokens[this.pos + offset] : null;
+    }
+    consume() {
+        if (this.pos >= this.tokens.length)
+            throw new Error('Unexpected end of input');
+        return this.tokens[this.pos++];
+    }
+    match(type, value) {
+        const token = this.peek();
+        return !!token && token.type === type && (value === undefined || token.value === value);
+    }
+    expect(type, value) {
+        const token = this.peek();
+        if (!token)
+            throw new Error(`Expected ${types_1.TokenType[type]}${value ? ` \"${value}\"` : ''}, but got end of input`);
+        if (token.type !== type) {
+            throw new Error(`Expected ${types_1.TokenType[type]}${value ? ` \"${value}\"` : ''}, but got ${types_1.TokenType[token.type]} \"${token.value}\" at line ${token.line}`);
+        }
+        if (value !== undefined && token.value !== value) {
+            throw new Error(`Expected \"${value}\", but got \"${token.value}\" at line ${token.line}`);
+        }
+        return this.consume();
+    }
+    skipNewlines() {
+        while (this.match(types_1.TokenType.NEWLINE)) {
+            this.consume();
+        }
+    }
+    parse() {
+        return this.parseProgram();
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=parser.js.map