darijacode 0.2.0

package/dist/compiler/parser.js

@@ -0,0 +1,513 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const tokens_1 = require("./tokens");
+const errors_1 = require("./errors");
+// NOTE: class parsing (jdid / this) is intentionally not implemented yet.
+// The lexer does not tokenize `this` or `jdid` as keywords, so classes
+// stay identifiers-only for now. Add THIS/JDID token types first.
+// NOTE: `dwr (item in array)` and `dwr (index, value of items)` are not
+// implemented yet either — the lexer has no IN/OF tokens. Only the
+// classic C-style `dwr (init; condition; update)` form is supported.
+const masofa = "mosfofa[hoja1, hoja2, hoja3]";
+class Parser {
+    tokens;
+    pos = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const body = [];
+        this.skipNewlines();
+        while (!this.isEnd()) {
+            body.push(this.statement());
+            this.skipNewlines();
+        }
+        return { type: "Program", body, pos: { line: 1, column: 1 } };
+    }
+    statement() {
+        this.skipNewlines();
+        const token = this.peek();
+        switch (token.type) {
+            case tokens_1.TokenType.DIR:
+                return this.variableDeclaration("dir");
+            case tokens_1.TokenType.KHLI:
+                return this.variableDeclaration("khli");
+            case tokens_1.TokenType.FN:
+                return this.functionDeclaration();
+            case tokens_1.TokenType.RAJ3:
+                return this.returnStatement();
+            case tokens_1.TokenType.ILA:
+                return this.ifStatement();
+            case tokens_1.TokenType.MAHD:
+                return this.whileStatement();
+            case tokens_1.TokenType.DWR:
+                return this.forStatement();
+            case tokens_1.TokenType.QTA3:
+                return this.breakStatement();
+            case tokens_1.TokenType.KAML:
+                return this.continueStatement();
+            case tokens_1.TokenType.KTEB:
+                return this.printStatement();
+            case tokens_1.TokenType.LBRACE:
+                return this.block();
+            default:
+                return this.expressionStatement();
+        }
+    }
+    variableDeclaration(kind) {
+        const pos = this.pos_();
+        this.advance(); // dir | khli
+        const name = this.expect(tokens_1.TokenType.IDENTF, "twa93na smya dyal mutaghayer", "DCE10").value;
+        let typeAnnotation = undefined;
+        if (this.match(tokens_1.TokenType.COLON)) {
+            typeAnnotation = this.typeAnnotation();
+        }
+        let init = null;
+        if (this.match(tokens_1.TokenType.EQUAL) || this.checkPrev(tokens_1.TokenType.COLONEQUAL)) {
+            init = this.expression();
+        }
+        else if (this.match(tokens_1.TokenType.COLONEQUAL)) {
+            init = this.expression();
+        }
+        this.consumeEOS();
+        return { type: "VariableDeclaration", kind, name, typeAnnotation, init, pos };
+    }
+    typeAnnotation() {
+        const djtype = { base: "khawi", d: 0 };
+        let type = this.expect(tokens_1.TokenType.IDENTF, "twa93na smya dyal chi naw3", "DCE10", "lanwa3 li mmkdin tdirhom : 'ra9m', 'nass', 'tona2i' awla dir khawi k9ima").value;
+        switch (type) {
+            case "ra9m":
+            case "nass":
+            case "tona2i":
+            case "khawi":
+            case "unknown":
+            case "walo":
+                djtype.base = type;
+                break;
+            default:
+                this.error(`naw3 dyal '${type}' makaynch awla mmd3omch`, "DCE15", "dir chi naw3 md3om bhal: 'ra9m', 'nass' etc ..");
+        }
+        while (this.check(tokens_1.TokenType.LBRACT)) {
+            this.advance();
+            this.expect(tokens_1.TokenType.RBRACT, "twa93na ']' mora '[' f naw3", "DCE3");
+            djtype.d = (djtype.d ?? 0) + 1;
+        }
+        return djtype;
+    }
+    params() {
+        const params = [];
+        this.expect(tokens_1.TokenType.LPAREN, "twa93na '(' 9bal mn lmo3amilat", "DCE5");
+        while (!this.check(tokens_1.TokenType.RPAREN)) {
+            const pos = this.pos_();
+            const name = this.expect(tokens_1.TokenType.IDENTF, "twa93na smya llmo3amilat", "DCE10").value;
+            let typeAnnotation = { base: "khawi", d: 0 };
+            if (this.match(tokens_1.TokenType.COLON)) {
+                typeAnnotation = this.typeAnnotation();
+            }
+            let defaultValue = null;
+            if (this.match(tokens_1.TokenType.EQUAL)) {
+                defaultValue = this.expression();
+            }
+            params.push({
+                type: "Param",
+                name,
+                typeAnnotation,
+                defaultValue,
+                rest: false,
+                pos,
+            });
+            if (!this.check(tokens_1.TokenType.RPAREN)) {
+                this.expect(tokens_1.TokenType.COMMA, "twa93nz ',' bin lmo3amilat", "DCE4");
+            }
+        }
+        this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora lmo3amilat", "DCE5");
+        return params;
+    }
+    functionDeclaration() {
+        const pos = this.pos_();
+        this.advance(); // fn
+        const name = this.expect(tokens_1.TokenType.IDENTF, "tw93na smya l ddalla", "DCE10", "fn smya(){}").value;
+        const fnParams = this.params();
+        let returnType = { base: "khawi", d: 0 };
+        if (this.match(tokens_1.TokenType.COLON)) {
+            returnType = this.typeAnnotation();
+        }
+        const body = this.block();
+        return { type: "FunctionDeclaration", name, params: fnParams, returnType: returnType ?? "khawi", body, pos };
+    }
+    returnStatement() {
+        const pos = this.pos_();
+        this.advance(); // raj3
+        let argument = null;
+        if (!this.check(tokens_1.TokenType.EOS) && !this.check(tokens_1.TokenType.RBRACE)) {
+            argument = this.expression();
+        }
+        this.consumeEOS();
+        return { type: "ReturnStatement", argument, pos };
+    }
+    ifStatement() {
+        const pos = this.pos_();
+        this.advance(); // ila
+        this.expect(tokens_1.TokenType.LPAREN, "tw93na '(' mora 'ila'", "DCE5");
+        const condition = this.expression();
+        this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' more chart", "DCE5");
+        const consequent = this.block();
+        const elseIfs = [];
+        this.skipNewlines();
+        while (this.check(tokens_1.TokenType.AWLA)) {
+            this.advance();
+            this.expect(tokens_1.TokenType.LPAREN, "twa93na '(' mora 'awla'", "DCE5");
+            const elseIfCondition = this.expression();
+            this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora chart", "DCE5");
+            const elseIfBody = this.block();
+            elseIfs.push({ condition: elseIfCondition, consequent: elseIfBody });
+            this.skipNewlines();
+        }
+        let alternate = null;
+        if (this.check(tokens_1.TokenType.WLA)) {
+            this.advance();
+            alternate = this.block();
+        }
+        return { type: "IfStatement", condition, consequent, elseIfs, alternate, pos };
+    }
+    whileStatement() {
+        const pos = this.pos_();
+        this.advance(); // mahd
+        this.expect(tokens_1.TokenType.LPAREN, "twa93na '(' mora 'mahd'", "DC5");
+        const condition = this.expression();
+        this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora chart", "DCE5");
+        const body = this.block();
+        return { type: "WhileStatement", condition, body, pos };
+    }
+    forStatement() {
+        const pos = this.pos_();
+        this.advance(); // dwr
+        this.expect(tokens_1.TokenType.LPAREN, "twa93na '(' mora 'dwr'", "DCE5");
+        let init = null;
+        if (!this.check(tokens_1.TokenType.EOS)) {
+            init = this.check(tokens_1.TokenType.DIR)
+                ? this.variableDeclaration("dir")
+                : this.expressionStatement();
+        }
+        else {
+            this.advance(); // consume the ';'
+        }
+        let condition = null;
+        if (!this.check(tokens_1.TokenType.EOS)) {
+            condition = this.expression();
+        }
+        this.expect(tokens_1.TokenType.EOS, "twa93na ';' mora chart dyal tdwar", "DCE2");
+        let update = null;
+        if (!this.check(tokens_1.TokenType.RPAREN)) {
+            update = this.expression();
+        }
+        this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora ljomla dyal 'dwr'", "DCE5");
+        const body = this.block();
+        return { type: "ForStatement", init, condition, update, body, pos };
+    }
+    breakStatement() {
+        const pos = this.pos_();
+        this.advance(); // qta3
+        this.consumeEOS();
+        return { type: "BreakStatement", pos };
+    }
+    continueStatement() {
+        const pos = this.pos_();
+        this.advance(); // kml
+        this.consumeEOS();
+        return { type: "ContinueStatement", pos };
+    }
+    printStatement() {
+        const pos = this.pos_();
+        this.advance(); // kteb
+        this.expect(tokens_1.TokenType.LPAREN, "twa93na '(' mora 'kteb'", "DCE5", "kteb(chi haja)");
+        const argument = this.expression();
+        this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora lhoja dyal kteb", "DCE5", "kteb(chi haja)");
+        this.consumeEOS();
+        return { type: "PrintStatement", argument, pos };
+    }
+    block() {
+        const pos = this.pos_();
+        this.expect(tokens_1.TokenType.LBRACE, "twa93na '{'", "DCE9", "zid '{'");
+        this.skipNewlines();
+        const body = [];
+        while (!this.check(tokens_1.TokenType.RBRACE) && !this.isEnd()) {
+            body.push(this.statement());
+            this.skipNewlines();
+        }
+        this.expect(tokens_1.TokenType.RBRACE, "twa93na '}'", "DCE9", "zid '}'");
+        return { type: "BlockStatement", body, pos };
+    }
+    expressionStatement() {
+        const pos = this.pos_();
+        const expression = this.expression();
+        this.consumeEOS();
+        return { type: "ExpressionStatement", expression, pos };
+    }
+    // ---------------------------------------------
+    // Expressions (precedence climbing)
+    // ---------------------------------------------
+    expression() {
+        return this.assignment();
+    }
+    assignment() {
+        const target = this.conditional();
+        const assignOps = {
+            [tokens_1.TokenType.EQUAL]: "=",
+        };
+        if (this.check(tokens_1.TokenType.EQUAL)) {
+            const pos = this.pos_();
+            this.advance();
+            const value = this.assignment();
+            return { type: "AssignmentExpression", operator: "=", target, value, pos };
+        }
+        return target;
+    }
+    conditional() {
+        const condition = this.logicalOr();
+        if (this.check(tokens_1.TokenType.QUESTION)) {
+            const pos = this.pos_();
+            this.advance();
+            const consequent = this.assignment();
+            this.expect(tokens_1.TokenType.COLON, "twa93na ':' f ta3bir chart tolaty", "DCE8");
+            const alternate = this.assignment();
+            return { type: "ConditionalExpression", condition, consequent, alternate, pos };
+        }
+        return condition;
+    }
+    logicalOr() {
+        let left = this.logicalAnd();
+        while (this.check(tokens_1.TokenType.OR)) {
+            const pos = this.pos_();
+            this.advance();
+            const right = this.logicalAnd();
+            left = { type: "LogicalExpression", operator: "||", left, right, pos };
+        }
+        return left;
+    }
+    logicalAnd() {
+        let left = this.equality();
+        while (this.check(tokens_1.TokenType.AND)) {
+            const pos = this.pos_();
+            this.advance();
+            const right = this.equality();
+            left = { type: "LogicalExpression", operator: "&&", left, right, pos };
+        }
+        return left;
+    }
+    equality() {
+        let left = this.relational();
+        while (this.check(tokens_1.TokenType.EQEQ) || this.check(tokens_1.TokenType.NOTEQ)) {
+            const pos = this.pos_();
+            const operator = this.advance().type === tokens_1.TokenType.EQEQ ? "==" : "!=";
+            const right = this.relational();
+            left = { type: "BinaryExpression", operator, left, right, pos };
+        }
+        return left;
+    }
+    relational() {
+        let left = this.additive();
+        while (this.check(tokens_1.TokenType.LT) ||
+            this.check(tokens_1.TokenType.LTEQ) ||
+            this.check(tokens_1.TokenType.GT) ||
+            this.check(tokens_1.TokenType.GTEQ)) {
+            const pos = this.pos_();
+            const opToken = this.advance();
+            const operator = { LT: "<", LTEQ: "<=", GT: ">", GTEQ: ">=" }[opToken.type];
+            const right = this.additive();
+            left = { type: "BinaryExpression", operator, left, right, pos };
+        }
+        return left;
+    }
+    additive() {
+        let left = this.multiplicative();
+        while (this.check(tokens_1.TokenType.PLUS) || this.check(tokens_1.TokenType.MINUS)) {
+            const pos = this.pos_();
+            const operator = this.advance().type === tokens_1.TokenType.PLUS ? "+" : "-";
+            const right = this.multiplicative();
+            left = { type: "BinaryExpression", operator, left, right, pos };
+        }
+        return left;
+    }
+    multiplicative() {
+        let left = this.power();
+        while (this.check(tokens_1.TokenType.STAR) ||
+            this.check(tokens_1.TokenType.SLASH) ||
+            this.check(tokens_1.TokenType.PERCENT)) {
+            const pos = this.pos_();
+            const opToken = this.advance();
+            const operator = { STAR: "*", SLASH: "/", PERCENT: "%" }[opToken.type];
+            const right = this.power();
+            left = { type: "BinaryExpression", operator, left, right, pos };
+        }
+        return left;
+    }
+    power() {
+        const left = this.unary();
+        if (this.check(tokens_1.TokenType.POWER)) {
+            const pos = this.pos_();
+            this.advance();
+            const right = this.power(); // right-associative
+            return { type: "BinaryExpression", operator: "**", left, right, pos };
+        }
+        return left;
+    }
+    unary() {
+        if (this.check(tokens_1.TokenType.NOT) || this.check(tokens_1.TokenType.MINUS)) {
+            const pos = this.pos_();
+            const operator = this.advance().type === tokens_1.TokenType.NOT ? "!" : "-";
+            const argument = this.unary();
+            return { type: "UnaryExpression", operator, argument, pos };
+        }
+        return this.postfix();
+    }
+    postfix() {
+        let expr = this.call();
+        if (this.check(tokens_1.TokenType.PLUSPLUS) || this.check(tokens_1.TokenType.MINUSMINUS)) {
+            const pos = this.pos_();
+            const operator = this.advance().type === tokens_1.TokenType.PLUSPLUS ? "++" : "--";
+            expr = { type: "UpdateExpression", operator, argument: expr, prefix: false, pos };
+        }
+        return expr;
+    }
+    call() {
+        let expr = this.primary();
+        while (true) {
+            if (this.check(tokens_1.TokenType.LPAREN)) {
+                const pos = this.pos_();
+                this.advance();
+                const args = [];
+                while (!this.check(tokens_1.TokenType.RPAREN)) {
+                    args.push(this.expression());
+                    if (!this.check(tokens_1.TokenType.RPAREN)) {
+                        this.expect(tokens_1.TokenType.COMMA, "twa93na ',' bin lhojaj", "DCE4", masofa);
+                    }
+                }
+                this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora lhojaj", "DCE5");
+                expr = { type: "CallExpression", callee: expr, args, pos };
+            }
+            else if (this.check(tokens_1.TokenType.DOT)) {
+                const pos = this.pos_();
+                this.advance();
+                const property = this.expect(tokens_1.TokenType.IDENTF, "twa93na smya dyal lkhasiya mora '.'", "DCE7").value;
+                expr = {
+                    type: "MemberExpression",
+                    object: expr,
+                    property: { type: "Identifier", name: property, pos },
+                    computed: false,
+                    pos,
+                };
+            }
+            else if (this.check(tokens_1.TokenType.LBRACT)) {
+                const pos = this.pos_();
+                this.advance();
+                const property = this.expression();
+                this.expect(tokens_1.TokenType.RBRACT, "twa93na ']' mora lfahras", "DCE3", "mosfofa[ra9m]");
+                expr = { type: "MemberExpression", object: expr, property, computed: true, pos };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    primary() {
+        const token = this.peek();
+        const pos = this.pos_();
+        if (this.match(tokens_1.TokenType.NUMBER)) {
+            return { type: "NumericLiteral", value: Number(token.value), pos };
+        }
+        if (this.match(tokens_1.TokenType.STRING)) {
+            return { type: "StringLiteral", value: token.value, pos };
+        }
+        if (this.match(tokens_1.TokenType.TRUE)) {
+            return { type: "BooleanLiteral", value: true, pos };
+        }
+        if (this.match(tokens_1.TokenType.FALSE)) {
+            return { type: "BooleanLiteral", value: false, pos };
+        }
+        if (this.match(tokens_1.TokenType.NULL)) {
+            return { type: "NullLiteral", pos };
+        }
+        if (this.match(tokens_1.TokenType.IDENTF)) {
+            return { type: "Identifier", name: token.value, pos };
+        }
+        if (this.match(tokens_1.TokenType.LPAREN)) {
+            const expr = this.expression();
+            this.expect(tokens_1.TokenType.RPAREN, "twa93na ')' mora tta3bir", "DCE5");
+            return expr;
+        }
+        if (this.match(tokens_1.TokenType.LBRACT)) {
+            const elements = [];
+            while (!this.check(tokens_1.TokenType.RBRACT)) {
+                elements.push(this.expression());
+                if (!this.check(tokens_1.TokenType.RBRACT)) {
+                    this.expect(tokens_1.TokenType.COMMA, "twa93na ',' bin l3anasir dyal lmasfofa", "DCE4", masofa);
+                }
+            }
+            this.expect(tokens_1.TokenType.RBRACT, "twa93na ']' mora l3anasir dyal lmasfofa", "DCE3", masofa);
+            return { type: "ArrayExpression", elements, pos };
+        }
+        if (token.value === "\\n") {
+            this.error(`token mmtw93ach: 'star jdid'`, "DCE1");
+        }
+        this.error(`token mmtw93ach: '${token.value}'`, "DCE1");
+    }
+    consumeEOS() {
+        this.skipNewlines();
+        this.expect(tokens_1.TokenType.EOS, "twa93na ';'", "DCE2");
+    }
+    skipNewlines() {
+        while (this.check(tokens_1.TokenType.NEWLINE)) {
+            this.advance();
+        }
+    }
+    peek(offset = 0) {
+        return this.tokens[this.pos + offset];
+    }
+    check(type) {
+        return this.peek().type === type;
+    }
+    checkPrev(type) {
+        return this.tokens[this.pos - 1]?.type === type;
+    }
+    match(type) {
+        if (!this.check(type))
+            return false;
+        this.advance();
+        return true;
+    }
+    advance() {
+        const token = this.tokens[this.pos];
+        if (!this.isEnd())
+            this.pos++;
+        return token;
+    }
+    expect(type, message, ecode, hint) {
+        if (this.check(type))
+            return this.advance();
+        this.error(message, ecode, hint);
+    }
+    isEnd() {
+        return this.peek().type === tokens_1.TokenType.EOF;
+    }
+    pos_() {
+        const token = this.peek();
+        return { line: token.line, column: token.column };
+    }
+    error(message, ecode, hint) {
+        const token = this.peek();
+        throw new errors_1.DarijaError({
+            code: ecode,
+            stage: "parser",
+            message,
+            location: {
+                line: token.line,
+                column: token.column
+            },
+            hint: hint ? hint : ''
+        });
+    }
+}
+exports.Parser = Parser;

package/dist/compiler/tokens.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    // literals
+    TokenType["IDENTF"] = "IDENTF";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["TRUE"] = "TRUE";
+    TokenType["FALSE"] = "FALSE";
+    TokenType["NULL"] = "NULL";
+    // declarations
+    TokenType["DIR"] = "DIR";
+    TokenType["KHLI"] = "KHLI";
+    // functions
+    TokenType["FN"] = "FN";
+    TokenType["RAJ3"] = "RAJ3";
+    // control flow
+    TokenType["ILA"] = "ILA";
+    TokenType["AWLA"] = "AWLA";
+    TokenType["WLA"] = "WLA";
+    TokenType["MAHD"] = "MAHD";
+    TokenType["DWR"] = "DWR";
+    TokenType["QTA3"] = "QTA3";
+    TokenType["KAML"] = "KAML";
+    // classes
+    TokenType["CLASS"] = "CLASS";
+    TokenType["DIRFLBLASA"] = "DIRFLBLASA";
+    TokenType["WRAATMN"] = "WRAATMN";
+    // built-in I/O
+    TokenType["KTEB"] = "KTEB";
+    // punctuation
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["LBRACT"] = "LBRACT";
+    TokenType["RBRACT"] = "RBRACT";
+    TokenType["DOT"] = "DOT";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["EOS"] = "EOS";
+    // operators
+    TokenType["PLUS"] = "PLUS";
+    TokenType["PLUSPLUS"] = "PLUSPLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["MINUSMINUS"] = "MINUSMINUS";
+    TokenType["STAR"] = "STAR";
+    TokenType["POWER"] = "POWER";
+    TokenType["SLASH"] = "SLASH";
+    TokenType["PERCENT"] = "PERCENT";
+    TokenType["EQUAL"] = "EQUAL";
+    TokenType["EQEQ"] = "EQEQ";
+    TokenType["NOT"] = "NOT";
+    TokenType["NOTEQ"] = "NOTEQ";
+    TokenType["LT"] = "LT";
+    TokenType["LTEQ"] = "LTEQ";
+    TokenType["GT"] = "GT";
+    TokenType["GTEQ"] = "GTEQ";
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["COLON"] = "COLON";
+    TokenType["COLONEQUAL"] = "COLONEQUAL";
+    // structural
+    TokenType["NEWLINE"] = "NEWLINE";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (exports.TokenType = TokenType = {}));

package/dist/utils/showType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showType = showType;
+exports.isType = isType;
+function showType(type) {
+    return type.d ? type.base + "[]".repeat(type.d) : type.base;
+}
+function isType(type, base, d = 0) {
+    return type.base === base && type.d === d;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "darijacode",
+  "version": "0.2.0",
+  "description": "A new programming languages based on Moroccan words to let people on morocco learn programming fast without need to english or learn advanced concepts",
+  "keywords": [
+    "DarijaCode",
+    "programming",
+    "language",
+    "morocco"
+  ],
+  "homepage": "https://github.com/krnl0xsns1nk/DarijaCode#readme",
+  "bugs": {
+    "url": "https://github.com/krnl0xsns1nk/DarijaCode/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krnl0xsns1nk/DarijaCode.git"
+  },
+  "license": "DCL",
+  "author": "krnl0xsns1nk",
+  "type": "commonJs",
+  "main": "compiler/index.js",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "bin": {
+    "drj": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run setup",
+    "build": "tsc && tsc-alias && chmod +x dist/cli.js",
+    "start": "node dist/compiler/index.js",
+    "dev": "ts-node -r tsconfig-paths/register src/compiler/index.ts",
+    "now": "scripts/run.sh",
+    "setup": "npm run build && npm link",
+    "test": "ts-node -r tsconfig-paths/register scripts/test.ts all",
+    "test:update": "ts-node -r tsconfig-paths/register scripts/test.ts all --update",
+    "test:lexer": "ts-node scripts/test.ts lexer",
+    "test:parser": "ts-node scripts/test.ts parser",
+    "test:checker": "ts-node scripts/test.ts checker",
+    "test:compiler": "ts-node scripts/test.ts compiler",
+    "test:runtime": "ts-node scripts/test.ts runtime",
+    "test:errors": "ts-node scripts/test.ts errors"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.9.0",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^6.0.3",
+    "typescript-language-server": "^5.3.0"
+  }
+}