mimo-lang 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# mimo
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.js
+```
+
+This project was created using `bun init` in bun v1.0.35. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import Mimo from "./index.js";
+import { version } from "./package.json";
+
+// Check if the user asked for the version
+if (process.argv.includes("-v") || process.argv.includes("--version")) {
+  console.log(version);
+  process.exit(0);
+}
+
+// Check if a filename was provided
+if (process.argv.length < 3) {
+  console.error("Error: No file name provided.");
+  console.log("Usage: mimo [FILENAME]");
+  process.exit(1);
+}
+
+const filename = process.argv[2];
+
+// Check if the file exists
+if (!fs.existsSync(filename)) {
+  console.error(`Error: File '${filename}' does not exist.`);
+  process.exit(1);
+}
+
+// Read the file
+let code;
+try {
+  code = fs.readFileSync(filename, "utf-8");
+} catch (err) {
+  console.error(`Error reading file '${filename}':`, err.message);
+  process.exit(1);
+}
+
+// Run the code
+const mimo = new Mimo();
+try {
+  mimo.run(code);
+} catch (err) {
+  console.error("Error running code:", err.message);
+  process.exit(1);
+}

package/compiler/execute/interpreter.js

@@ -0,0 +1,68 @@
+import { interpretBinary } from "./interpreters/binary";
+import { interpretCall } from "./interpreters/call";
+import { interpretIf } from "./interpreters/if";
+import { interpretTryCatch } from "./interpreters/try-catch";
+import { interpretWhile } from "./interpreters/while";
+import { createFunction } from "./utils/createfunction";
+import { evaluate } from "./utils/evaluate";
+
+export async function interpretStatement(statement, env) {
+  if (Array.isArray(statement)) {
+    for (let i = 0; i < statement.length; i++) {
+      if (await interpretStatement(statement[i], env)) return true;
+    }
+    return;
+  }
+
+  if (typeof statement === "object") {
+    if (statement.type === "try-catch") {
+      await interpretTryCatch(statement, env);
+    } else {
+      await interpretObjectStatement(statement, env);
+    }
+  }
+}
+
+async function interpretObjectStatement(statement, env) {
+  switch (statement.type) {
+    case "assignment":
+      env[statement.target] = evaluate(statement.value, env);
+      break;
+    case "binary":
+      await interpretBinary(statement, env);
+      break;
+    case "if":
+      await interpretIf(statement, env);
+      break;
+    case "while":
+      await interpretWhile(statement, env);
+      break;
+    case "function":
+      env[statement.name] = createFunction(
+        statement.params,
+        statement.body,
+        env
+      );
+      break;
+    case "return":
+      env["return"] = evaluate(statement.expression, env);
+      return true;
+    case "call":
+      await interpretCall(statement, env);
+      break;
+    case "print":
+      console.log(evaluate(statement.value, env));
+      break;
+    default:
+      console.log("Unknown statement type", statement.type);
+      break;
+  }
+}
+
+export async function interpret(program, env = {}) {
+  let index = 0;
+  while (index < program.length) {
+    if (await interpretStatement(program[index++], env)) break;
+  }
+  return env;
+}

package/compiler/execute/interpreters/binary.js

@@ -0,0 +1,12 @@
+import { evaluate } from "../utils/evaluate";
+
+export async function interpretBinary(statement, env) {
+    if (env[statement.target] === undefined) {
+        env[statement.target] = null;
+    }
+    env[statement.target] = await operate(
+        statement.operator,
+        await evaluate(statement.left, env),
+        await evaluate(statement.right, env)
+    );
+}

package/compiler/execute/interpreters/call.js

@@ -0,0 +1,10 @@
+import { evaluate } from "../utils/evaluate";
+
+export async function interpretCall(statement, env) {
+    const func = env[statement.name];
+    if (typeof func !== "function") {
+        throw new Error(`${statement.name} is not a function`);
+    }
+    const args = statement.args.map((arg) => evaluate(arg, env));
+    env[statement.target] = await func(...args);
+}

package/compiler/execute/interpreters/if.js

@@ -0,0 +1,10 @@
+import { interpretStatement } from "../interpreter";
+import { evaluate } from "../utils/evaluate";
+
+export async function interpretIf(statement, env) {
+    if (evaluate(statement.condition, env)) {
+        if (await interpretStatement(statement.consequent, env)) return true;
+    } else if (statement.alternate) {
+        if (await interpretStatement(statement.alternate, env)) return true;
+    }
+}

package/compiler/execute/interpreters/try-catch.js

@@ -0,0 +1,9 @@
+
+export async function interpretTryCatch(statement, env) {
+    try {
+        await interpretStatement(statement.tryBlock, env);
+    } catch (error) {
+        env[statement.error] = error;
+        await interpretStatement(statement.catchBlock, env);
+    }
+}

package/compiler/execute/interpreters/while.js

@@ -0,0 +1,8 @@
+import { interpretStatement } from "../interpreter";
+import { evaluate } from "../utils/evaluate";
+
+export async function interpretWhile(statement, env) {
+    while (evaluate(statement.condition, env)) {
+        if (await interpretStatement(statement.body, env)) return true;
+    }
+}

package/compiler/execute/utils/createfunction.js

@@ -0,0 +1,11 @@
+import { interpret } from "../interpreter";
+
+export function createFunction(params, body, env) {
+  return async function (...args) {
+    const newEnv = { ...env };
+    params.forEach((param, index) => {
+      newEnv[param] = args[index] ?? undefined;
+    });
+    return (await interpret(body, newEnv))["return"];
+  };
+}

package/compiler/execute/utils/evaluate.js

@@ -0,0 +1,20 @@
+import { operate } from "./operate";
+
+export const evaluate = (expression, env) =>
+  expression.type === "literal"
+    ? expression.value
+    : expression.type === "variable"
+    ? env.hasOwnProperty(expression.name)
+      ? env[expression.name]
+      : null
+    : expression.type === "list"
+    ? expression.elements.map((element) => evaluate(element, env))
+    : expression.type === "indexAccess"
+    ? env[expression.name][evaluate(expression.index, env)]
+    : expression.type === "binary"
+    ? operate(
+        expression.operator,
+        evaluate(expression.left, env),
+        evaluate(expression.right, env)
+      )
+    : null;

package/compiler/execute/utils/operate.js

@@ -0,0 +1,23 @@
+const operations = new Map([
+  ["+", (left, right) => left + right],
+  ["-", (left, right) => left - right],
+  ["*", (left, right) => left * right],
+  ["/", (left, right) => left / right],
+  ["%", (left, right) => left % right],
+  ["**", (left, right) => left ** right],
+  [">", (left, right) => left > right],
+  ["<", (left, right) => left < right],
+  [">=", (left, right) => left >= right],
+  ["<=", (left, right) => left <= right],
+  ["==", (left, right) => left == right],
+  ["!=", (left, right) => left != right],
+  ["!", (left) => !left],
+]);
+
+export const operate = (operator, left, right) => {
+  const operation = operations.get(operator);
+  if (!operation) {
+    throw new Error(`Invalid operator: ${operator}`);
+  }
+  return operation(left, right);
+};

package/compiler/lexer/processToken.js

@@ -0,0 +1,40 @@
+// processToken.js
+
+import { OPERATORS } from "./tokenTypes";
+
+export const isOperator = (char) => OPERATORS.includes(char);
+
+export const processToken = (currentToken, currentType, tokens) => {
+    if (currentToken) {
+        tokens.push({ type: currentType, value: currentToken });
+        return { currentToken: "", currentType: null };
+    }
+    return { currentToken, currentType };
+};
+
+export const processStringToken = (inString, currentToken, tokens) => {
+    inString = !inString;
+    if (!inString) {
+        tokens.push({ type: "string", value: currentToken });
+        currentToken = "";
+    }
+    return { inString, currentToken };
+};
+
+export const processOperatorToken = (char, index, input, currentType, currentToken, tokens) => {
+    if (currentToken) {
+        ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
+    }
+
+    
+    currentType = "operator";
+    currentToken += char;
+
+
+    if (index < input.length - 1 && isOperator(input[index + 1])) {
+        currentToken += input[index + 1];
+        index++; // Skip the next operator character
+    }
+    tokens.push({ type: currentType, value: currentToken });
+    return { currentToken: "", currentType: null, i:index };
+};

package/compiler/lexer/tokenTypes.js

@@ -0,0 +1,4 @@
+// tokenTypes.js
+export const OPERATORS = ["+", "-", "*", "/", ">", "<", "=", "!"];
+export const KEYWORDS = ["let", "const", "if", "else", "for", "while", "function", "return"];
+export const PUNCTUATION = ["(", ")", ",", "[", "]"];

package/compiler/lexer/tokenizer.js

@@ -0,0 +1,63 @@
+import { processToken, processStringToken, processOperatorToken, isOperator } from './processToken.js';
+import { PUNCTUATION } from './tokenTypes.js';
+
+function generateTokens(input) {
+    const tokens = [];
+    let currentToken = "";
+    let currentType = null;
+    let inComment = false;
+    let inString = false;
+
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        
+        if (inComment) {
+            if (char === "\n") {
+                inComment = false;
+            }
+            continue;
+        }
+
+        if (char === "/" && input[i + 1] === "/") {
+            inComment = true;
+            i++; // Skip the second '/'
+            continue;
+        }
+
+        if (char === '"') {
+            ({ inString, currentToken } = processStringToken(inString, currentToken, tokens));
+            continue;
+        }
+
+        if (inString) {
+            currentToken += char;
+            continue;
+        }
+
+        if (/\s/.test(char)) {
+            ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
+            continue;
+        }
+
+        if (isOperator(char)) {
+            ({ currentToken, currentType, i } = processOperatorToken(char, i, input, currentType, currentToken, tokens));
+        }else  if (PUNCTUATION.includes(char)) {
+            ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
+            tokens.push({ type: "punctuation", value: char });
+        } else {
+            currentToken += char;
+            if (!currentType) {
+                currentType = /[a-zA-Z]/.test(char)
+                    ? "identifier"
+                    : /[0-9]/.test(char)
+                    ? "number"
+                    : null;
+            }
+        }
+    }
+
+    ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
+    return tokens;
+}
+
+export { generateTokens };

package/compiler/parser/expression/comparison.js

@@ -0,0 +1,18 @@
+import { parseExpression } from "../parseExpression";
+
+export function comparisonExpression(tokens, index) {
+    const operator = tokens[index++].value;
+        let left = parseExpression(tokens, index);
+        index = left.index; // Update the index
+        let right = parseExpression(tokens, index);
+        index = right.index; // Update the index
+        return {
+          expression: {
+            type: "comparison",
+            operator,
+            left: left.expression,
+            right: right.expression,
+          },
+          index,
+        };
+}

package/compiler/parser/expression/identifier.js

@@ -0,0 +1,29 @@
+import { parseExpression } from "../parseExpression";
+
+export function identifierExpression(tokens, index) {
+  if (
+    tokens[index + 1]?.value === "[" &&
+    tokens[index + 3]?.value === "]"
+  ) {
+    const name = tokens[index].value;
+    index += 2; // Skip identifier and '['
+    const indexExpression = parseExpression(tokens, index);
+    index = indexExpression.index; // Update the index
+    if (tokens[index]?.value === "]") {
+      index++; // Skip ']'
+    }
+    return {
+      expression: {
+        type: "indexAccess",
+        name,
+        index: indexExpression.expression,
+      },
+      index,
+    };
+  } else {
+    return {
+      expression: { type: "variable", name: tokens[index++].value },
+      index,
+    };
+  }
+}

package/compiler/parser/expression/number.js

@@ -0,0 +1,10 @@
+
+export function numberExpression(tokens, index){
+    return {
+        expression: {
+        type: "literal",
+        value: parseFloat(tokens[index++].value),
+        },
+        index,
+    };
+}

package/compiler/parser/expression/operator.js

@@ -0,0 +1,21 @@
+import { parseExpression } from "../parseExpression";
+
+export function operatorExpression(tokens, index) {
+  let operator = tokens[index++].value;
+  let left = parseExpression(tokens, index);
+  index = left.index; // Update the index
+  if (tokens[index]?.type === "operator") {
+    operator += tokens[index++].value; // Handle two-character operators like '=='
+  }
+  let right = parseExpression(tokens, index);
+  index = right.index; // Update the index
+  return {
+    expression: {
+      type: "binary",
+      operator,
+      left: left.expression,
+      right: right.expression,
+    },
+    index,
+  };
+}

package/compiler/parser/expression/punctuation.js

@@ -0,0 +1,31 @@
+import { parseExpression } from "../parseExpression";
+
+export function punctuationExpression(tokens, index) {
+    if (tokens[index].value === "[") {
+        index++; // Skip '['
+        const elements = [];
+        while (
+          tokens[index]?.type !== "punctuation" &&
+          tokens[index]?.value !== "]"
+        ) {
+          let result = parseExpression(tokens, index);
+          elements.push(result.expression);
+          index = result.index; // Update the index
+          if (
+            tokens[index]?.type === "punctuation" &&
+            tokens[index]?.value === ","
+          ) {
+            index++; // Skip ',' between elements
+          }
+        }
+        if (tokens[index]?.value === "]") {
+          index++; // Skip ']'
+        }
+        return { expression: { type: "list", elements }, index };
+      }
+
+    return {
+        expression: { type: "punctuation", value: tokens[index++].value },
+        index,
+    };
+}

package/compiler/parser/expression/string.js

@@ -0,0 +1,6 @@
+export function stringExpression(tokens, index){
+    return {
+        expression: { type: "literal", value: tokens[index++].value },
+        index,
+    };
+}

package/compiler/parser/parseExpression.js

@@ -0,0 +1,27 @@
+import { comparisonExpression } from "./expression/comparison";
+import { identifierExpression } from "./expression/identifier";
+import { numberExpression } from "./expression/number";
+import { operatorExpression } from "./expression/operator";
+import { punctuationExpression } from "./expression/punctuation";
+import { stringExpression } from "./expression/string";
+
+export const parseExpression = (tokens, index) => {
+//   console.log("expression..", tokens[index].type, tokens[index].value);
+
+  switch (tokens[index].type) {
+    case "number":
+     return numberExpression(tokens, index);
+    case "string":
+      return stringExpression(tokens, index);
+    case "identifier":
+      return identifierExpression(tokens, index);
+    case "operator":
+     return operatorExpression(tokens, index);
+    case "punctuation":
+      return punctuationExpression(tokens, index);
+    default:
+      if (["<", ">", ">=", "<=", "==", "!="].includes(tokens[index].value)) {
+        return comparisonExpression(tokens, index);
+      }
+  }
+};

package/compiler/parser/parseStatement.js

@@ -0,0 +1,36 @@
+import { parseExpression } from "./parseExpression";
+import { ifStatement } from "./statement/if";
+import { setStatement } from "./statement/set";
+import { tryCatchStatement } from "./statement/try-catch";
+import { whileStatement } from "./statement/while";
+import { functionStatement } from "./statement/function";
+import { callStatement } from "./statement/call";
+import { returnStatement } from "./statement/return";
+import { showStatement } from "./statement/show";
+
+export const parseStatement = (tokens, index) => {
+  let statement = { type: "statement" };
+
+  // console.log("parsing..", tokens[index].type, tokens[index].value);
+  if (tokens[index].value === "set") {
+    ({ statement, index } = setStatement(tokens, index));
+  } else if (tokens[index].value === "if") {
+    ({ statement, index } = ifStatement(tokens, index));
+  } else if (tokens[index].value === "while") {
+    ({ statement, index } = whileStatement(tokens, index));
+  } else if (tokens[index].value === "try") {
+    ({ statement, index } = tryCatchStatement(tokens, index));
+  } else if (tokens[index].value === "function") {
+    ({ statement, index } = functionStatement(tokens, index));
+  } else if (tokens[index].value === "call") {
+    ({ statement, index } = callStatement(tokens, index));
+  } else if (tokens[index].value === "return") {
+    ({ statement, index } = returnStatement(tokens, index));
+  } else if (tokens[index].value === "show") {
+    ({ statement, index } = showStatement(tokens, index));
+  } else {
+    index++;
+  }
+
+  return { statement, index };
+};

package/compiler/parser/parser.js

@@ -0,0 +1,16 @@
+import { parseStatement } from "./parseStatement";
+
+export function parseTokens(tokens) {
+    let index = 0;
+
+    const program = [];
+    while (index < tokens.length) {
+        let statement;
+        let result = parseStatement(tokens, index);
+        statement = result.statement;
+        index = result.index; // Update the index
+        program.push(statement);
+    }
+
+    return program;
+}

package/compiler/parser/statement/call.js

@@ -0,0 +1,26 @@
+import { parseExpression } from "../parseExpression";
+
+export const callStatement = (tokens, index) => {
+  let statement = { type: "call" };
+  statement.name = tokens[index + 1]?.value;
+  index += 2; // Skip 'call' and function name
+  statement.args = [];
+  statement.target = null;
+  if (tokens[index].value === "(") {
+    index++; // Skip '('
+    while (tokens[index].value !== ")") {
+      if (tokens[index].value !== ",") {
+        let result = parseExpression(tokens, index);
+        statement.args.push(result.expression);
+        index = result.index; // Update the index
+      } else {
+        index++; // Skip ','
+      }
+    }
+    index++; // Skip ')'
+  }
+  if ((tokens[index++].value = "->")) {
+    statement.target = tokens[index++].value;
+  }
+  return { statement, index };
+};

package/compiler/parser/statement/function.js

@@ -0,0 +1,29 @@
+import { parseStatement } from "../parseStatement";
+
+// #file:statement/function.js
+export const functionStatement = (tokens, index) => {
+  index++; // Skip 'function'
+  let statement = { type: "function" };
+  statement.name = tokens[index++]?.value;
+  index++; // Skip 'function' and function name
+  statement.params = [];
+  while (tokens[index]?.value !== ")") {
+    statement.params.push(tokens[index]?.value);
+    index++; // Skip parameter
+    if (tokens[index]?.value === ",") {
+      index++; // Skip ','
+    }
+  }
+  index++; // Skip ')'
+  const body = [];
+  while (tokens[index] && tokens[index].value !== "endfunction") {
+    let result = parseStatement(tokens, index);
+    body.push(result.statement);
+    index = result.index; // Update the index
+  }
+  if (tokens[index].value === "endfunction") {
+    index++;
+  }
+  statement.body = body;
+  return { statement, index };
+};

package/compiler/parser/statement/if.js

@@ -0,0 +1,34 @@
+import { parseExpression } from "../parseExpression";
+import { parseStatement } from "../parseStatement";
+
+export function ifStatement(tokens, index) {
+  let statement = { type: "if" };
+  index++;
+  let result = parseExpression(tokens, index);
+  statement.condition = result.expression;
+  index = result.index; // Update the index
+  statement.consequent = [];
+
+  while (
+      tokens[index] &&
+      tokens[index].value !== "endif" &&
+      tokens[index].value !== "else"
+  ) {
+      let result = parseStatement(tokens, index);
+      statement.consequent.push(result.statement);
+      index = result.index; // Update the index
+  }
+  if (tokens[index].value === "else") {
+      index++;
+      statement.alternate = [];
+      while (tokens[index] && tokens[index].value !== "endif") {
+          let result = parseStatement(tokens, index);
+          statement.alternate.push(result.statement);
+          index = result.index; // Update the index
+      }
+  }
+  if (tokens[index].value === "endif") {
+      index++;
+  }
+  return { statement, index };
+}

package/compiler/parser/statement/return.js

@@ -0,0 +1,10 @@
+import { parseExpression } from "../parseExpression";
+
+// #file:statement/return.js
+export const returnStatement = (tokens, index) => {
+    let statement = { type: "return" };
+    let result = parseExpression(tokens, index + 1);
+    statement.expression = result.expression;
+    index = result.index; // Update the index
+    return { statement, index };
+};

package/compiler/parser/statement/set.js

@@ -0,0 +1,11 @@
+import { parseExpression } from "../parseExpression";
+
+export function setStatement(tokens, index) {
+  let statement = { type: "assignment" };
+  index++;
+  statement.target = tokens[index++].value;
+  let result = parseExpression(tokens, index);
+  statement.value = result.expression;
+  index = result.index; // Update the index
+  return { statement, index };
+}

package/compiler/parser/statement/show.js

@@ -0,0 +1,10 @@
+import { parseExpression } from "../parseExpression";
+
+export const showStatement = (tokens, index) => {
+    let statement = { type: "print" };
+    index++; // Skip 'show'
+    let result = parseExpression(tokens, index);
+    statement.value = result.expression;
+    index = result.index; // Update the index
+    return { statement, index };
+};

package/compiler/parser/statement/try-catch.js

@@ -0,0 +1,25 @@
+import { parseStatement } from "../parseStatement";
+
+export const tryCatchStatement = (tokens, index) => {
+  let statement = { type: "try-catch" };
+  statement.tryBlock = [];
+  index++;
+  while (tokens[index] && tokens[index].value !== "catch") {
+    let result = parseStatement(tokens, index);
+    statement.tryBlock.push(result.statement);
+    index = result.index; // Update the index
+  }
+  if (tokens[index].value === "catch") {
+    index++;
+    statement.catchBlock = [];
+    while (tokens[index] && tokens[index].value !== "endtry") {
+      let result = parseStatement(tokens, index);
+      statement.catchBlock.push(result.statement);
+      index = result.index; // Update the index
+    }
+  }
+  if (tokens[index].value === "endtry") {
+    index++;
+  }
+  return { statement, index };
+};

package/compiler/parser/statement/while.js

@@ -0,0 +1,22 @@
+import { parseExpression } from "../parseExpression";
+import { parseStatement } from "../parseStatement";
+
+
+export const whileStatement = (tokens, index) => {
+  index++; // Skip 'while'
+  let statement = { type: "while" };
+  let result = parseExpression(tokens, index);
+  statement.condition = result.expression;
+  index = result.index; // Update the index
+  const body = [];
+  while (tokens[index] && tokens[index].value !== "endwhile") {
+    let result = parseStatement(tokens, index);
+    body.push(result.statement);
+    index = result.index; // Update the index
+  }
+  if (tokens[index].value === "endwhile") {
+    index++;
+  }
+  statement.body = body;
+  return { statement, index };
+};

package/converter/go/convert.js

@@ -0,0 +1,100 @@
+let declaredVariables = new Set();
+
+function generateGoCodeFromAst(node) {
+  switch (node.type) {
+    case "function":
+      return generateFunction(node);
+    case "assignment":
+      return generateAssignment(node);
+    case "while":
+      return generateWhile(node);
+    case "if":
+      return generateIf(node);
+    case "return":
+      return generateReturn(node);
+    case "call":
+      return generateCall(node);
+    case "print":
+      return generatePrint(node);
+    case "literal":
+      return node.value;
+    case "variable":
+      return node.name;
+    case "binary":
+      return generateBinary(node);
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+
+export function generateGoCodeFromAstArray(ast) {
+  declaredVariables = new Set();
+  const generatedCode = ast.map(generateGoCodeFromAst).join("\n\n");
+  return formatGoCode(`
+    package main
+
+    import "fmt"
+
+    ${generatedCode}
+  `);
+}
+
+function generateFunction(node) {
+  const params = node.params.join(", ");
+  const body = node.body.map(generateGoCodeFromAst).join("\n");
+  return `func ${node.name}(${params}) int {\n${body}\n}`;
+}
+
+function generateAssignment(node) {
+  let prefix = "";
+  if (!declaredVariables.has(node.target)) {
+    prefix = "var ";
+    declaredVariables.add(node.target);
+  }
+  return `${prefix}${node.target} := ${generateGoCodeFromAst(node.value)}`;
+}
+
+function generateWhile(node) {
+  const condition = generateGoCodeFromAst(node.condition);
+  const body = node.body.map(generateGoCodeFromAst).join("\n");
+  return `for ${condition} {\n${body}\n}`;
+}
+
+function generateIf(node) {
+  const condition = generateGoCodeFromAst(node.condition);
+  const consequent = node.consequent.map(generateGoCodeFromAst).join("\n");
+  return `if ${condition} {\n${consequent}\n}`;
+}
+
+function generateReturn(node) {
+  return `return ${generateGoCodeFromAst(node.expression)}`;
+}
+
+function generateCall(node) {
+  const args = node.args.map(generateGoCodeFromAst).join(", ");
+  let callCode = `${node.name}(${args})`;
+  if (node.target) {
+    let prefix = "";
+    if (!declaredVariables.has(node.target)) {
+      prefix = "var ";
+      declaredVariables.add(node.target);
+    }
+    callCode = `${prefix}${node.target} := ${callCode}`;
+  }
+  return callCode;
+}
+
+
+function generatePrint(node) {
+  return `fmt.Println(${generateGoCodeFromAst(node.value)})`;
+}
+
+function generateBinary(node) {
+  const left = generateGoCodeFromAst(node.left);
+  const right = generateGoCodeFromAst(node.right);
+  return `${left} ${node.operator} ${right}`;
+}
+
+function formatGoCode(code) {
+  return code;
+}

package/converter/js/convert.js

@@ -0,0 +1,106 @@
+import esformatter from 'esformatter';
+
+
+let declaredVariables = new Set();
+
+export function generateCodeFromAst(node) {
+  switch (node.type) {
+    case "function":
+      return generateFunction(node);
+    case "assignment":
+      return generateAssignment(node);
+    case "while":
+      return generateWhile(node);
+    case "if":
+      return generateIf(node);
+    case "return":
+      return generateReturn(node);
+    case "call":
+      return generateCall(node);
+    case "print":
+      return generatePrint(node);
+    case "literal":
+      return node.value;
+    case "variable":
+      return node.name;
+    case "binary":
+      return generateBinary(node);
+    case "indexAccess":
+      return generateIndexAccess(node);
+    case "list":
+      return generateList(node);
+    default:
+      console.log(node);
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+
+export function generateCodeJsFromAstArray(ast) {
+  const generatedCode = ast.map(generateCodeFromAst).join("\n");
+  return esformatter.format(generatedCode);
+}
+
+function generateFunction(node) {
+  const params = node.params.join(", ");
+  const body = node.body.map(generateCodeFromAst).join("\n");
+  return `function ${node.name}(${params}) {\n${body}\n}`;
+}
+
+function generateAssignment(node) {
+  let prefix = "";
+  if (!declaredVariables.has(node.target)) {
+    prefix = "let ";
+    declaredVariables.add(node.target);
+  }
+  return `${prefix}${node.target} = ${generateCodeFromAst(node.value)};`;
+}
+
+function generateWhile(node) {
+  const condition = generateCodeFromAst(node.condition);
+  const body = node.body.map(generateCodeFromAst).join("\n");
+  return `while (${condition}) {\n${body}\n}`;
+}
+
+function generateIf(node) {
+  const condition = generateCodeFromAst(node.condition);
+  const consequent = node.consequent.map(generateCodeFromAst).join("\n");
+  return `if (${condition}) {\n${consequent}\n}`;
+}
+
+function generateReturn(node) {
+  return `return ${generateCodeFromAst(node.expression)};`;
+}
+
+function generateCall(node) {
+  const args = node.args.map(generateCodeFromAst).join(", ");
+  let callCode = `${node.name}(${args})`;
+  if (node.target) {
+    let prefix = "";
+    if (!declaredVariables.has(node.target)) {
+      prefix = "let ";
+      declaredVariables.add(node.target);
+    }
+    callCode = `${prefix}${node.target} = ${callCode};`;
+  }
+  return callCode;
+}
+
+function generatePrint(node) {
+  return `console.log(${generateCodeFromAst(node.value)});`;
+}
+
+function generateBinary(node) {
+  const left = generateCodeFromAst(node.left);
+  const right = generateCodeFromAst(node.right);
+  return `${left} ${node.operator} ${right}`;
+}
+
+function generateIndexAccess(node) {
+  const index = generateCodeFromAst(node.index);
+  return `${node.name}[${index}]`;
+}
+
+function generateList(node) {
+  const elements = node.elements.map(generateCodeFromAst).join(", ");
+  return `[${elements}]`;
+}

package/index.js

@@ -0,0 +1,48 @@
+import { generateTokens } from "./compiler/lexer/tokenizer";
+import { parseTokens } from "./compiler/parser/parser";
+import { interpret } from "./compiler/execute/interpreter";
+import { generateGoCodeFromAstArray } from "./converter/go/convert";
+import { generateCodeJsFromAstArray } from "./converter/js/convert";
+import fs from "fs";
+
+// The main class for the Mimo language
+export default class Mimo {
+  constructor() {
+    // Initialize the environment for variables
+    this.env = {};
+  }
+
+  // Tokenize the given code into a list of tokens
+  async tokenize(code) {
+    return generateTokens(code);
+  }
+
+  // Parse the list of tokens into an abstract syntax tree (AST)
+  async parse(tokens) {
+    return parseTokens(tokens);
+  }
+
+  // Interpret the AST and execute the code
+  async interpret(program) {
+    return interpret(program, this.env);
+  }
+
+  // Run the given code by tokenizing, parsing, and interpreting it
+  async run(code) {
+    const tokens = await this.tokenize(code);
+    const program = await this.parse(tokens);
+    return await this.interpret(program);
+  }
+
+  // Convert the AST to JavaScript code
+  toJS(ast) {
+    return generateCodeJsFromAstArray(ast);
+  }
+
+  // Convert the AST to Go code
+  toGO(ast) {
+    return generateGoCodeFromAstArray(ast);
+  }
+}
+
+

package/jsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mimo-lang",
+  "version": "1.0.0",
+  "description": "A programming language made in javascript mostly for learning purposes.",
+  "keywords": [
+    "programing language"
+  ],
+  "author": "bethropolis",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.js",
+  "type": "module",
+  "bin": {
+    "mimo": "./cli.js"
+  },
+  "scripts": {
+    "dev": "bun index.js"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "dependencies": {
+    "esformatter": "^0.11.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bethropolis/mimo.git"
+  },
+  "homepage": "https://bethropolis.github.io/mimo",
+  "bugs": {
+    "url": "https://github.com/bethropolis/mimo/issues"
+  }
+}

package/test.js

@@ -0,0 +1 @@
+console.log(a)