cajyu 1.0.0 → 1.1.0

package/README.md

@@ -2,57 +2,75 @@
 
 **A clean, practical programming language that transpiles to JavaScript.**
 
-Cajyu is designed for people who want a simpler syntax without leaving the JavaScript ecosystem. Write expressive code, get real JavaScript output, and use a growing set of official libraries.
+Cajyu gives you a simpler, more expressive syntax while staying fully compatible with the JavaScript ecosystem.
 
 [![npm](https://img.shields.io/badge/npm-cajyu-blue)](https://www.npmjs.com/package/cajyu)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Version](https://img.shields.io/badge/version-1.1.0-brightgreen)](package.json)
 
 ---
 
 ## Features
 
-- **Familiar yet cleaner syntax** — variables, functions, classes, control flow, and loops that feel natural
-- **Transpiles to modern JavaScript** — runs anywhere Node.js runs
-- **Real HTTP server** — built-in `Server` class with POST handlers, sleep/wake, and static files
-- **Official libraries** — `serial`, `fs`, `math`, `http` (and more coming)
-- **Optional typing** — runtime type checks with `var x:Number = 10`
-- **Async support** — `sync fn` and `wait`
-- **One-liners & stacking** — concise style when you want it
-- **CLI** — `cajyu init`, `cajyu inst`, `cajyu run`
+- Clean syntax for variables, functions, classes, loops and conditionals
+- Transpiles to modern JavaScript
+- Real HTTP server with POST handlers, sleep/wake
+- WebSocket that automatically sends and receives JSON
+- Official libraries: `serial`, `fs`, `math`, `http`, `websocket`, `string`, `json`, `exec`, `fetch`
+- Optional runtime typing
+- Async with `sync fn` and `wait`
+- One-liners and stacking
+- CLI with flags and multiple commands
 
 ---
 
 ## Quick Start
 
 ```bash
-# Install the CLI (once published)
+# After publishing
 npm install -g cajyu
 
-# Or run directly from this repo
+# Or from source
 node bin/cajyu.js --help
 ```
 
-Create a new project:
-
 ```bash
 cajyu init
+cajyu inst serial
+cajyu inst http
+cajyu run examples/fatorial.cjy
 ```
 
-Run a file:
+---
 
-```bash
-cajyu run examples/fatorial.cjy
+## CLI
+
+```
+cajyu [flags]
+cajyu <command> [options]
 ```
 
+| Command          | Description                          |
+|------------------|--------------------------------------|
+| `init`           | Create a new project                 |
+| `inst <lib>`     | Install a library from CajyuLibs     |
+| `run <file.cjy>` | Compile and run a file               |
+| `list`           | List installed libraries             |
+| `update`         | Update libraries (planned)           |
+
+| Flag             | Description          |
+|------------------|----------------------|
+| `-h, --help`     | Show help            |
+| `-v, --version`  | Show version         |
+
 ---
 
-## Syntax Overview
+## Syntax
 
 ### Variables
 ```cajyu
 var name = "Cajyu"
 var age:Number = 17
-var items = [1, 2, 3]
 ```
 
 ### Functions
@@ -60,13 +78,9 @@ var items = [1, 2, 3]
 fn add a, b {
   return a + b
 }
-
-fn double x {
-  return x * 2
-}
 ```
 
-### Control Flow
+### Control flow & loops
 ```cajyu
 if x > 10 {
   print("big")
@@ -75,17 +89,10 @@ if x > 10 {
 } else {
   print("small")
 }
-```
 
-### Loops
-```cajyu
 for i in range(10) {
   print(i)
 }
-
-while x < 100 {
-  x = x * 2
-}
 ```
 
 ### Classes
@@ -96,26 +103,14 @@ class Person {
     Self.age = age
   }
   greet {
-    return "Hello, I'm " + Self.name
+    return "Hello, " + Self.name
   }
 }
-
-var p = new Person("Ana", 17)
-print(p.greet())
-```
-
-### Async
-```cajyu
-sync fn fetchData {
-  wait someAsyncCall()
-  return result
-}
 ```
 
-### HTTP Server
+### HTTP
 ```cajyu
 import Server from CajyuLibs.http
-import print from CajyuLibs.serial
 
 var server = new Server(3000)
 
@@ -123,67 +118,58 @@ server.post(fn b {
   if !b.a and !b.b {
     return { code: 400 }
   }
-  return {
-    code: 200,
-    result: b.a + b.b
-  }
+  return { code: 200, result: b.a + b.b }
 })
 ```
 
----
-
-## Libraries
-
-Official libraries live in the [CajyuLibs](https://github.com/abs-js/CajyuLibs) repository.
-
-Install a library:
+### WebSocket (JSON)
+```cajyu
+import WS from CajyuLibs.websocket
 
-```bash
-cajyu inst serial
-cajyu inst http
+var wss = new WS.Server(8080)
+wss.on("message", fn msg, client {
+  wss.broadcast({ echo: msg })
+})
 ```
 
-Import in your code:
-
+### Exec & Fetch
 ```cajyu
-import print from CajyuLibs.serial
-import Server from CajyuLibs.http
+import exec from CajyuLibs.exec
+var files = exec.exec("ls -a")
+
+import fetch from CajyuLibs.fetch
+fetch.fetch("https://api.github.com", {}, null, fn result, ms {
+  print(result)
+})
 ```
 
 ---
 
-## CLI Commands
-
-| Command | Description |
-|---------|-------------|
-| `cajyu init` | Create a new project (`package.json` + structure) |
-| `cajyu inst <name>` | Install a library from CajyuLibs |
-| `cajyu run <file.cjy>` | Compile and run a Cajyu file |
-
----
+## Libraries
 
-## Project Structure
+Official libraries: https://github.com/abs-js/CajyuLibs
 
-```
-Cajyu/
-├── bin/cajyu.js          # CLI entry point
-├── src/compiler.js       # Transpiler
-├── examples/             # Working examples
-│   ├── fatorial.cjy
-│   ├── classe.cjy
-│   └── servidor-post.cjy
-└── package.json
+```bash
+cajyu inst serial
+cajyu inst fs
+cajyu inst math
+cajyu inst http
+cajyu inst websocket
+cajyu inst string
+cajyu inst json
+cajyu inst exec
+cajyu inst fetch
 ```
 
 ---
 
 ## Contributing
 
-Cajyu is early but intentional. Pull requests are welcome — especially for:
+Pull requests are welcome. Priority areas:
 
-- A proper parser (currently regex-based)
+- A proper parser (current one is regex-based)
 - More language features
-- New official libraries
+- Additional libraries
 - Better error messages
 
 ---
@@ -191,7 +177,3 @@ Cajyu is early but intentional. Pull requests are welcome — especially for:
 ## License
 
 MIT
-
----
-
-**Built for people who like clean code and real results.**

package/bin/cajyu.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { compileAndRun } from '../src/compiler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CAJYULIBS_REPO = 'https://github.com/abs-js/CajyuLibs.git';
+const VERSION = '1.1.0';
+
+const args = process.argv.slice(2);
+const command = args[0];
+const flags = args.filter(a => a.startsWith('-'));
+
+function hasFlag(...names) {
+  return names.some(n => flags.includes(n) || flags.includes(`-${n}`) || flags.includes(`--${n}`));
+}
+
+async function main() {
+  if (hasFlag('v', 'version', '--version')) {
+    console.log(`Cajyu ${VERSION}`);
+    return;
+  }
+
+  if (hasFlag('h', 'help', '--help') || !command) {
+    showHelp();
+    return;
+  }
+
+  if (command === 'init') {
+    initProject();
+  } else if (command === 'inst' || command === 'install') {
+    const libName = args[1];
+    if (!libName || libName.startsWith('-')) {
+      console.error('Usage: cajyu inst <library>');
+      process.exit(1);
+    }
+    await installLib(libName);
+  } else if (command === 'run') {
+    const file = args.find(a => a.endsWith('.cjy') || (a !== 'run' && !a.startsWith('-')));
+    if (!file) {
+      console.error('Usage: cajyu run <file.cjy>');
+      process.exit(1);
+    }
+    await compileAndRun(file);
+  } else if (command === 'list') {
+    listInstalled();
+  } else if (command === 'update') {
+    console.log('Updating is not yet implemented. Re-run `cajyu inst <lib>` after deleting the folder.');
+  } else {
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`
+Cajyu ${VERSION} — a custom programming language that transpiles to JavaScript
+
+Usage:
+  cajyu [flags]
+  cajyu <command> [options]
+
+Commands:
+  init              Create a new Cajyu project
+  inst <lib>        Install a library from CajyuLibs
+  run <file.cjy>    Compile and execute a Cajyu file
+  list              List installed libraries
+  update            Update installed libraries (coming soon)
+
+Flags:
+  -h, --help        Show this help
+  -v, --version     Show version
+
+Examples:
+  cajyu init
+  cajyu inst http
+  cajyu inst websocket
+  cajyu run examples/fatorial.cjy
+  cajyu list
+`);
+}
+
+function initProject() {
+  const pkg = {
+    name: "cajyu-project",
+    version: "1.0.0",
+    description: "Cajyu project",
+    main: "index.cjy",
+    type: "module"
+  };
+  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+  if (!fs.existsSync('CajyuLibs')) fs.mkdirSync('CajyuLibs');
+  console.log('Cajyu project initialized.');
+}
+
+async function installLib(libName) {
+  console.log(`Installing "${libName}" from CajyuLibs...`);
+
+  const targetDir = path.join(process.cwd(), 'CajyuLibs', libName);
+  if (fs.existsSync(targetDir)) {
+    console.log(`Library "${libName}" already installed.`);
+    return;
+  }
+
+  const tmpDir = path.join('/tmp', `cajyulibs-${Date.now()}`);
+  try {
+    console.log('Cloning CajyuLibs repository...');
+    execSync(`git clone --depth 1 ${CAJYULIBS_REPO} ${tmpDir}`, { stdio: 'inherit' });
+
+    const sourceLib = path.join(tmpDir, libName);
+    if (!fs.existsSync(sourceLib)) {
+      console.error(`Library "${libName}" not found in CajyuLibs.`);
+      process.exit(1);
+    }
+
+    fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+    fs.cpSync(sourceLib, targetDir, { recursive: true });
+
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+        console.log('Installing library dependencies...');
+        execSync('npm install', { cwd: targetDir, stdio: 'inherit' });
+      }
+    }
+
+    console.log(`✓ Library "${libName}" installed to CajyuLibs/${libName}/`);
+  } catch (err) {
+    console.error('Failed to install library:', err.message);
+    process.exit(1);
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function listInstalled() {
+  const libsDir = path.join(process.cwd(), 'CajyuLibs');
+  if (!fs.existsSync(libsDir)) {
+    console.log('No libraries installed yet.');
+    return;
+  }
+  const libs = fs.readdirSync(libsDir).filter(d => fs.statSync(path.join(libsDir, d)).isDirectory());
+  if (libs.length === 0) {
+    console.log('No libraries installed.');
+  } else {
+    console.log('Installed libraries:');
+    libs.forEach(l => console.log(`  - ${l}`));
+  }
+}
+
+main().catch(console.error);

package/examples/comparison/README.md

@@ -0,0 +1,51 @@
+# Comparison: JavaScript vs TypeScript vs Cajyu
+
+Three identical features implemented in three languages.
+
+## 1. Simple HTML Server
+
+| Language   | File                              | Lines (approx) | Notes |
+|------------|-----------------------------------|----------------|-------|
+| JavaScript | `js/simple-server.js`            | 18             | Direct `http` module |
+| TypeScript | `ts/simple-server.ts`            | 18             | Same + types |
+| Cajyu      | `cajyu/simple-server.cjy`        | 10             | Uses `CajyuLibs.http` |
+
+**Cajyu is the shortest.** The HTTP library abstracts the boilerplate.
+
+## 2. Click Counter
+
+| Language   | File                              | Lines (approx) | Notes |
+|------------|-----------------------------------|----------------|-------|
+| JavaScript | `js/click-counter.js`            | 35             | Manual route + inline HTML/JS |
+| TypeScript | `ts/click-counter.ts`            | 35             | Same + types |
+| Cajyu      | `cajyu/click-counter.cjy`        | 16             | `server.post` + `server.file` |
+
+Again, Cajyu is more concise because of the built-in server abstraction.
+
+## 3. Live Chat (WebSocket)
+
+| Language   | File                              | Lines (approx) | Notes |
+|------------|-----------------------------------|----------------|-------|
+| JavaScript | `js/live-chat.js`                | 45             | Uses `ws` package + full HTML |
+| TypeScript | `ts/live-chat.ts`                | 45             | Same + types |
+| Cajyu      | `cajyu/live-chat.cjy`            | 12             | Uses `CajyuLibs.websocket` (broadcast only) |
+
+Cajyu version is shorter but currently only shows the WebSocket server side.
+
+## Summary
+
+| Aspect              | JavaScript      | TypeScript       | Cajyu                  |
+|---------------------|-----------------|------------------|------------------------|
+| Boilerplate         | Medium          | Medium           | Low                    |
+| Type safety         | None            | Strong           | Optional runtime       |
+| Learning curve      | Low             | Medium           | Low (if you know JS)   |
+| Ecosystem           | Huge            | Huge             | Small (growing)        |
+| Abstraction level   | Low-medium      | Low-medium       | Higher                 |
+| Best for            | Production      | Large projects   | Prototyping / learning |
+
+**Conclusion:**
+- **JavaScript** is the baseline.
+- **TypeScript** adds safety with almost no extra cost.
+- **Cajyu** reduces boilerplate the most, especially for servers, but is still a prototype language.
+
+All examples are in `examples/comparison/`.

package/examples/comparison/cajyu/click-counter.cjy

@@ -0,0 +1,17 @@
+import Server from CajyuLibs.http
+import print from CajyuLibs.serial
+
+var clicks = 0
+var server = new Server(3001)
+print("Cajyu click server at http://localhost:3001")
+
+var html = "<!DOCTYPE html><html><body><h1>Click Counter (Cajyu)</h1><button id='btn'>Click me</button><p>Total clicks: <span id='count'>0</span></p><script>const btn=document.getElementById('btn');const count=document.getElementById('count');btn.onclick=async()=>{const r=await fetch('/click',{method:'POST'});const data=await r.json();count.textContent=data.clicks;};</script></body></html>"
+
+server.file("/", html)
+server.file("index.html", html)
+
+server.post(fn b {
+  clicks = clicks + 1
+  print("Click #" + clicks)
+  return { code: 200, clicks: clicks }
+})

package/examples/comparison/cajyu/live-chat.cjy

@@ -0,0 +1,16 @@
+import WS from CajyuLibs.websocket
+import print from CajyuLibs.serial
+
+var wss = new WS.Server(3002)
+print("Cajyu live chat WebSocket on port 3002")
+
+wss.on("connection", fn client {
+  print("Client connected")
+})
+
+wss.on("message", fn msg, client {
+  print("Message: " + msg)
+  wss.broadcast(msg)
+})
+
+print("Open a WebSocket client to ws://localhost:3002 to chat")

package/examples/comparison/cajyu/simple-server.cjy

@@ -0,0 +1,10 @@
+import Server from CajyuLibs.http
+import print from CajyuLibs.serial
+
+var server = new Server(3000)
+print("Cajyu simple server running at http://localhost:3000")
+
+var html = "<!DOCTYPE html><html><head><title>Simple Server</title></head><body><h1>Hello from Cajyu!</h1><p>This is a simple text served by a Cajyu server.</p></body></html>"
+
+server.file("/", html)
+server.file("index.html", html)

package/examples/comparison/js/simple-server.js

@@ -0,0 +1,20 @@
+// Simple HTML server - JavaScript
+import http from 'http';
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+  res.end(`
+    <!DOCTYPE html>
+    <html>
+      <head><title>Simple Server</title></head>
+      <body>
+        <h1>Hello from JavaScript!</h1>
+        <p>This is a simple text served by a Node.js server.</p>
+      </body>
+    </html>
+  `);
+});
+
+server.listen(3000, () => {
+  console.log('JS server running at http://localhost:3000');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cajyu",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Cajyu programming language - a custom language that compiles to JavaScript",
   "main": "src/compiler.js",
   "bin": {

package/src/compiler.js

@@ -2,23 +2,64 @@ import fs from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
 
+// Error codes
+const ERRORS = {
+  ERR001: 'Syntax error',
+  ERR002: 'Unexpected token',
+  ERR003: 'Missing closing brace',
+  ERR004: 'Type mismatch',
+  ERR005: 'Undefined variable',
+  ERR006: 'Invalid function call',
+  ERR007: 'Missing parentheses',
+  ERR008: 'Invalid import',
+  ERR009: 'Unexpected end of file',
+  ERR010: 'Invalid operator',
+  ERR011: 'Missing semicolon or block',
+  ERR012: 'Invalid type annotation',
+  ERR013: 'Keyword used as identifier',
+  ERR014: 'Unterminated string',
+  ERR015: 'Invalid number',
+  ERR016: 'Duplicate declaration',
+  ERR017: 'Missing return value',
+  ERR018: 'Invalid class member',
+  ERR019: 'Async error',
+  ERR020: 'Library not found'
+};
+
+class CajyuError extends Error {
+  constructor(code, line, column, lineContent, message) {
+    const errName = ERRORS[code] || 'Unknown error';
+    const pointer = ' '.repeat(Math.max(0, column)) + '^';
+    super(`There is an ${errName.toLowerCase()} in line ${line}: ${code}.\n    ${lineContent.trim()}\n   ${pointer}`);
+    this.code = code;
+    this.line = line;
+    this.column = column;
+  }
+}
+
 export async function compileAndRun(filePath) {
   if (!fs.existsSync(filePath)) {
-    console.error(`Arquivo não encontrado: ${filePath}`);
+    console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
   const source = fs.readFileSync(filePath, 'utf-8');
-  const jsCode = transpile(source, path.dirname(filePath));
-  const tempFile = path.join('/tmp', `cajyu_${Date.now()}.mjs`);
-  fs.writeFileSync(tempFile, jsCode);
   try {
-    await import(pathToFileURL(tempFile).href);
-    console.log('--- Execução Cajyu ---');
+    const jsCode = transpile(source, path.dirname(filePath));
+    const tempFile = path.join('/tmp', `cajyu_${Date.now()}.mjs`);
+    fs.writeFileSync(tempFile, jsCode);
+    try {
+      await import(pathToFileURL(tempFile).href);
+      console.log('--- Cajyu execution ---');
+    } finally {
+      try { fs.unlinkSync(tempFile); } catch {}
+    }
   } catch (err) {
-    console.error('Erro na execução:', err.message);
-    console.error(err.stack);
-  } finally {
-    try { fs.unlinkSync(tempFile); } catch {}
+    if (err instanceof CajyuError) {
+      console.error(err.message);
+    } else {
+      console.error('Runtime error:', err.message);
+    }
+    process.exit(1);
   }
 }
 
@@ -26,13 +67,21 @@ function transpile(source, baseDir) {
   const lines = source.split('\n');
   const imports = [];
   const codeLines = [];
-  for (const line of lines) {
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     const m = line.match(/^\s*import\s+(\*|\w+)\s+from\s+['"]?([^\s'"]+)['"]?\s*;?\s*$/);
-    if (m) imports.push({ what: m[1], from: m[2] });
-    else codeLines.push(line);
+    if (m) {
+      imports.push({ what: m[1], from: m[2], line: i + 1 });
+    } else {
+      codeLines.push(line);
+    }
   }
+
   let code = codeLines.join('\n');
 
+  code = preprocessWithErrors(code, lines);
+
   let importCode = '';
   for (const imp of imports) {
     const libPath = resolveLib(imp.from, baseDir);
@@ -43,10 +92,11 @@ function transpile(source, baseDir) {
       } else {
         importCode += `const { CayjuLib: _lib${imp.what} } = await import('${url}'); const ${imp.what} = _lib${imp.what}.${imp.what} || _lib${imp.what};\n`;
       }
+    } else {
+      throw new CajyuError('ERR020', imp.line, 0, lines[imp.line - 1] || '', `Library not found: ${imp.from}`);
     }
   }
 
-  code = preprocessKeywords(code);
   code = transpileFunctions(code);
   code = transpileAnonymousFunctions(code);
   code = transpileControlFlow(code);
@@ -63,24 +113,95 @@ function _range(a, b, c) {
 function _typeCheck(val, type) {
   if (!type) return val;
   const t = String(type).toLowerCase();
-  if (t === 'string' && typeof val !== 'string') throw new Error('esperado String');
-  if ((t === 'number' || t === 'int' || t === 'float') && typeof val !== 'number') throw new Error('esperado Number');
-  if (t === 'boolean' && typeof val !== 'boolean') throw new Error('esperado Boolean');
-  if (t === 'array' && !Array.isArray(val)) throw new Error('esperado Array');
+  if (t === 'string' && typeof val !== 'string') throw new Error('ERR004: expected String');
+  if ((t === 'number' || t === 'int' || t === 'float') && typeof val !== 'number') throw new Error('ERR004: expected Number');
+  if (t === 'boolean' && typeof val !== 'boolean') throw new Error('ERR004: expected Boolean');
+  if (t === 'array' && !Array.isArray(val)) throw new Error('ERR004: expected Array');
+  if (t === 'object' && (typeof val !== 'object' || val === null)) throw new Error('ERR004: expected Object');
   return val;
 }
 `;
 
-  const final = `
+  return `
 ${importCode}
 ${builtins}
 (async () => {
 ${code}
-})().catch(console.error);
+})().catch(e => { console.error(e.message); process.exit(1); });
 `;
+}
+
+function preprocessWithErrors(code, originalLines) {
+  const result = [];
+  const lines = code.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    let newLine = '';
+    let inString = false;
+    let stringChar = '';
 
-  fs.writeFileSync('/tmp/cajyu_debug.mjs', final);
-  return final;
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+
+      if (!inString && (ch === '"' || ch === "'")) {
+        inString = true;
+        stringChar = ch;
+        newLine += ch;
+        continue;
+      }
+      if (inString && ch === stringChar && line[j - 1] !== '\\') {
+        inString = false;
+        newLine += ch;
+        continue;
+      }
+      if (inString) {
+        newLine += ch;
+        continue;
+      }
+
+      if (line.substr(j, 3) === 'and' && isWordBoundary(line, j, 3)) {
+        newLine += '&&';
+        j += 2;
+        continue;
+      }
+      if (line.substr(j, 2) === 'or' && isWordBoundary(line, j, 2)) {
+        newLine += '||';
+        j += 1;
+        continue;
+      }
+      if (line.substr(j, 3) === 'not' && isWordBoundary(line, j, 3)) {
+        newLine += '!';
+        j += 2;
+        continue;
+      }
+
+      newLine += ch;
+    }
+
+    if (inString) {
+      throw new CajyuError('ERR014', i + 1, line.length, line, 'Unterminated string');
+    }
+
+    newLine = newLine
+      .replace(/sync\s+fn\s+(\w+)/g, 'async function $1')
+      .replace(/\bwait\s+/g, 'await ')
+      .replace(/\belif\b/g, 'else if')
+      .replace(/\bSelf\./g, 'this.')
+      .replace(/\brange\(/g, '_range(')
+      .replace(/var\s+(\w+):(\w+)\s*=\s*(.+)/g, 'let $1 = _typeCheck($3, "$2")')
+      .replace(/var\s+(\w+)\s*=/g, 'let $1 =');
+
+    result.push(newLine);
+  }
+
+  return result.join('\n');
+}
+
+function isWordBoundary(line, index, len) {
+  const before = index === 0 || !/\w/.test(line[index - 1]);
+  const after = index + len >= line.length || !/\w/.test(line[index + len]);
+  return before && after;
 }
 
 function resolveLib(from, baseDir) {
@@ -100,21 +221,6 @@ function cleanParams(s) {
   return (s || '').trim().split(',').map(p => p.trim().split(':')[0].trim()).filter(Boolean).join(', ');
 }
 
-function preprocessKeywords(code) {
-  return code
-    .replace(/\band\b/g, '&&')
-    .replace(/\bor\b/g, '||')
-    .replace(/\bnot\b/g, '!')
-    .replace(/sync\s+fn\s+(\w+)/g, 'async function $1')
-    .replace(/\bwait\s+/g, 'await ')
-    .replace(/\belif\b/g, 'else if')
-    .replace(/\bSelf\./g, 'this.')
-    .replace(/\brange\(/g, '_range(')
-    .replace(/\/\/\s*private\s+(\w+)/g, '/* private $1 */')
-    .replace(/var\s+(\w+):(\w+)\s*=\s*(.+)/g, 'let $1 = _typeCheck($3, "$2")')
-    .replace(/var\s+(\w+)\s*=/g, 'let $1 =');
-}
-
 function transpileFunctions(code) {
   return code
     .replace(/^fn\s+(\w+)\s+([^{]*)\{/gm, (_, n, p) => `function ${n}(${cleanParams(p)}) {`)
@@ -145,5 +251,7 @@ function transpileControlFlow(code) {
 function transpileOneLiners(code) {
   return code
     .replace(/return\s+(\{[^}]*\}|.+?)\s+if\s+([^;]+);/g, 'if ($2) return $1;')
-    .replace(/if\s+([^:{;\n]+)\s+return\s+([^;\n{]+)/g, 'if ($1) return $2;');
+    .replace(/if\s+([^:{;\n]+)\s+return\s+([^;\n{]+)/g, 'if ($1) return $2;')
+    .replace(/while\s+([^:{;\n]+)\s+([^;\n{]+);?/g, 'while ($1) { $2; }')
+    .replace(/for\s+(\w+)\s+in\s+([^ {\n;]+)\s+([^;\n{]+);?/g, 'for (let $1 of $2) { $3; }');
 }