nexicscript 0.1.0

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,29 @@
+# Código de Conducta de NexicScript
+
+## Nuestro compromiso
+
+Nos comprometemos a hacer de NexicScript una comunidad abierta y respetuosa para todos.
+
+## Comportamiento esperado
+
+- Ser respetuoso y amable con todos
+- Aceptar críticas constructivas
+- Enfocarse en lo mejor para la comunidad
+- Mostrar empatía hacia otros miembros
+
+## Comportamiento inaceptable
+
+- Lenguaje ofensivo o insultos
+- Acoso de cualquier tipo
+- Publicar información privada de otros
+- Cualquier conducta que se considere inapropiada
+
+## Aplicación
+
+Los casos de comportamiento abusivo pueden ser reportados abriendo un Issue privado o contactando a los mantenedores del proyecto.
+
+Los mantenedores tienen el derecho de eliminar comentarios, commits, o contribuciones que no respeten este código.
+
+## Atribución
+
+Este Código de Conducta está adaptado del [Contributor Covenant](https://www.contributor-covenant.org), versión 2.1.

package/CONTRIBUTING.md

@@ -0,0 +1,39 @@
+# Cómo contribuir a NexicScript
+
+¡Gracias por querer contribuir! NexicScript es un proyecto abierto y toda ayuda es bienvenida.
+
+## Formas de contribuir
+
+- 🐛 Reportar bugs abriendo un Issue
+- 💡 Proponer nuevas funcionalidades
+- 🔧 Enviar Pull Requests con mejoras
+- 📖 Mejorar la documentación
+- 🌍 Traducir documentación
+
+## Proceso para contribuir
+
+1. Haz fork del repositorio
+2. Crea una rama: git checkout -b mi-mejora
+3. Haz tus cambios
+4. Haz commit: git commit -m "Descripción clara del cambio"
+5. Haz push: git push origin mi-mejora
+6. Abre un Pull Request
+
+## Estilo de código
+
+- Usa 2 espacios para indentar
+- Nombres de variables en camelCase
+- Comentarios en español o inglés
+- Prueba tus cambios con los ejemplos en /ejemplos
+
+## Reportar bugs
+
+Abre un Issue con:
+- Versión de NexicScript
+- Sistema operativo
+- Código .nxs que produce el error
+- Mensaje de error completo
+
+## Código de conducta
+
+Lee nuestro [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) antes de contribuir.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NexicScript
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# NexicScript
+
+> Lenguaje de programación minimalista para bots, web y bases de datos.
+
+```nxs
+fn saludar(nombre)
+  "Hola, " + nombre
+
+print(saludar("Mundo"))
+```
+
+## Instalación
+
+```bash
+npm install -g nexicscript
+```
+
+## Uso
+
+```bash
+nexic mi_programa.nxs
+```
+
+## Características
+
+- Sin punto y coma
+- Sin llaves — bloques por indentación
+- Módulos integrados: `discord`, `web`, `db`
+- Sin dependencias externas para proyectos simples
+- Archivos `.nxs`
+
+## Ejemplos
+
+```nxs
+// Variables
+let nombre = "Bot"
+const puerto = 8080
+
+// Funciones
+fn sumar(a, b)
+  a + b
+
+// Listas y objetos
+let usuarios = ["Ana", "Luis"]
+let config = { puerto: 8080, debug: true }
+
+// Discord bot
+import discord
+discord.conectar("TOKEN")
+discord.on("mensaje") fn(msg)
+  if msg.contenido == "!hola"
+    discord.enviar(msg.canal, "Hola!")
+
+// Servidor web
+import web
+let srv = web.crearServidor fn(req)
+  web.responder(req, 200, "OK")
+srv.iniciar(8080)
+
+// Base de datos
+import db
+db.conectar("datos.db")
+db.insertar("usuarios", { nombre: "Ana", edad: 28 })
+```
+
+## Licencia
+
+MIT

package/SECURITY.md

@@ -0,0 +1,27 @@
+# Seguridad de NexicScript
+
+## Reportar una vulnerabilidad
+
+Si encuentras una vulnerabilidad de seguridad en NexicScript, **NO** abras un Issue público.
+
+En su lugar, repórtala de forma privada a:
+- Email: security@nexicscript.dev
+- O usa GitHub Private Vulnerability Reporting
+
+## Qué reportar
+
+- Errores en el intérprete que permitan ejecutar código malicioso
+- Vulnerabilidades en los módulos integrados (discord, web, db)
+- Cualquier comportamiento inesperado que comprometa la seguridad
+
+## Tiempo de respuesta
+
+Nos comprometemos a responder en menos de 72 horas.
+
+## Versiones soportadas
+
+| Versión | Soporte de seguridad |
+|---------|----------------------|
+| 0.1.x   | ✅ Activa            |
+
+Gracias por ayudar a mantener NexicScript seguro.

package/bin/nexic.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs  = require('fs')
+const path = require('path')
+const { ejecutarCodigo } = require('../src/index')
+
+const args = process.argv.slice(2)
+
+if (args.length === 0) {
+  console.log(`
+  ███╗   ██╗███████╗██╗  ██╗██╗ ██████╗███████╗ ██████╗██████╗ ██╗██████╗ ████████╗
+  ████╗  ██║██╔════╝╚██╗██╔╝██║██╔════╝██╔════╝██╔════╝██╔══██╗██║██╔══██╗╚══██╔══╝
+  ██╔██╗ ██║█████╗   ╚███╔╝ ██║██║     ███████╗██║     ██████╔╝██║██████╔╝   ██║   
+  ██║╚██╗██║██╔══╝   ██╔██╗ ██║██║     ╚════██║██║     ██╔══██╗██║██╔═══╝    ██║   
+  ██║ ╚████║███████╗██╔╝ ██╗██║╚██████╗███████║╚██████╗██║  ██║██║██║        ██║   
+  ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝╚═╝ ╚═════╝╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝╚═╝        ╚═╝   
+
+  NexicScript v0.1.0
+  Uso: nexic <archivo.nxs>
+  `)
+  process.exit(0)
+}
+
+const archivo = args[0]
+
+if (!archivo.endsWith('.nxs')) {
+  console.error('[NexicScript] Los archivos deben tener extensión .nxs')
+  process.exit(1)
+}
+
+if (!fs.existsSync(archivo)) {
+  console.error(`[NexicScript] Archivo no encontrado: ${archivo}`)
+  process.exit(1)
+}
+
+const codigo = fs.readFileSync(archivo, 'utf8')
+
+try {
+  ejecutarCodigo(codigo)
+} catch (e) {
+  console.error(e.message)
+  process.exit(1)
+}

package/ejemplos/bot.nxs

@@ -0,0 +1,13 @@
+// Bot de Discord en NexicScript
+import discord
+
+discord.conectar("TU_TOKEN_AQUI")
+
+discord.on("mensaje") fn(msg)
+  if msg.contenido == "!hola"
+    discord.enviar(msg.canal, "Hola! Soy un bot hecho con NexicScript")
+
+  if msg.contenido == "!version"
+    discord.enviar(msg.canal, "NexicScript v0.1.0")
+
+print("Bot iniciado y escuchando...")

package/ejemplos/hola.nxs

@@ -0,0 +1,45 @@
+// Ejemplo básico de NexicScript
+let nombre = "NexicScript"
+const version = "0.1.0"
+
+fn saludar(quien)
+  "Hola desde " + quien + " v" + version
+
+print(saludar(nombre))
+
+// Listas y bucles
+let frutas = ["manzana", "pera", "uva"]
+
+for fruta in frutas
+  print("Fruta: " + fruta)
+
+// Condicional
+let x = 42
+
+if x > 100
+  print("Grande")
+else if x > 10
+  print("Mediano: " + x)
+else
+  print("Pequeño")
+
+// Objetos
+let usuario = {
+  nombre: "Ana"
+  edad: 28
+  activo: true
+}
+
+print("Usuario: " + usuario.nombre + ", edad: " + usuario.edad)
+
+// Try / catch
+fn dividir(a, b)
+  if b == 0
+    throw "No se puede dividir entre cero"
+  a / b
+
+try
+  print("10 / 2 = " + dividir(10, 2))
+  print("10 / 0 = " + dividir(10, 0))
+catch error
+  print("Error atrapado: " + error)

package/ejemplos/web.nxs

@@ -0,0 +1,17 @@
+// Servidor web en NexicScript
+import web
+import db
+
+db.conectar("datos.db")
+
+let manejador = fn(req)
+  if req.ruta == "/"
+    web.responder(req, 200, "Bienvenido a NexicScript")
+  else if req.ruta == "/usuarios"
+    let lista = db.consultar("usuarios", fn(u) true)
+    web.responder(req, 200, lista)
+  else
+    web.responder(req, 404, "Página no encontrada")
+
+let servidor = web.crearServidor(manejador)
+servidor.iniciar(8080)

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "nexicscript",
+  "version": "0.1.0",
+  "description": "NexicScript - Lenguaje de programación minimalista para bots, web y bases de datos",
+  "main": "src/index.js",
+  "bin": {
+    "nexic": "./bin/nexic.js"
+  },
+  "scripts": {
+    "test": "node bin/nexic.js ejemplos/hola.nxs"
+  },
+  "keywords": ["nexicscript", "lenguaje", "discord", "web", "db"],
+  "author": "NexicScript Team",
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const { lexer }       = require('./lexer')
+const { parsear }     = require('./parser')
+const { interpretar } = require('./interpreter')
+
+function ejecutarCodigo(codigo) {
+  const tokens = lexer(codigo)
+  const ast    = parsear(tokens)
+  return interpretar(ast)
+}
+
+module.exports = { ejecutarCodigo }

package/src/interpreter.js

@@ -0,0 +1,334 @@
+'use strict'
+
+class ReturnSignal { constructor(v) { this.valor = v } }
+class ThrowSignal  { constructor(v) { this.valor = v } }
+
+class Entorno {
+  constructor(padre = null) {
+    this.vars = new Map()
+    this.padre = padre
+  }
+
+  obtener(nombre) {
+    if (this.vars.has(nombre)) return this.vars.get(nombre)
+    if (this.padre) return this.padre.obtener(nombre)
+    throw new Error(`[NexicScript] Variable '${nombre}' no definida`)
+  }
+
+  definir(nombre, valor) {
+    this.vars.set(nombre, valor)
+  }
+
+  asignar(nombre, valor) {
+    if (this.vars.has(nombre)) { this.vars.set(nombre, valor); return }
+    if (this.padre) { this.padre.asignar(nombre, valor); return }
+    throw new Error(`[NexicScript] Variable '${nombre}' no definida`)
+  }
+}
+
+class Funcion {
+  constructor(nombre, params, cuerpo, entorno) {
+    this.nombre  = nombre
+    this.params  = params
+    this.cuerpo  = cuerpo
+    this.entorno = entorno
+  }
+}
+
+function crearEntornoGlobal() {
+  const env = new Entorno()
+
+  // Funciones nativas
+  env.definir('print',  (...args) => { console.log(...args.map(nxsStr)); return null })
+  env.definir('largo',  (v) => v.length ?? 0)
+  env.definir('texto',  (v) => nxsStr(v))
+  env.definir('numero', (v) => Number(v))
+  env.definir('tipo',   (v) => typeof v)
+
+  // Módulo discord (simulado — conectar con discord.js en producción)
+  env.definir('discord', {
+    _listeners: {},
+    conectar(token) { console.log(`[discord] Conectando con token: ${token.slice(0,8)}...`) },
+    on(evento, fn) { this._listeners[evento] = fn },
+    enviar(canal, mensaje) { console.log(`[discord] → #${canal}: ${mensaje}`) },
+    _simular(evento, datos) {
+      if (this._listeners[evento]) this._listeners[evento](datos)
+    }
+  })
+
+  // Módulo web (simulado — conectar con http en producción)
+  env.definir('web', {
+    crearServidor(manejador) {
+      const srv = {
+        _manejador: manejador,
+        iniciar: function(puerto) { console.log(`[web] Servidor escuchando en puerto ${puerto}`) },
+        _simular: function(ruta) {
+          const req = { ruta }
+          this._manejador(req)
+        }
+      }
+      return srv
+    },
+    responder(req, codigo, cuerpo) {
+      console.log(`[web] ${codigo} ${req.ruta} → ${nxsStr(cuerpo)}`)
+    }
+  })
+
+  // Módulo db (simulado — conectar con SQLite/PostgreSQL en producción)
+  env.definir('db', {
+    _datos: {},
+    _url: null,
+    conectar(url) { this._url = url; console.log(`[db] Conectado a: ${url}`) },
+    insertar(tabla, obj) {
+      if (!this._datos[tabla]) this._datos[tabla] = []
+      this._datos[tabla].push({ ...obj })
+      console.log(`[db] Insertado en '${tabla}':`, obj)
+    },
+    consultar(tabla, filtro) {
+      const rows = this._datos[tabla] || []
+      return typeof filtro === 'function' ? rows.filter(filtro) : rows
+    },
+    actualizar(tabla, filtro, cambios) {
+      const rows = this._datos[tabla] || []
+      rows.forEach((r, i) => { if (filtro(r)) this._datos[tabla][i] = { ...r, ...cambios } })
+    },
+    eliminar(tabla, filtro) {
+      this._datos[tabla] = (this._datos[tabla] || []).filter(r => !filtro(r))
+    }
+  })
+
+  return env
+}
+
+function nxsStr(v) {
+  if (v === null || v === undefined) return 'null'
+  if (typeof v === 'object' && !Array.isArray(v)) return JSON.stringify(v)
+  if (Array.isArray(v)) return '[' + v.map(nxsStr).join(', ') + ']'
+  return String(v)
+}
+
+function ejecutarBloque(stmts, env) {
+  let ultimo = null
+  for (const s of stmts) {
+    ultimo = ejecutar(s, env)
+    if (ultimo instanceof ReturnSignal || ultimo instanceof ThrowSignal) return ultimo
+  }
+  return ultimo
+}
+
+function ejecutar(nodo, env) {
+  if (!nodo) return null
+
+  switch (nodo.tipo) {
+    case 'Programa':
+      return ejecutarBloque(nodo.cuerpo, env)
+
+    case 'DeclVar': {
+      const val = evaluar(nodo.valor, env)
+      env.definir(nodo.nombre, val)
+      return null
+    }
+
+    case 'DeclFn': {
+      const fn = new Funcion(nodo.nombre, nodo.params, nodo.cuerpo, env)
+      if (nodo.nombre) env.definir(nodo.nombre, fn)
+      return fn
+    }
+
+    case 'Export': {
+      const resultado = ejecutar(nodo.decl, env)
+      if (nodo.decl.nombre) env.definir('__export__' + nodo.decl.nombre, resultado)
+      return resultado
+    }
+
+    case 'Import': {
+      // Módulos integrados ya están en el entorno global
+      // Para módulos propios se extendería aquí
+      try {
+        const modulo = env.obtener(nodo.nombre)
+        return modulo
+      } catch {
+        throw new Error(`[NexicScript] Módulo '${nodo.nombre}' no encontrado`)
+      }
+    }
+
+    case 'ExprStmt':
+      return evaluar(nodo.expr, env)
+
+    case 'If': {
+      const cond = evaluar(nodo.condicion, env)
+      if (cond) {
+        return ejecutarBloque(nodo.entonces, env)
+      } else if (nodo.sino) {
+        if (nodo.sino.tipo === 'If') return ejecutar(nodo.sino, env)
+        return ejecutarBloque(nodo.sino.cuerpo, env)
+      }
+      return null
+    }
+
+    case 'While': {
+      let res = null
+      while (evaluar(nodo.condicion, env)) {
+        res = ejecutarBloque(nodo.cuerpo, env)
+        if (res instanceof ReturnSignal || res instanceof ThrowSignal) return res
+      }
+      return res
+    }
+
+    case 'For': {
+      const lista = evaluar(nodo.lista, env)
+      let res = null
+      for (const item of lista) {
+        const loopEnv = new Entorno(env)
+        loopEnv.definir(nodo.variable, item)
+        res = ejecutarBloque(nodo.cuerpo, loopEnv)
+        if (res instanceof ReturnSignal || res instanceof ThrowSignal) return res
+      }
+      return res
+    }
+
+    case 'Try': {
+      try {
+        const res = ejecutarBloque(nodo.intentar, env)
+        if (res instanceof ThrowSignal) {
+          const catchEnv = new Entorno(env)
+          catchEnv.definir(nodo.errorVar, res.valor)
+          return ejecutarBloque(nodo.capturar, catchEnv)
+        }
+        return res
+      } catch (e) {
+        const catchEnv = new Entorno(env)
+        catchEnv.definir(nodo.errorVar, e.message)
+        return ejecutarBloque(nodo.capturar, catchEnv)
+      }
+    }
+
+    case 'Throw':
+      return new ThrowSignal(evaluar(nodo.valor, env))
+
+    case 'Return':
+      return new ReturnSignal(nodo.valor ? evaluar(nodo.valor, env) : null)
+
+    default:
+      return evaluar(nodo, env)
+  }
+}
+
+function evaluar(nodo, env) {
+  switch (nodo.tipo) {
+    case 'Numero':   return nodo.valor
+    case 'Texto':    return nodo.valor
+    case 'Booleano': return nodo.valor
+    case 'Nulo':     return null
+
+    case 'Identificador':
+      return env.obtener(nodo.nombre)
+
+    case 'Lista':
+      return nodo.elementos.map(e => evaluar(e, env))
+
+    case 'Objeto': {
+      const obj = {}
+      for (const { clave, valor } of nodo.pares) obj[clave] = evaluar(valor, env)
+      return obj
+    }
+
+    case 'Acceso': {
+      const obj = evaluar(nodo.objeto, env)
+      if (obj === null || obj === undefined)
+        throw new Error(`[NexicScript] No se puede acceder a '${nodo.propiedad}' de null`)
+      const val = obj[nodo.propiedad]
+      if (typeof val === 'function') return val.bind(obj)
+      if (val instanceof Funcion) return val
+      return val
+    }
+
+    case 'Indice': {
+      const obj = evaluar(nodo.objeto, env)
+      const idx = evaluar(nodo.indice, env)
+      return obj[idx]
+    }
+
+    case 'BinOp': {
+      const i = evaluar(nodo.izq, env)
+      const d = evaluar(nodo.der, env)
+      switch (nodo.op) {
+        case '+':  return typeof i === 'string' || typeof d === 'string' ? nxsStr(i) + nxsStr(d) : i + d
+        case '-':  return i - d
+        case '*':  return i * d
+        case '/':  return i / d
+        case '==': return i === d
+        case '!=': return i !== d
+        case '>':  return i > d
+        case '<':  return i < d
+        case '>=': return i >= d
+        case '<=': return i <= d
+        case 'and': return i && d
+        case 'or':  return i || d
+      }
+    }
+
+    case 'Unario': {
+      const v = evaluar(nodo.valor, env)
+      if (nodo.op === '-') return -v
+      if (nodo.op === 'not') return !v
+    }
+
+    case 'Asignacion': {
+      const val = evaluar(nodo.valor, env)
+      if (nodo.objetivo.tipo === 'Identificador') {
+        env.asignar(nodo.objetivo.nombre, val)
+      } else if (nodo.objetivo.tipo === 'Acceso') {
+        const obj = evaluar(nodo.objetivo.objeto, env)
+        obj[nodo.objetivo.propiedad] = val
+      }
+      return val
+    }
+
+    case 'Llamada': {
+      const fn = evaluar(nodo.fn, env)
+      const args = nodo.args.map(a => evaluar(a, env))
+
+      if (typeof fn === 'function') {
+        // Wrap any NexicScript Funcion args as JS callables for native modules
+        const jsArgs = args.map(a => {
+          if (a instanceof Funcion) {
+            return (...innerArgs) => {
+              const fnEnv = new Entorno(a.entorno)
+              a.params.forEach((p, i) => fnEnv.definir(p, innerArgs[i] ?? null))
+              const res = ejecutarBloque(a.cuerpo, fnEnv)
+              if (res instanceof ReturnSignal) return res.valor
+              return res
+            }
+          }
+          return a
+        })
+        return fn(...jsArgs)
+      }
+
+      if (fn instanceof Funcion) {
+        const fnEnv = new Entorno(fn.entorno)
+        fn.params.forEach((p, i) => fnEnv.definir(p, args[i] ?? null))
+        const res = ejecutarBloque(fn.cuerpo, fnEnv)
+        if (res instanceof ReturnSignal) return res.valor
+        if (res instanceof ThrowSignal) throw new Error(nxsStr(res.valor))
+        return res
+      }
+
+      throw new Error(`[NexicScript] '${nodo.fn.nombre || nodo.fn.propiedad}' no es una función`)
+    }
+
+    case 'DeclFn':
+      return ejecutar(nodo, env)
+
+    default:
+      return ejecutar(nodo, env)
+  }
+}
+
+function interpretar(ast) {
+  const env = crearEntornoGlobal()
+  return ejecutar(ast, env)
+}
+
+module.exports = { interpretar }

package/src/lexer.js

@@ -0,0 +1,159 @@
+'use strict'
+
+const PALABRAS_CLAVE = new Set([
+  'let', 'const', 'fn', 'import', 'export', 'from',
+  'if', 'else', 'for', 'in', 'while',
+  'try', 'catch', 'throw', 'return',
+  'true', 'false', 'null'
+])
+
+const TIPOS = {
+  // Literales
+  NUMERO:       'NUMERO',
+  TEXTO:        'TEXTO',
+  BOOLEANO:     'BOOLEANO',
+  NULO:         'NULO',
+  // Identificadores
+  IDENTIFICADOR:'IDENTIFICADOR',
+  PALABRA_CLAVE:'PALABRA_CLAVE',
+  // Operadores
+  IGUAL:        'IGUAL',        // =
+  IGUAL_IGUAL:  'IGUAL_IGUAL',  // ==
+  NO_IGUAL:     'NO_IGUAL',     // !=
+  MAYOR:        'MAYOR',        // >
+  MENOR:        'MENOR',        // <
+  MAYOR_IGUAL:  'MAYOR_IGUAL',  // >=
+  MENOR_IGUAL:  'MENOR_IGUAL',  // <=
+  MAS:          'MAS',          // +
+  MENOS:        'MENOS',        // -
+  POR:          'POR',          // *
+  ENTRE:        'ENTRE',        // /
+  Y:            'Y',            // and
+  O:            'O',            // or
+  NO:           'NO',           // not
+  // Puntuación
+  PAREN_IZQ:    'PAREN_IZQ',    // (
+  PAREN_DER:    'PAREN_DER',    // )
+  LLAVE_IZQ:    'LLAVE_IZQ',    // {
+  LLAVE_DER:    'LLAVE_DER',    // }
+  CORCHETE_IZQ: 'CORCHETE_IZQ', // [
+  CORCHETE_DER: 'CORCHETE_DER', // ]
+  COMA:         'COMA',         // ,
+  PUNTO:        'PUNTO',        // .
+  DOS_PUNTOS:   'DOS_PUNTOS',   // :
+  // Estructura
+  NUEVA_LINEA:  'NUEVA_LINEA',
+  INDENTAR:     'INDENTAR',     // bloque entra
+  DESINDENTAR:  'DESINDENTAR',  // bloque sale
+  FIN:          'FIN',
+}
+
+function lexer(codigo) {
+  const tokens = []
+  const lineas = codigo.split('\n')
+  const pilaIndentacion = [0]
+
+  for (let numLinea = 0; numLinea < lineas.length; numLinea++) {
+    const linea = lineas[numLinea]
+
+    // Ignorar líneas vacías y comentarios
+    const lineaSinEspacios = linea.trimEnd()
+    if (lineaSinEspacios === '' || lineaSinEspacios.trimStart().startsWith('//')) continue
+
+    // Contar espacios al inicio
+    let espacios = 0
+    while (espacios < linea.length && linea[espacios] === ' ') espacios++
+
+    const indentActual = pilaIndentacion[pilaIndentacion.length - 1]
+
+    if (espacios > indentActual) {
+      pilaIndentacion.push(espacios)
+      tokens.push({ tipo: TIPOS.INDENTAR, valor: null, linea: numLinea + 1 })
+    } else {
+      while (espacios < pilaIndentacion[pilaIndentacion.length - 1]) {
+        pilaIndentacion.pop()
+        tokens.push({ tipo: TIPOS.DESINDENTAR, valor: null, linea: numLinea + 1 })
+      }
+    }
+
+    // Tokenizar la línea
+    let i = espacios
+    while (i < linea.length) {
+      // Saltar espacios
+      if (linea[i] === ' ') { i++; continue }
+
+      // Comentario inline
+      if (linea[i] === '/' && linea[i+1] === '/') break
+
+      // Número
+      if (/[0-9]/.test(linea[i])) {
+        let num = ''
+        while (i < linea.length && /[0-9.]/.test(linea[i])) num += linea[i++]
+        tokens.push({ tipo: TIPOS.NUMERO, valor: parseFloat(num), linea: numLinea + 1 })
+        continue
+      }
+
+      // Texto con comillas dobles o simples
+      if (linea[i] === '"' || linea[i] === "'") {
+        const comilla = linea[i++]
+        let texto = ''
+        while (i < linea.length && linea[i] !== comilla) texto += linea[i++]
+        i++ // cerrar comilla
+        tokens.push({ tipo: TIPOS.TEXTO, valor: texto, linea: numLinea + 1 })
+        continue
+      }
+
+      // Identificador o palabra clave
+      if (/[a-zA-Z_]/.test(linea[i])) {
+        let nombre = ''
+        while (i < linea.length && /[a-zA-Z0-9_]/.test(linea[i])) nombre += linea[i++]
+        if (nombre === 'true' || nombre === 'false') {
+          tokens.push({ tipo: TIPOS.BOOLEANO, valor: nombre === 'true', linea: numLinea + 1 })
+        } else if (nombre === 'null') {
+          tokens.push({ tipo: TIPOS.NULO, valor: null, linea: numLinea + 1 })
+        } else if (PALABRAS_CLAVE.has(nombre)) {
+          tokens.push({ tipo: TIPOS.PALABRA_CLAVE, valor: nombre, linea: numLinea + 1 })
+        } else {
+          tokens.push({ tipo: TIPOS.IDENTIFICADOR, valor: nombre, linea: numLinea + 1 })
+        }
+        continue
+      }
+
+      // Operadores y puntuación
+      const doble = linea.slice(i, i+2)
+      if (doble === '==') { tokens.push({ tipo: TIPOS.IGUAL_IGUAL, valor: '==', linea: numLinea + 1 }); i+=2; continue }
+      if (doble === '!=') { tokens.push({ tipo: TIPOS.NO_IGUAL,    valor: '!=', linea: numLinea + 1 }); i+=2; continue }
+      if (doble === '>=') { tokens.push({ tipo: TIPOS.MAYOR_IGUAL, valor: '>=', linea: numLinea + 1 }); i+=2; continue }
+      if (doble === '<=') { tokens.push({ tipo: TIPOS.MENOR_IGUAL, valor: '<=', linea: numLinea + 1 }); i+=2; continue }
+
+      const simple = linea[i]
+      const mapaSimple = {
+        '=': TIPOS.IGUAL, '>': TIPOS.MAYOR, '<': TIPOS.MENOR,
+        '+': TIPOS.MAS, '-': TIPOS.MENOS, '*': TIPOS.POR, '/': TIPOS.ENTRE,
+        '(': TIPOS.PAREN_IZQ, ')': TIPOS.PAREN_DER,
+        '{': TIPOS.LLAVE_IZQ, '}': TIPOS.LLAVE_DER,
+        '[': TIPOS.CORCHETE_IZQ, ']': TIPOS.CORCHETE_DER,
+        ',': TIPOS.COMA, '.': TIPOS.PUNTO, ':': TIPOS.DOS_PUNTOS,
+      }
+      if (mapaSimple[simple]) {
+        tokens.push({ tipo: mapaSimple[simple], valor: simple, linea: numLinea + 1 })
+        i++; continue
+      }
+
+      throw new Error(`[NexicScript] Carácter desconocido '${linea[i]}' en línea ${numLinea + 1}`)
+    }
+
+    tokens.push({ tipo: TIPOS.NUEVA_LINEA, valor: null, linea: numLinea + 1 })
+  }
+
+  // Cerrar indentaciones abiertas
+  while (pilaIndentacion.length > 1) {
+    pilaIndentacion.pop()
+    tokens.push({ tipo: TIPOS.DESINDENTAR, valor: null, linea: -1 })
+  }
+
+  tokens.push({ tipo: TIPOS.FIN, valor: null, linea: -1 })
+  return tokens
+}
+
+module.exports = { lexer, TIPOS }

package/src/parser.js

@@ -0,0 +1,352 @@
+'use strict'
+
+const { TIPOS } = require('./lexer')
+
+class Parser {
+  constructor(tokens) {
+    this.tokens = tokens
+    this.pos = 0
+  }
+
+  actual() { return this.tokens[this.pos] }
+  siguiente() { return this.tokens[this.pos + 1] }
+
+  consumir(tipo, valor) {
+    const t = this.actual()
+    if (tipo && t.tipo !== tipo) {
+      throw new Error(`[NexicScript] Se esperaba ${tipo} pero se encontró ${t.tipo} ('${t.valor}') en línea ${t.linea}`)
+    }
+    if (valor !== undefined && t.valor !== valor) {
+      throw new Error(`[NexicScript] Se esperaba '${valor}' pero se encontró '${t.valor}' en línea ${t.linea}`)
+    }
+    this.pos++
+    return t
+  }
+
+  saltarLineas() {
+    while (this.actual().tipo === TIPOS.NUEVA_LINEA) this.pos++
+  }
+
+  // Salta líneas nuevas, INDENTAR y DESINDENTAR (para dentro de {} y [])
+  saltarEstructura() {
+    while ([TIPOS.NUEVA_LINEA, TIPOS.INDENTAR, TIPOS.DESINDENTAR].includes(this.actual().tipo)) this.pos++
+  }
+
+  parsear() {
+    const stmts = []
+    this.saltarLineas()
+    while (this.actual().tipo !== TIPOS.FIN) {
+      stmts.push(this.stmt())
+      this.saltarLineas()
+    }
+    return { tipo: 'Programa', cuerpo: stmts }
+  }
+
+  stmt() {
+    const t = this.actual()
+
+    if (t.tipo === TIPOS.PALABRA_CLAVE) {
+      switch (t.valor) {
+        case 'let':    return this.declVar(false)
+        case 'const':  return this.declVar(true)
+        case 'fn':     return this.declFn()
+        case 'export': return this.declExport()
+        case 'import': return this.declImport()
+        case 'if':     return this.declIf()
+        case 'while':  return this.declWhile()
+        case 'for':    return this.declFor()
+        case 'try':    return this.declTry()
+        case 'throw':  return this.declThrow()
+        case 'return': return this.declReturn()
+      }
+    }
+
+    return this.exprStmt()
+  }
+
+  declVar(esConst) {
+    this.consumir(TIPOS.PALABRA_CLAVE)
+    const nombre = this.consumir(TIPOS.IDENTIFICADOR).valor
+    this.consumir(TIPOS.IGUAL)
+    const valor = this.expr()
+    this.saltarLineas()
+    return { tipo: 'DeclVar', nombre, valor, esConst }
+  }
+
+  declFn() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'fn')
+    const nombre = this.actual().tipo === TIPOS.IDENTIFICADOR ? this.consumir(TIPOS.IDENTIFICADOR).valor : null
+    this.consumir(TIPOS.PAREN_IZQ)
+    const params = []
+    while (this.actual().tipo !== TIPOS.PAREN_DER) {
+      params.push(this.consumir(TIPOS.IDENTIFICADOR).valor)
+      if (this.actual().tipo === TIPOS.COMA) this.consumir(TIPOS.COMA)
+    }
+    this.consumir(TIPOS.PAREN_DER)
+    const cuerpo = this.bloque()
+    return { tipo: 'DeclFn', nombre, params, cuerpo }
+  }
+
+  declExport() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'export')
+    const decl = this.stmt()
+    return { tipo: 'Export', decl }
+  }
+
+  declImport() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'import')
+    const nombre = this.consumir(TIPOS.IDENTIFICADOR).valor
+    let desde = null
+    if (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'from') {
+      this.consumir(TIPOS.PALABRA_CLAVE, 'from')
+      desde = this.consumir(TIPOS.TEXTO).valor
+    }
+    this.saltarLineas()
+    return { tipo: 'Import', nombre, desde }
+  }
+
+  declIf() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'if')
+    const condicion = this.expr()
+    const entonces = this.bloque()
+    let sino = null
+    if (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'else') {
+      this.consumir(TIPOS.PALABRA_CLAVE, 'else')
+      if (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'if') {
+        sino = this.declIf()
+      } else {
+        sino = { tipo: 'Bloque', cuerpo: this.bloque() }
+      }
+    }
+    return { tipo: 'If', condicion, entonces, sino }
+  }
+
+  declWhile() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'while')
+    const condicion = this.expr()
+    const cuerpo = this.bloque()
+    return { tipo: 'While', condicion, cuerpo }
+  }
+
+  declFor() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'for')
+    const variable = this.consumir(TIPOS.IDENTIFICADOR).valor
+    this.consumir(TIPOS.PALABRA_CLAVE, 'in')
+    const lista = this.expr()
+    const cuerpo = this.bloque()
+    return { tipo: 'For', variable, lista, cuerpo }
+  }
+
+  declTry() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'try')
+    const intentar = this.bloque()
+    this.consumir(TIPOS.PALABRA_CLAVE, 'catch')
+    const errorVar = this.consumir(TIPOS.IDENTIFICADOR).valor
+    const capturar = this.bloque()
+    return { tipo: 'Try', intentar, errorVar, capturar }
+  }
+
+  declThrow() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'throw')
+    const valor = this.expr()
+    this.saltarLineas()
+    return { tipo: 'Throw', valor }
+  }
+
+  declReturn() {
+    this.consumir(TIPOS.PALABRA_CLAVE, 'return')
+    const valor = this.actual().tipo === TIPOS.NUEVA_LINEA ? null : this.expr()
+    this.saltarLineas()
+    return { tipo: 'Return', valor }
+  }
+
+  bloque() {
+    this.saltarLineas()
+    if (this.actual().tipo !== TIPOS.INDENTAR) {
+      // bloque de una sola expresión en la misma línea
+      const s = this.stmt()
+      return [s]
+    }
+    this.consumir(TIPOS.INDENTAR)
+    const stmts = []
+    this.saltarLineas()
+    while (this.actual().tipo !== TIPOS.DESINDENTAR && this.actual().tipo !== TIPOS.FIN) {
+      stmts.push(this.stmt())
+      this.saltarLineas()
+    }
+    if (this.actual().tipo === TIPOS.DESINDENTAR) this.consumir(TIPOS.DESINDENTAR)
+    return stmts
+  }
+
+  exprStmt() {
+    const e = this.expr()
+    this.saltarLineas()
+    return { tipo: 'ExprStmt', expr: e }
+  }
+
+  expr() { return this.exprAsignacion() }
+
+  exprAsignacion() {
+    const izq = this.exprOr()
+    if (this.actual().tipo === TIPOS.IGUAL) {
+      this.consumir(TIPOS.IGUAL)
+      const der = this.expr()
+      return { tipo: 'Asignacion', objetivo: izq, valor: der }
+    }
+    return izq
+  }
+
+  exprOr() {
+    let izq = this.exprAnd()
+    while (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'or') {
+      this.consumir(TIPOS.PALABRA_CLAVE)
+      izq = { tipo: 'BinOp', op: 'or', izq, der: this.exprAnd() }
+    }
+    return izq
+  }
+
+  exprAnd() {
+    let izq = this.exprIgualdad()
+    while (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'and') {
+      this.consumir(TIPOS.PALABRA_CLAVE)
+      izq = { tipo: 'BinOp', op: 'and', izq, der: this.exprIgualdad() }
+    }
+    return izq
+  }
+
+  exprIgualdad() {
+    let izq = this.exprComparacion()
+    while ([TIPOS.IGUAL_IGUAL, TIPOS.NO_IGUAL].includes(this.actual().tipo)) {
+      const op = this.consumir(this.actual().tipo).valor
+      izq = { tipo: 'BinOp', op, izq, der: this.exprComparacion() }
+    }
+    return izq
+  }
+
+  exprComparacion() {
+    let izq = this.exprSuma()
+    while ([TIPOS.MAYOR, TIPOS.MENOR, TIPOS.MAYOR_IGUAL, TIPOS.MENOR_IGUAL].includes(this.actual().tipo)) {
+      const op = this.consumir(this.actual().tipo).valor
+      izq = { tipo: 'BinOp', op, izq, der: this.exprSuma() }
+    }
+    return izq
+  }
+
+  exprSuma() {
+    let izq = this.exprProducto()
+    while ([TIPOS.MAS, TIPOS.MENOS].includes(this.actual().tipo)) {
+      const op = this.consumir(this.actual().tipo).valor
+      izq = { tipo: 'BinOp', op, izq, der: this.exprProducto() }
+    }
+    return izq
+  }
+
+  exprProducto() {
+    let izq = this.exprUnario()
+    while ([TIPOS.POR, TIPOS.ENTRE].includes(this.actual().tipo)) {
+      const op = this.consumir(this.actual().tipo).valor
+      izq = { tipo: 'BinOp', op, izq, der: this.exprUnario() }
+    }
+    return izq
+  }
+
+  exprUnario() {
+    if (this.actual().tipo === TIPOS.MENOS) {
+      this.consumir(TIPOS.MENOS)
+      return { tipo: 'Unario', op: '-', valor: this.exprUnario() }
+    }
+    if (this.actual().tipo === TIPOS.PALABRA_CLAVE && this.actual().valor === 'not') {
+      this.consumir(TIPOS.PALABRA_CLAVE)
+      return { tipo: 'Unario', op: 'not', valor: this.exprUnario() }
+    }
+    return this.exprLlamada()
+  }
+
+  exprLlamada() {
+    let expr = this.exprPrimaria()
+    while (true) {
+      if (this.actual().tipo === TIPOS.PAREN_IZQ) {
+        this.consumir(TIPOS.PAREN_IZQ)
+        const args = []
+        while (this.actual().tipo !== TIPOS.PAREN_DER) {
+          args.push(this.expr())
+          if (this.actual().tipo === TIPOS.COMA) this.consumir(TIPOS.COMA)
+        }
+        this.consumir(TIPOS.PAREN_DER)
+        expr = { tipo: 'Llamada', fn: expr, args }
+      } else if (this.actual().tipo === TIPOS.PUNTO) {
+        this.consumir(TIPOS.PUNTO)
+        const prop = this.consumir(TIPOS.IDENTIFICADOR).valor
+        expr = { tipo: 'Acceso', objeto: expr, propiedad: prop }
+      } else if (this.actual().tipo === TIPOS.CORCHETE_IZQ) {
+        this.consumir(TIPOS.CORCHETE_IZQ)
+        const indice = this.expr()
+        this.consumir(TIPOS.CORCHETE_DER)
+        expr = { tipo: 'Indice', objeto: expr, indice }
+      } else {
+        break
+      }
+    }
+    return expr
+  }
+
+  exprPrimaria() {
+    const t = this.actual()
+
+    if (t.tipo === TIPOS.NUMERO)   { this.pos++; return { tipo: 'Numero',   valor: t.valor } }
+    if (t.tipo === TIPOS.TEXTO)    { this.pos++; return { tipo: 'Texto',    valor: t.valor } }
+    if (t.tipo === TIPOS.BOOLEANO) { this.pos++; return { tipo: 'Booleano', valor: t.valor } }
+    if (t.tipo === TIPOS.NULO)     { this.pos++; return { tipo: 'Nulo',     valor: null    } }
+
+    if (t.tipo === TIPOS.IDENTIFICADOR) {
+      this.pos++
+      return { tipo: 'Identificador', nombre: t.valor }
+    }
+
+    if (t.tipo === TIPOS.PALABRA_CLAVE && t.valor === 'fn') {
+      return this.declFn()
+    }
+
+    if (t.tipo === TIPOS.PAREN_IZQ) {
+      this.consumir(TIPOS.PAREN_IZQ)
+      const e = this.expr()
+      this.consumir(TIPOS.PAREN_DER)
+      return e
+    }
+
+    if (t.tipo === TIPOS.CORCHETE_IZQ) {
+      this.consumir(TIPOS.CORCHETE_IZQ)
+      const elementos = []
+      while (this.actual().tipo !== TIPOS.CORCHETE_DER) {
+        elementos.push(this.expr())
+        if (this.actual().tipo === TIPOS.COMA) this.consumir(TIPOS.COMA)
+      }
+      this.consumir(TIPOS.CORCHETE_DER)
+      return { tipo: 'Lista', elementos }
+    }
+
+    if (t.tipo === TIPOS.LLAVE_IZQ) {
+      this.consumir(TIPOS.LLAVE_IZQ)
+      this.saltarEstructura()
+      const pares = []
+      while (this.actual().tipo !== TIPOS.LLAVE_DER) {
+        const clave = this.consumir(TIPOS.IDENTIFICADOR).valor
+        this.consumir(TIPOS.DOS_PUNTOS)
+        const valor = this.expr()
+        pares.push({ clave, valor })
+        this.saltarEstructura()
+        if (this.actual().tipo === TIPOS.COMA) { this.consumir(TIPOS.COMA); this.saltarEstructura() }
+      }
+      this.consumir(TIPOS.LLAVE_DER)
+      return { tipo: 'Objeto', pares }
+    }
+
+    throw new Error(`[NexicScript] Token inesperado '${t.valor}' (${t.tipo}) en línea ${t.linea}`)
+  }
+}
+
+function parsear(tokens) {
+  return new Parser(tokens).parsear()
+}
+
+module.exports = { parsear }