jpsx 0.1.16

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { tokenize } from "../lexer/tokenizer.js";
+import { parse } from "../parser/parser.js";
+import { transform } from "../transformer/transformer.js";
+import { generate } from "../generator/generator.js";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const program = new Command();
+program
+    .name("jps")
+    .description("JPS (Just Python Script) Compiler CLI")
+    .version("0.1.0");
+function getRuntimePath() {
+    // Assuming structure: dist/cli/index.js
+    // Runtime: dist/runtime/index.js
+    return path.resolve(__dirname, "../runtime/index.js");
+}
+function printCodeFrame(code, line, col) {
+    const lines = code.split("\n");
+    const startObj = Math.max(0, line - 3);
+    const endObj = Math.min(lines.length, line + 2);
+    for (let i = startObj; i < endObj; i++) {
+        const lineNum = i + 1;
+        const isErrorLine = lineNum === line;
+        const gutter = isErrorLine ? "> " : "  ";
+        const lineStr = lines[i];
+        console.error(chalk.gray(`${gutter}${lineNum} | `) + lineStr);
+        if (isErrorLine) {
+            const pad = " ".repeat(String(lineNum).length + 3 + (col - 1));
+            console.error(chalk.red(`${pad}^`));
+        }
+    }
+}
+function compileFile(inputFile, outputFile, quiet = false) {
+    if (!fs.existsSync(inputFile)) {
+        console.error(chalk.red(`Error: File '${inputFile}' not found.`));
+        process.exit(1);
+    }
+    const code = fs.readFileSync(inputFile, "utf-8");
+    try {
+        const tokens = tokenize(code);
+        const ast = parse(tokens);
+        const transformed = transform(ast);
+        const js = generate(transformed);
+        const target = outputFile || inputFile.replace(/\.jps$/, ".js");
+        fs.writeFileSync(target, js);
+        // Copy Runtime
+        const runtimeSrc = getRuntimePath();
+        const runtimeDest = path.join(path.dirname(target), "jps_runtime.js");
+        if (!fs.existsSync(runtimeSrc)) {
+            // Try finding it in dist
+            const altRuntime = path.resolve(__dirname, "../../dist/runtime/index.js");
+            if (fs.existsSync(altRuntime)) {
+                fs.copyFileSync(altRuntime, runtimeDest);
+            }
+            else {
+                // If not found, maybe we are running from src via ts-node? 
+                // But valid install should have dist.
+                if (!quiet)
+                    console.warn(chalk.yellow("Warning: Runtime not found. Build the project first."));
+            }
+        }
+        else {
+            fs.copyFileSync(runtimeSrc, runtimeDest);
+        }
+        if (!quiet) {
+            console.log(chalk.green(`Compiled: ${inputFile} -> ${target}`));
+        }
+        return target;
+    }
+    catch (e) {
+        console.error(chalk.red("Compilation Failed:"));
+        if (e.token) { // Nearley error
+            console.error(chalk.red(`Syntax Error at line ${e.token.line}, col ${e.token.col}: Unexpected token '${e.token.value}'`));
+            printCodeFrame(code, e.token.line, e.token.col);
+        }
+        else if (e.message) {
+            console.error(chalk.red(e.message));
+        }
+        else {
+            console.error(e);
+        }
+        process.exit(1);
+    }
+}
+program.command("build")
+    .argument("<file>", "JPS source file")
+    .option("-o, --out <file>", "Output file path")
+    .description("Compile a JPS file to JavaScript")
+    .action((file, options) => {
+    compileFile(file, options.out);
+});
+program.command("run")
+    .argument("<file>", "JPS source file")
+    .description("Compile and run a JPS file")
+    .action((file) => {
+    const jsFile = compileFile(file, undefined, true);
+    try {
+        // Run node
+        execSync(`node "${jsFile}"`, { stdio: "inherit" });
+    }
+    catch (e) {
+        process.exit(1);
+    }
+});
+program.command("watch")
+    .argument("<file>", "JPS source file")
+    .description("Watch file and recompile on changes")
+    .action((file) => {
+    console.log(chalk.blue(`Watching ${file}...`));
+    compileFile(file); // Initial compile
+    fs.watchFile(file, { interval: 1000 }, () => {
+        console.log(chalk.blue("Change detected. Recompiling..."));
+        compileFile(file);
+    });
+});
+program.command("init")
+    .argument("[name]", "Project name")
+    .description("Initialize a new JPS project")
+    .action((name) => {
+    const projectName = name || "jps-project";
+    if (!fs.existsSync(projectName)) {
+        fs.mkdirSync(projectName);
+    }
+    const sampleCode = `print("Hello JPS!")\n`;
+    fs.writeFileSync(path.join(projectName, "main.jps"), sampleCode);
+    console.log(chalk.green(`Initialize project '${projectName}' with main.jps`));
+});
+program.command("doctor")
+    .description("Check JPS environment")
+    .action(() => {
+    console.log(chalk.bold("JPS Doctor"));
+    console.log("OS: " + process.platform);
+    console.log("Node Version: " + process.version);
+    const runtimePath = getRuntimePath();
+    // Check local or alternate for verify
+    let found = fs.existsSync(runtimePath);
+    if (!found) {
+        const altRuntime = path.resolve(__dirname, "../../dist/runtime/index.js");
+        found = fs.existsSync(altRuntime);
+    }
+    if (found) {
+        console.log(chalk.green("Runtime Library: Found"));
+    }
+    else {
+        console.log(chalk.red("Runtime Library: MISSING"));
+    }
+});
+program.parse();

package/dist/cli.js

@@ -0,0 +1,30 @@
+import { tokenize } from "./lexer/tokenizer.js";
+import { parse } from "./parser/parser.js";
+import { transform } from "./transformer/transformer.js";
+import { generate } from "./generator/generator.js";
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, extname, join } from "node:path";
+function build(inputPath) {
+    const source = readFileSync(inputPath, "utf-8");
+    const tokens = tokenize(source);
+    console.log("Tokens:", JSON.stringify(tokens, null, 2));
+    const ast = parse(tokens);
+    const transformed = transform(ast);
+    const output = generate(transformed);
+    const outputPath = join(dirname(inputPath), `${basenameWithoutExt(inputPath)}.js`);
+    writeFileSync(outputPath, output, "utf-8");
+    console.log(`Wrote ${outputPath}`);
+}
+function basenameWithoutExt(path) {
+    const ext = extname(path);
+    if (!ext) {
+        return path;
+    }
+    return path.slice(0, -ext.length).split(/[\\/]/).pop();
+}
+const args = process.argv.slice(2);
+if (args.length !== 2 || args[0] !== "build") {
+    console.log("Usage: jps build <file.jps>");
+    process.exit(1);
+}
+build(args[1]);

package/dist/generator/generator.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "../ast/types.js";
+export declare function generate(program: Program): string;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/generator/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAuE,MAAM,iBAAiB,CAAC;AA4E/G,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGjD"}

package/dist/generator/generator.js

@@ -0,0 +1,175 @@
+function generateStatement(statement, indent = 0) {
+    const pad = "  ".repeat(indent);
+    switch (statement.type) {
+        case "FunctionDeclaration": {
+            const params = statement.params.join(", ");
+            const body = statement.body.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            return `${pad}function ${statement.name}(${params}) {\n${body}\n${pad}}`;
+        }
+        case "ForStatement": {
+            if (statement.collection) {
+                const collection = generateExpression(statement.collection);
+                const body = statement.body.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+                return `${pad}for (const ${statement.iterator} of ${collection}) {\n${body}\n${pad}}`;
+            }
+            const start = generateExpression(statement.start);
+            const end = generateExpression(statement.end);
+            const body = statement.body.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            return `${pad}for (let ${statement.iterator} = ${start}; ${statement.iterator} < ${end}; ${statement.iterator}++) {\n${body}\n${pad}}`;
+        }
+        case "WhileStatement": {
+            const test = generateExpression(statement.test);
+            const body = statement.body.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            return `${pad}while (${test}) {\n${body}\n${pad}}`;
+        }
+        case "IfStatement": {
+            const test = generateExpression(statement.test);
+            const consequent = statement.consequent.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            let code = `${pad}if (${test}) {\n${consequent}\n${pad}}`;
+            if (statement.alternate) {
+                const alternate = statement.alternate.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+                code += ` else {\n${alternate}\n${pad}}`;
+            }
+            return code;
+        }
+        case "ExpressionStatement": {
+            const expression = statement.expression;
+            if (expression.type === "BinaryExpression" && expression.operator === "=" && expression.left.type === "Identifier") {
+                return `${pad}var ${generateExpression(expression.left)} = ${generateExpression(expression.right)};`;
+            }
+            const expr = generateExpression(statement.expression);
+            return `${pad}${expr};`;
+        }
+        case "ReturnStatement": {
+            if (statement.argument) {
+                return `${pad}return ${generateExpression(statement.argument)};`;
+            }
+            return `${pad}return;`;
+        }
+        case "ClassDeclaration": {
+            const body = statement.body.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            // Hack to remove 'function' keyword for methods in class body
+            const classBody = body.replace(/function\s+/g, "");
+            // Note: This is a weak hack. But simpler than refactoring generator.
+            const extendsClause = statement.superClass ? ` extends ${statement.superClass}` : "";
+            return `${pad}class ${statement.name}${extendsClause} {\n${classBody}\n${pad}}`;
+        }
+        case "TryStatement": {
+            const block = statement.block.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            const handler = statement.handler.map((stmt) => generateStatement(stmt, indent + 1)).join("\n");
+            return `${pad}try {\n${block}\n${pad}} catch (e) {\n${handler}\n${pad}}`;
+        }
+        case "ImportDeclaration": {
+            const { source, specifiers } = statement;
+            const specs = specifiers.map(s => s.local === s.imported ? s.local : `${s.imported} as ${s.local}`).join(", ");
+            return `${pad}import { ${specs} } from "${source}";`;
+        }
+        case "ExportDeclaration": {
+            return `${pad}export ${generateStatement(statement.declaration, 0)}`;
+        }
+        default:
+            return "";
+    }
+}
+export function generate(program) {
+    const RUNTIME_IMPORT = `import { print, len, range, sum, min, max, sorted, str, int, float, map, filter, list, __in__ } from "jps/runtime";\n\n`;
+    return RUNTIME_IMPORT + program.body.map((s) => generateStatement(s)).join("\n\n") + "\n";
+}
+function generateExpression(expression) {
+    if (!expression)
+        return "";
+    switch (expression.type) {
+        case "BooleanLiteral":
+            return expression.value ? "true" : "false";
+        case "ArrayLiteral":
+            const elements = expression.elements.map(generateExpression).join(", ");
+            return `[${elements}]`;
+        case "ObjectLiteral":
+            const properties = expression.properties.map((p) => `"${p.key}": ${generateExpression(p.value)}`).join(", ");
+            return `{${properties}}`;
+        case "Identifier":
+            return expression.name;
+        case "NumberLiteral":
+            return String(expression.value);
+        case "StringLiteral":
+            return JSON.stringify(expression.value);
+        case "FStringLiteral": {
+            const parts = expression.value.split(/\{([^}]+)\}/);
+            const segments = parts.map((part, index) => {
+                if (index % 2 === 0)
+                    return JSON.stringify(part); // String literal
+                // Transform common Python methods that might be in f-string expressions
+                let expr = part;
+                expr = expr.replace(/\.lower\(\)/g, ".toLowerCase()");
+                expr = expr.replace(/\.upper\(\)/g, ".toUpperCase()");
+                expr = expr.replace(/\.strip\(\)/g, ".trim()");
+                return `(${expr})`; // Expression interpolation
+            });
+            return segments.join(" + ");
+        }
+        case "BinaryExpression": {
+            const left = generateExpression(expression.left);
+            const right = generateExpression(expression.right);
+            let operator = expression.operator;
+            // Map Python operators to JS
+            if (operator === "and")
+                operator = "&&";
+            if (operator === "or")
+                operator = "||";
+            if (operator === "not")
+                operator = "!";
+            // not in / in handling? 'in' keyword?
+            // For now assume simple mapping or pre-handled by transformer
+            // JS 'in' operator exists but 'not in' needs !(... in ...)
+            // But Array.includes is better for arrays. 'in' is for objects.
+            // JPS 'in' is likely Array/Iterable includes.
+            // We should probably emit helper for 'in' if possible.
+            // But standard 'in' operator works for keys.
+            // Let's stick to literal operator for now unless we see issues.
+            // Actually, 'in' in Python is values, 'in' in JS is keys. 
+            // We might need a runtime helper `__in__(val, obj)`.
+            return `${left} ${operator} ${right}`;
+        }
+        case "UnaryExpression": {
+            const argument = generateExpression(expression.argument);
+            return `${expression.operator}(${argument})`; // Add parens for safety
+        }
+        case "ConditionalExpression": {
+            const test = generateExpression(expression.test);
+            const consequent = generateExpression(expression.consequent);
+            const alternate = generateExpression(expression.alternate);
+            return `(${test} ? ${consequent} : ${alternate})`;
+        }
+        case "CallExpression": {
+            const callee = generateExpression(expression.callee);
+            const args = expression.args.map(generateExpression).join(", ");
+            return `${callee}(${args})`;
+        }
+        case "NewExpression": {
+            const callee = generateExpression(expression.callee);
+            const args = expression.args.map(generateExpression).join(", ");
+            return `new ${callee}(${args})`;
+        }
+        case "ListComprehension": {
+            const expr = generateExpression(expression.expression);
+            const iterator = expression.iterator;
+            const collection = generateExpression((expression.collection || expression.start)); // fallback
+            const test = expression.test ? `if (${generateExpression(expression.test)}) ` : "";
+            // If collection is not defined (old range style with start/end), handle it?
+            // Grammar update removed start/end. So collection is mandatory.
+            return `(() => { const res = []; for (const ${iterator} of ${collection}) { ${test}res.push(${expr}); } return res; })()`;
+        }
+        case "MemberExpression": {
+            const obj = generateExpression(expression.object);
+            const computed = expression.computed;
+            const prop = computed ? generateExpression(expression.property) : expression.property.name;
+            return computed ? `${obj}[${prop}]` : `${obj}.${prop}`;
+        }
+        case "LambdaExpression": {
+            const params = expression.params.join(", ");
+            return `(${params}) => ${generateExpression(expression.body)}`;
+        }
+        default:
+            return "";
+    }
+}

package/dist/lexer/lexer.d.ts

@@ -0,0 +1,3 @@
+import moo from 'moo';
+export declare const lexer: moo.Lexer;
+//# sourceMappingURL=lexer.d.ts.map

package/dist/lexer/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../src/lexer/lexer.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,KAAK,WAqBhB,CAAC"}

package/dist/lexer/lexer.js

@@ -0,0 +1,23 @@
+import moo from 'moo';
+export const lexer = moo.compile({
+    ws: { match: /[ \t]+/, type: (text) => 'ws' },
+    nl: { match: /\r?\n/, lineBreaks: true },
+    lparen: '(',
+    rparen: ')',
+    string: /" (?:\\["\\]|[^\n"\\])* "/,
+    number: /0|[1-9][0-9]*/,
+    keyword: ['def', 'if', 'else', 'for', 'in', 'return', 'let', 'const', 'var', 'while'], // Added common keywords
+    identifier: {
+        match: /[a-zA-Z_][a-zA-Z0-9_]*/, type: moo.keywords({
+            def: 'def',
+            if: 'if',
+            else: 'else',
+            for: 'for',
+            in: 'in',
+            return: 'return'
+        })
+    },
+    operator: ['+', '-', '*', '/', '<', '>', '==', '='],
+    comma: ',',
+    colon: ':',
+});

package/dist/lexer/tokenizer.d.ts

@@ -0,0 +1,9 @@
+export type TokenType = "INDENT" | "DEDENT" | "NEWLINE" | "DEF" | "IF" | "ELSE" | "FOR" | "IN" | "RANGE" | "RETURN" | "DEF" | "CLASS" | "TRY" | "EXCEPT" | "LAMBDA" | "IMPORT" | "FROM" | "NOT" | "AND" | "OR" | "EXPORT" | "AS" | "IDENT" | "NUMBER" | "STRING" | "FSTRING" | "LPAREN" | "RPAREN" | "COLON" | "COMMA" | "OP" | "LBRACKET" | "RBRACKET" | "TRUE" | "FALSE" | "LBRACE" | "RBRACE" | "WHILE" | "DOT";
+export type Token = {
+    type: TokenType;
+    value?: string;
+    line: number;
+    column: number;
+};
+export declare function tokenize(source: string): Token[];
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lexer/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../src/lexer/tokenizer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,KAAK,GACL,IAAI,GACJ,MAAM,GACN,KAAK,GACL,IAAI,GACJ,OAAO,GACP,QAAQ,GACR,KAAK,GACL,OAAO,GACP,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,KAAK,GACL,KAAK,GACL,IAAI,GACJ,QAAQ,GACR,IAAI,GACJ,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,IAAI,GACJ,UAAU,GACV,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,KAAK,CAAC;AAEV,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqCF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CAyOhD"}

package/dist/lexer/tokenizer.js

@@ -0,0 +1,240 @@
+// Keywords map directly to token types.
+const keywords = {
+    def: "DEF",
+    if: "IF",
+    else: "ELSE",
+    for: "FOR",
+    in: "IN",
+    range: "RANGE",
+    return: "RETURN",
+    or: "OR",
+    and: "AND",
+    not: "NOT",
+    true: "TRUE",
+    false: "FALSE",
+    True: "TRUE",
+    False: "FALSE",
+    while: "WHILE",
+    class: "CLASS",
+    try: "TRY",
+    except: "EXCEPT",
+    lambda: "LAMBDA",
+    import: "IMPORT",
+    from: "FROM",
+    export: "EXPORT",
+    as: "AS",
+};
+// Supported operators for simple expressions.
+const operators = ["+", "-", "*", "/", "<", ">", "==", "=", "%", "<=", ">=", "!=", "+=", "-=", "*=", "/="];
+const isAlpha = (ch) => /[A-Za-z_]/.test(ch);
+const isAlphaNumeric = (ch) => /[A-Za-z0-9_]/.test(ch);
+const isDigit = (ch) => /[0-9]/.test(ch);
+// Convert source code into a flat token stream with INDENT/DEDENT markers.
+export function tokenize(source) {
+    const tokens = [];
+    const lines = source.replace(/\r\n/g, "\n").split("\n");
+    const indentStack = [0];
+    let inMultilineString = false;
+    let multilineStringValue = "";
+    let multilineStartLine = 0;
+    let multilineStartCol = 0;
+    lines.forEach((lineText, lineIndex) => {
+        const lineNumber = lineIndex + 1;
+        let i = 0;
+        // --- State: Inside Multiline String ---
+        if (inMultilineString) {
+            const closingIndex = lineText.indexOf('"""');
+            if (closingIndex !== -1) {
+                // Found closing delimiter
+                multilineStringValue += lineText.slice(0, closingIndex);
+                tokens.push({ type: "STRING", value: multilineStringValue, line: multilineStartLine, column: multilineStartCol });
+                inMultilineString = false;
+                multilineStringValue = "";
+                i = closingIndex + 3; // Resume processing after """
+            }
+            else {
+                // No closing delimiter, consume entire line
+                multilineStringValue += lineText + "\n";
+                return; // Proceed to next line (don't add NEWLINE token for inside of string)
+            }
+        }
+        else {
+            // --- State: Normal (Start of Line) ---
+            // 1. Skip empty lines (only if not inside multiline string)
+            if (lineText.trim().length === 0) {
+                return;
+            }
+            // 2. Skip full-line comments
+            if (lineText.trim().startsWith("#")) {
+                return;
+            }
+            // 3. Handle Indentation
+            const indentMatch = lineText.match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0].length : 0;
+            i = indent; // Start processing after indentation
+            if (indent > indentStack[indentStack.length - 1]) {
+                indentStack.push(indent);
+                tokens.push({ type: "INDENT", line: lineNumber, column: 1 });
+            }
+            else {
+                while (indent < indentStack[indentStack.length - 1]) {
+                    indentStack.pop();
+                    tokens.push({ type: "DEDENT", line: lineNumber, column: 1 });
+                }
+            }
+        }
+        // --- Tokenization Loop ---
+        while (i < lineText.length) {
+            const char = lineText[i];
+            // Skip whitespace
+            if (char === " " || char === "\t") {
+                i += 1;
+                continue;
+            }
+            // Handle F-String
+            if (char === 'f' && lineText[i + 1] === '"') {
+                let start = i + 2;
+                i += 2;
+                while (i < lineText.length && lineText[i] !== '"') {
+                    i += 1;
+                }
+                const value = lineText.slice(start, i);
+                i += 1;
+                tokens.push({ type: "FSTRING", value, line: lineNumber, column: start - 1 });
+                continue;
+            }
+            // Handle Multiline String Start
+            if (lineText.slice(i, i + 3) === '"""') {
+                inMultilineString = true;
+                multilineStartLine = lineNumber;
+                multilineStartCol = i + 1;
+                multilineStringValue = "";
+                i += 3;
+                // Try to find closing on same line
+                const remainder = lineText.slice(i);
+                const closingIndex = remainder.indexOf('"""');
+                if (closingIndex !== -1) {
+                    multilineStringValue = remainder.slice(0, closingIndex);
+                    tokens.push({ type: "STRING", value: multilineStringValue, line: multilineStartLine, column: multilineStartCol });
+                    inMultilineString = false;
+                    multilineStringValue = "";
+                    i += closingIndex + 3;
+                }
+                else {
+                    multilineStringValue += remainder + "\n";
+                    return; // Stop processing this line, iterate to next
+                }
+                continue;
+            }
+            // Handle Inline Comments
+            if (char === '#') {
+                break; // Stop handling this line (ignore rest)
+            }
+            if (isAlpha(char)) {
+                let start = i;
+                i += 1;
+                while (i < lineText.length && isAlphaNumeric(lineText[i])) {
+                    i += 1;
+                }
+                const text = lineText.slice(start, i);
+                const keyword = keywords[text];
+                if (keyword) {
+                    tokens.push({ type: keyword, line: lineNumber, column: start + 1 });
+                }
+                else {
+                    tokens.push({ type: "IDENT", value: text, line: lineNumber, column: start + 1 });
+                }
+                continue;
+            }
+            if (isDigit(char)) {
+                let start = i;
+                i += 1;
+                while (i < lineText.length && isDigit(lineText[i])) {
+                    i += 1;
+                }
+                if (i < lineText.length && lineText[i] === ".") {
+                    i += 1;
+                    while (i < lineText.length && isDigit(lineText[i])) {
+                        i += 1;
+                    }
+                }
+                tokens.push({ type: "NUMBER", value: lineText.slice(start, i), line: lineNumber, column: start + 1 });
+                continue;
+            }
+            if (char === '"') {
+                let start = i + 1;
+                i += 1;
+                while (i < lineText.length && lineText[i] !== '"') {
+                    i += 1;
+                }
+                const value = lineText.slice(start, i);
+                i += 1;
+                tokens.push({ type: "STRING", value, line: lineNumber, column: start });
+                continue;
+            }
+            if (char === "(") {
+                tokens.push({ type: "LPAREN", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === ")") {
+                tokens.push({ type: "RPAREN", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === ":") {
+                tokens.push({ type: "COLON", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === ",") {
+                tokens.push({ type: "COMMA", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === ".") {
+                tokens.push({ type: "DOT", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === "[") {
+                tokens.push({ type: "LBRACKET", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === "]") {
+                tokens.push({ type: "RBRACKET", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === "{") {
+                tokens.push({ type: "LBRACE", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            if (char === "}") {
+                tokens.push({ type: "RBRACE", line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            const twoChar = lineText.slice(i, i + 2);
+            if (operators.includes(twoChar)) {
+                tokens.push({ type: "OP", value: twoChar, line: lineNumber, column: i + 1 });
+                i += 2;
+                continue;
+            }
+            if (operators.includes(char)) {
+                tokens.push({ type: "OP", value: char, line: lineNumber, column: i + 1 });
+                i += 1;
+                continue;
+            }
+            throw new Error(`Unexpected character '${char}' at ${lineNumber}:${i + 1}`);
+        }
+        tokens.push({ type: "NEWLINE", line: lineNumber, column: lineText.length + 1 });
+    });
+    while (indentStack.length > 1) {
+        indentStack.pop();
+        tokens.push({ type: "DEDENT", line: lines.length, column: 1 });
+    }
+    return tokens;
+}