@dramxx/brolang 0.1.0

package/bin/bro.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+const { spawn } = require('child_process')
+const repl = require('repl')
+
+const { transpile, substituteKeywords } = require('../src/transpiler')
+const { buildRuntimeContext } = require('../src/runtime')
+const { version } = require('../package.json')
+
+// ── ANSI colors ───────────────────────────────────────────────────────────────
+const red   = (s) => `\x1b[31m${s}\x1b[0m`
+const green = (s) => `\x1b[32m${s}\x1b[0m`
+const cyan  = (s) => `\x1b[1;36m${s}\x1b[0m`
+const gray  = (s) => `\x1b[90m${s}\x1b[0m`
+
+// ── CLI entry ─────────────────────────────────────────────────────────────────
+const [,, cmd, ...args] = process.argv
+
+const HELP = `
+BroLang ${version} — JavaScript for people who peaked in 1997
+
+Usage: bro <command> [options]
+
+Commands:
+  run <file>             Transpile and execute a .bro file
+  build <file> [-o out]  Transpile a .bro file to JavaScript
+  check <file>           Check a .bro file for transpile errors
+  repl                   Start an interactive BroLang REPL
+
+Options:
+  -v, --version          Show version
+  -h, --help             Show this help
+`.trim()
+
+if (!cmd || cmd === '-h' || cmd === '--help') {
+  console.log(HELP)
+  process.exit(0)
+}
+
+if (cmd === '-v' || cmd === '--version') {
+  console.log(version)
+  process.exit(0)
+}
+
+if      (cmd === 'run')   runFile(args[0])
+else if (cmd === 'build') buildFile(args)
+else if (cmd === 'check') checkFile(args[0])
+else if (cmd === 'repl')  startRepl()
+else {
+  console.error(red(`bro: unknown command '${cmd}'. Run 'bro --help' for usage.`))
+  process.exit(1)
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function resolveFile(file) {
+  if (!file) {
+    console.error(red('bro: no file specified'))
+    process.exit(1)
+  }
+  let p = path.resolve(file)
+  if (!fs.existsSync(p) && !file.endsWith('.bro')) {
+    p = path.resolve(file + '.bro')
+  }
+  if (!fs.existsSync(p)) {
+    console.error(red(`bro: file not found: ${file}`))
+    process.exit(1)
+  }
+  return p
+}
+
+// ── commands ──────────────────────────────────────────────────────────────────
+
+function runFile(file) {
+  const filePath = resolveFile(file)
+  const source = fs.readFileSync(filePath, 'utf8')
+
+  let js
+  try {
+    js = transpile(source)
+  } catch (err) {
+    console.error(red('transpile error:'), err.message)
+    process.exit(1)
+  }
+
+  const hasModuleSyntax = /^(?:import|export)\s/m.test(js)
+  const ext = hasModuleSyntax ? '.mjs' : '.js'
+  const tmp = path.join(path.dirname(filePath), `__bro_${process.pid}_${Date.now()}${ext}`)
+
+  fs.writeFileSync(tmp, js, 'utf8')
+
+  const child = spawn(process.execPath, [tmp], { stdio: 'inherit' })
+  child.on('exit', (code, signal) => {
+    fs.unlink(tmp, () => {})
+    if (signal) process.kill(process.pid, signal)
+    else process.exit(code ?? 0)
+  })
+  child.on('error', (err) => {
+    console.error(red('run error:'), err.message)
+    fs.unlink(tmp, () => {})
+    process.exit(1)
+  })
+}
+
+function buildFile(args) {
+  let file = null
+  let out = null
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '-o' || args[i] === '--out') && args[i + 1]) {
+      out = args[++i]
+    } else if (!file) {
+      file = args[i]
+    }
+  }
+
+  const filePath = resolveFile(file)
+  const source = fs.readFileSync(filePath, 'utf8')
+
+  let js
+  try {
+    js = transpile(source)
+  } catch (err) {
+    console.error(red('transpile error:'), err.message)
+    process.exit(1)
+  }
+
+  const outPath = out ? path.resolve(out) : filePath.replace(/\.bro$/, '.js')
+  fs.writeFileSync(outPath, js, 'utf8')
+  console.log(green('built:'), outPath)
+}
+
+function checkFile(file) {
+  const filePath = resolveFile(file)
+  const source = fs.readFileSync(filePath, 'utf8')
+  try {
+    transpile(source)
+    console.log(green(`✓ ${file} — looks good, bro`))
+  } catch (err) {
+    console.error(red(`✗ ${file} — ${err.message}`))
+    process.exit(1)
+  }
+}
+
+function startRepl() {
+  console.log(cyan('BroLang REPL') + gray('  (.exit to quit)\n'))
+
+  const rtFns = buildRuntimeContext()
+
+  const r = repl.start({
+    prompt: cyan('bro> '),
+    useGlobal: true,
+    ignoreUndefined: true,
+  })
+
+  Object.assign(r.context, rtFns)
+
+  const origEval = r.eval
+  r.eval = function broEval(input, ctx, filename, cb) {
+    origEval.call(r, substituteKeywords(input), ctx, filename, cb)
+  }
+}

package/examples/classes.bro

@@ -0,0 +1,43 @@
+// classes.bro — OOP but make it bro
+
+crew Animal {
+  setup(name, sound) {
+    me.name = name
+    me.sound = sound
+  }
+
+  speak() {
+    fuckoff me.name + " says " + me.sound
+  }
+
+  static describe() {
+    fuckoff "Animals are cool bro"
+  }
+}
+
+crew Dog extends Animal {
+  setup(name) {
+    super(name, "woof")
+    me.tricks = []
+  }
+
+  learn(trick) {
+    me.tricks.stuffin(trick)
+  }
+
+  showoff() {
+    sus (me.tricks.howmany === 0) {
+      spam(me.name + " doesn't know any tricks yet, sad")
+      fuckoff
+    }
+    spam(me.name + " knows: " + me.tricks.glue(", "))
+  }
+}
+
+lilbro dog = fresh Dog("Rex")
+spam(dog.speak())
+dog.learn("sit")
+dog.learn("roll over")
+dog.learn("vibe")
+dog.showoff()
+spam(Animal.describe())

package/examples/hello.bro

@@ -0,0 +1,46 @@
+// hello.bro — the classic first program, but make it bro
+
+bro greet(name) {
+  fuckoff "Yo, " + name + "! Welcome to BroLang."
+}
+
+lilbro name = "Chad"
+spam(greet(name))
+
+// Arrays
+lilbro nums = [1, 2, 3, 4, 5]
+lilbro doubled = nums.cook(bro(n) { fuckoff n * 2 })
+lilbro evens   = nums.keeponly(bro(n) { fuckoff n % 2 === 0 })
+lilbro total   = nums.smashdown(bro(acc, n) { fuckoff acc + n }, 0)
+
+spam("doubled:", doubled)
+spam("evens:",   evens)
+spam("total:",   total)
+spam("count:",   nums.howmany)
+
+// Control flow
+sus (total > 10) {
+  spam("big number energy")
+} nah sus (total > 5) {
+  spam("mid number energy")
+} nah {
+  spam("smol number energy")
+}
+
+// Loop
+grind(lilbro i = 0; i < 3; i++) {
+  spam("lap", i)
+}
+
+// Error handling
+bro riskyBusiness() {
+  yolo {
+    yeet fresh Error("something broke lol")
+  } lol(err) {
+    omfg("caught:", err.message)
+  } anyway {
+    spam("tried my best")
+  }
+}
+
+riskyBusiness()

package/examples/promise.bro

@@ -0,0 +1,6 @@
+lilbro p = fresh pinkyswear(bro(win, fail) {
+  win("sorted!")
+})
+
+p.thendo(bro(v) { spam(v) })
+ .otherwise(bro(e) { omfg(e) })

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@dramxx/brolang",
+  "version": "0.1.0",
+  "description": "JavaScript transpiler for people who peaked in 1997",
+  "license": "MIT",
+  "author": "dmaxx",
+  "keywords": [
+    "brolang",
+    "transpiler",
+    "javascript",
+    "language",
+    "cli",
+    "bro"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dramxx/brolang.git"
+  },
+  "homepage": "https://github.com/dramxx/brolang#readme",
+  "bugs": {
+    "url": "https://github.com/dramxx/brolang/issues"
+  },
+  "files": [
+    "bin",
+    "src",
+    "examples",
+    "README.md"
+  ],
+  "bin": {
+    "bro": "./bin/bro.js"
+  },
+  "scripts": {
+    "test": "node test/transpiler.test.js"
+  }
+}

package/src/keywords.js

@@ -0,0 +1,67 @@
+'use strict'
+
+// Multi-word patterns — checked FIRST, only horizontal whitespace is skipped
+// between parts (no newline-crossing to avoid surprises).
+// Format: [broLangPattern, jsEquivalent]
+const MULTI_WORD_MAP = [
+  ['nocap bro', 'async function'],
+  ['nah sus',   'else if'],
+]
+
+// Single-word keyword substitutions.
+// With word-boundary matching, ordering only matters to break ties on prefix
+// overlaps — there are none here, so order is just for readability.
+const KEYWORD_MAP = [
+  // Declarations
+  ['lilbro',      'let'],
+  ['crew',        'class'],
+  ['setup',       'constructor'],
+  ['fresh',       'new'],
+
+  // Functions / async
+  ['bro',         'function'],
+  ['nocap',       'async'],
+  ['holdmybeer',  'await'],
+  ['fuckoff',     'return'],
+
+  // Control flow
+  ['sus',         'if'],
+  ['nah',         'else'],
+  ['pickone',     'switch'],
+  ['when',        'case'],
+  ['whatever',    'default'],
+
+  // Loops
+  ['nosyping',    'for'],
+  ['vibing',      'for'],
+  ['grind',       'for'],
+  ['keepgoing',   'while'],
+  ['doitonce',    'do'],
+  ['gtfo',        'break'],
+  ['peace',       'break'],
+  ['skip',        'continue'],
+
+  // Error handling
+  ['yolo',        'try'],
+  ['lol',         'catch'],
+  ['anyway',      'finally'],
+  // 'yeet' is handled separately (throw vs delete heuristic)
+
+  // Modules
+  ['shareall',    'export default'],
+  ['yoink',       'import'],
+  ['share',       'export'],
+
+  // Operators / misc
+  ['ispartof',    'instanceof'],
+  ['wtf',         'typeof'],
+  ['me',          'this'],
+
+  // Literals
+  ['cool',        'true'],
+  ['notcool',     'false'],
+  ['shit',        'null'],
+  ['idk',         'undefined'],
+]
+
+module.exports = { KEYWORD_MAP, MULTI_WORD_MAP }

package/src/runtime.js

@@ -0,0 +1,169 @@
+'use strict'
+
+// The runtime is injected as a plain JS block at the top of every transpiled file.
+// It's self-contained (no require/import) so the output works standalone.
+const RUNTIME_CODE = `
+/* ── BroLang Runtime ── */
+const spam          = (...a) => console.log(...a)
+const omfg          = (...a) => console.error(...a)
+const omg           = (...a) => console.warn(...a)
+const spreadshit    = (...a) => console.table(...a)
+const debugshit     = (...a) => console.debug(...a)
+const clearshit     = ()     => console.clear()
+const timeshit      = (l)    => console.time(l)
+const timeshitdone  = (l)    => console.timeEnd(l)
+
+const laterbruh     = (fn, ms) => setTimeout(fn, ms)
+const keepspamming  = (fn, ms) => setInterval(fn, ms)
+const nevermind     = (id)     => clearTimeout(id)
+const shutup        = (id)     => clearInterval(id)
+
+const dice          = ()        => Math.random()
+const lowball       = (n)       => Math.floor(n)
+const highball      = (n)       => Math.ceil(n)
+const ballpark      = (n)       => Math.round(n)
+const bigbro        = (...a)    => Math.max(...a)
+const smolbro       = (...a)    => Math.min(...a)
+const nominus       = (n)       => Math.abs(n)
+const whatroot      = (n)       => Math.sqrt(n)
+const tothepower    = (b, e)    => Math.pow(b, e)
+const PI            = Math.PI
+
+const listkeys      = (o)       => Object.keys(o)
+const listvals      = (o)       => Object.values(o)
+const listpairs     = (o)       => Object.entries(o)
+const mash          = (t, ...s) => Object.assign(t, ...s)
+const frozensolid   = (o)       => Object.freeze(o)
+const sealitup      = (o)       => Object.seal(o)
+
+const textify       = (v)       => JSON.stringify(v)
+const textifypretty = (v, n=2)  => JSON.stringify(v, null, n)
+const untext        = (s)       => JSON.parse(s)
+
+const isalist       = (x)       => Array.isArray(x)
+const isnothing     = (x)       => x === null || x === undefined
+const exists        = (x)       => x !== null && x !== undefined
+const freshobj      = (proto)   => Object.create(proto)
+
+const grab          = (...a)    => fetch(...a)
+
+const pinkyswear = Object.assign(
+  function(fn) { return new Promise(fn) },
+  {
+    sorted:      (v) => Promise.resolve(v),
+    noped:       (e) => Promise.reject(e),
+    waitforall:  (a) => Promise.all(a),
+    firstfinish: (a) => Promise.race(a),
+    nodrama:     (a) => Promise.allSettled(a),
+  }
+)
+
+// DOM helpers (no-op stubs in Node; real functions in browser)
+const findthisshit  = typeof document !== 'undefined' ? (id)  => document.getElementById(id)  : () => null
+const findme        = typeof document !== 'undefined' ? (sel) => document.querySelector(sel)   : () => null
+const findallofthem = typeof document !== 'undefined' ? (sel) => document.querySelectorAll(sel): () => []
+const makething     = typeof document !== 'undefined' ? (tag) => document.createElement(tag)   : () => null
+
+// Array prototype extensions
+Array.prototype.cook        = Array.prototype.map
+Array.prototype.keeponly    = Array.prototype.filter
+Array.prototype.smashdown   = Array.prototype.reduce
+Array.prototype.vibecheck   = Array.prototype.forEach
+Array.prototype.findone     = Array.prototype.find
+Array.prototype.findindex   = Array.prototype.findIndex
+Array.prototype.gotthis     = Array.prototype.includes
+Array.prototype.allfine     = Array.prototype.every
+Array.prototype.anyonegood  = Array.prototype.some
+Array.prototype.stuffin     = Array.prototype.push
+Array.prototype.yeetlast    = Array.prototype.pop
+Array.prototype.stufffirst  = Array.prototype.unshift
+Array.prototype.yeetfirst   = Array.prototype.shift
+Array.prototype.glue        = Array.prototype.join
+Array.prototype.cutout      = Array.prototype.slice
+Array.prototype.surgery     = Array.prototype.splice
+Array.prototype.sortitout   = Array.prototype.sort
+Array.prototype.flipit      = Array.prototype.reverse
+Array.prototype.flatten     = Array.prototype.flat
+Array.prototype.flatmash    = Array.prototype.flatMap
+Object.defineProperty(Array.prototype, 'howmany', {
+  get() { return this.length },
+  configurable: true,
+})
+
+// String prototype extensions
+String.prototype.cutout     = String.prototype.slice
+String.prototype.chop       = String.prototype.split
+String.prototype.cleanitup  = String.prototype.trim
+String.prototype.cleanfront = String.prototype.trimStart
+String.prototype.cleanback  = String.prototype.trimEnd
+String.prototype.gotthis    = String.prototype.includes
+String.prototype.swapout    = String.prototype.replace
+String.prototype.swapallout = String.prototype.replaceAll
+String.prototype.smallify   = String.prototype.toLowerCase
+String.prototype.bigify     = String.prototype.toUpperCase
+String.prototype.startswith = String.prototype.startsWith
+String.prototype.endswith   = String.prototype.endsWith
+String.prototype.pad        = String.prototype.padStart
+String.prototype.padback    = String.prototype.padEnd
+String.prototype.atpos      = String.prototype.charAt
+String.prototype.numcode    = String.prototype.charCodeAt
+Object.defineProperty(String.prototype, 'howlong', {
+  get() { return this.length },
+  configurable: true,
+})
+
+// Promise prototype extensions
+Promise.prototype.thendo       = Promise.prototype.then
+Promise.prototype.otherwise    = Promise.prototype.catch
+Promise.prototype.nomatterwhat = Promise.prototype.finally
+
+// DOM prototype extensions (browser only)
+if (typeof EventTarget !== 'undefined') {
+  EventTarget.prototype.whenthishappens = EventTarget.prototype.addEventListener
+  EventTarget.prototype.stoplistening   = EventTarget.prototype.removeEventListener
+}
+if (typeof Node !== 'undefined') {
+  Node.prototype.addtodoc = Node.prototype.appendChild
+  Node.prototype.kickout  = Node.prototype.removeChild
+}
+if (typeof Element !== 'undefined') {
+  Element.prototype.attr    = Element.prototype.setAttribute
+  Element.prototype.getattr = Element.prototype.getAttribute
+  Object.defineProperty(Element.prototype, 'text', {
+    get() { return this.textContent },
+    set(v) { this.textContent = v },
+    configurable: true,
+  })
+  Object.defineProperty(Element.prototype, 'html', {
+    get() { return this.innerHTML },
+    set(v) { this.innerHTML = v },
+    configurable: true,
+  })
+  Object.defineProperty(Element.prototype, 'classes', {
+    get() { return this.classList },
+    configurable: true,
+  })
+}
+/* ── End BroLang Runtime ── */
+`
+
+function getRuntimeCode() {
+  return RUNTIME_CODE
+}
+
+// Runtime function object for REPL injection (evaluated fresh each call)
+function buildRuntimeContext() {
+  const ctx = {}
+  // Evaluate the runtime block to capture var-declared names
+  // We rebuild it using Function so const → visible in returned ctx
+  const lines = RUNTIME_CODE
+    .split('\n')
+    .filter(l => /^\s*const\s+/.test(l))
+    .map(l => l.trim())
+  const names = lines.map(l => l.match(/^const\s+(\w+)/)[1])
+  const body = RUNTIME_CODE + '\nreturn {' + names.join(',') + '}'
+  // eslint-disable-next-line no-new-func
+  return new Function(body)()
+}
+
+module.exports = { getRuntimeCode, buildRuntimeContext }