gofront 0.0.3 → 0.0.5

package/src/codegen/statements.js

@@ -1,5 +1,7 @@
 // CodeGen statement methods — installed as a mixin on CodeGen.prototype.
 
+import { isComplex } from "../typechecker/types.js";
+
 export const statementGenMethods = {
 	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);
@@ -45,10 +47,16 @@ export const statementGenMethods = {
 				const redecls = stmt.lhs.map((e) => !!e._redecl);
 				const anyRedecl = redecls.some((r) => r);
 				if (lhs.length === 1) {
+					const isBoxed = this._boxedVars.has(lhs[0]);
+					const val = isBoxed && !redecls[0] ? `{ value: ${rhs[0]} }` : rhs[0];
 					if (redecls[0]) {
-						this.line(`${lhs[0]} = ${rhs[0]};`);
+						if (isBoxed) {
+							this.line(`${lhs[0]}.value = ${rhs[0]};`);
+						} else {
+							this.line(`${lhs[0]} = ${val};`);
+						}
 					} else {
-						this.line(`let ${lhs[0]} = ${rhs[0]};`);
+						this.line(`let ${lhs[0]} = ${val};`);
 					}
 				} else if (!anyRedecl) {
 					// All new: let [a, b] = ...
@@ -75,14 +83,109 @@ export const statementGenMethods = {
 			}
 
 			case "AssignStmt": {
+				// Complex compound assignment: z += w → z = z + w (with complex codegen)
+				if (
+					stmt.op !== "=" &&
+					stmt.lhs.length === 1 &&
+					stmt.rhs.length === 1 &&
+					isComplex(stmt.lhs[0]._type)
+				) {
+					const lhsStr = stmt.lhs[0].name ?? this.genExpr(stmt.lhs[0]);
+					const rhsExpr = this._genComplexOperand(stmt.rhs[0]);
+					const baseOp = stmt.op.slice(0, -1); // "+=" → "+"
+					let result;
+					switch (baseOp) {
+						case "+":
+							result = `{ re: ${lhsStr}.re + ${rhsExpr}.re, im: ${lhsStr}.im + ${rhsExpr}.im }`;
+							break;
+						case "-":
+							result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
+							break;
+						case "*":
+							this._usesCmul = true;
+							result = `__cmul(${lhsStr}, ${rhsExpr})`;
+							break;
+						case "/":
+							this._usesCdiv = true;
+							result = `__cdiv(${lhsStr}, ${rhsExpr})`;
+							break;
+						default:
+							result = rhsExpr;
+					}
+					this.line(`${lhsStr} = ${result};`);
+					break;
+				}
+				// comma-ok map index: v, ok = m["key"]
+				if (stmt._commaOkMap) {
+					const rhsNode = stmt.rhs[0];
+					const mapExpr = this.genExpr(rhsNode.expr);
+					const keyExpr = this.genExpr(rhsNode.index);
+					const [vName, okName] = stmt.lhs.map(
+						(e) => e.name ?? this.genExpr(e),
+					);
+					if (vName !== "_") {
+						const zero = rhsNode._mapValueType
+							? this.zeroValueForType(rhsNode._mapValueType)
+							: "undefined";
+						this.line(
+							`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
+						);
+					}
+					if (okName !== "_")
+						this.line(`${okName} = (${keyExpr}) in ${mapExpr};`);
+					break;
+				}
+				// comma-ok type assertion: v, ok = x.(T)
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0]._commaOk
+				) {
+					const val = this.genExpr(stmt.rhs[0]);
+					const [vName, okName] = stmt.lhs.map(
+						(e) => e.name ?? this.genExpr(e),
+					);
+					const tmp = "__ta";
+					this.line(`let ${tmp} = ${val};`);
+					if (vName !== "_") this.line(`${vName} = ${tmp}[0];`);
+					if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
+					break;
+				}
 				const rhs = stmt.rhs.map((e) => this.genExpr(e));
 				for (const e of stmt.lhs) if (e.kind === "IndexExpr") e._lvalue = true;
-				const lhs = stmt.lhs.map((e) => this.genExpr(e));
-				if (lhs.length === 1) {
-					this.line(`${lhs[0]} ${stmt.op} ${rhs[0]};`);
+				const lhs = stmt.lhs.map((e) => {
+					if (
+						e.kind === "Ident" &&
+						e.name !== "_" &&
+						this._boxedVars.has(e.name)
+					)
+						return `${e.name}.value`;
+					return e.name ?? this.genExpr(e);
+				});
+				// Filter out blank identifier assignments entirely
+				const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
+				const active = pairs.filter((p) => p.l !== "_");
+				if (active.length === 0) {
+					// All _ — still need to evaluate rhs for side effects
+					if (rhs.length > 0) this.line(`${rhs[0]};`);
+				} else if (lhs.length === 1) {
+					this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
 				} else {
+					// multi-assign: emit only non-blank targets
 					const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-					this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
+					if (active.length === pairs.length) {
+						this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
+					} else {
+						// Some blanks — use temp and assign only non-blank
+						const tmp = "__t";
+						this.line(`let ${tmp} = ${rhsStr};`);
+						for (let i = 0; i < lhs.length; i++) {
+							if (lhs[i] !== "_") {
+								const src = rhs.length === 1 ? `${tmp}[${i}]` : rhs[i];
+								this.line(`${lhs[i]} ${stmt.op} ${src};`);
+							}
+						}
+					}
 				}
 				break;
 			}
@@ -96,6 +199,21 @@ export const statementGenMethods = {
 				break;
 
 			case "ReturnStmt": {
+				if (this._inIteratorBody) {
+					if (stmt.values.length === 0 && !this.namedReturnVars?.length) {
+						this.line(`${this._iterReturnFlag} = true; return false;`);
+					} else {
+						const vals =
+							stmt.values.length > 0
+								? stmt.values.map((v) => this.genExpr(v))
+								: (this.namedReturnVars ?? []);
+						const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
+						this.line(
+							`${this._iterReturnFlag} = true; ${this._iterReturnVar} = ${stored}; return false;`,
+						);
+					}
+					break;
+				}
 				if (stmt.values.length === 0) {
 					// bare return — emit named return vars if present
 					if (this.namedReturnVars?.length > 0) {
@@ -155,6 +273,16 @@ export const statementGenMethods = {
 				break;
 
 			case "BranchStmt":
+				if (this._inIteratorBody && !stmt.label) {
+					if (stmt.keyword === "break") {
+						this.line(`${this._iterBreakFlag} = true; return false;`);
+						break;
+					}
+					if (stmt.keyword === "continue") {
+						this.line("return true;");
+						break;
+					}
+				}
 				if (stmt.keyword !== "fallthrough")
 					this.line(
 						stmt.label ? `${stmt.keyword} ${stmt.label};` : `${stmt.keyword};`,
@@ -200,14 +328,22 @@ export const statementGenMethods = {
 	},
 
 	genFor(stmt) {
-		// Detect range: init is DefineStmt with rhs[0] being a RangeExpr
+		// Detect range: init is DefineStmt/AssignStmt with rhs[0] being a RangeExpr
 		if (this.isRangeFor(stmt)) {
-			this.genRangeFor(stmt);
+			if (stmt.init.rhs[0]._isIterator) {
+				this.genIteratorFor(stmt);
+			} else {
+				this.genRangeFor(stmt);
+			}
 			return;
 		}
 
-		// for range N { } — no variable, just repeat N times
+		// for range expr — no variable; could be int range or 0-param iterator
 		if (stmt.cond?.kind === "RangeExpr") {
+			if (stmt.cond._isIterator) {
+				this.genIteratorForCond(stmt);
+				return;
+			}
 			const iteree = this.genExpr(stmt.cond.expr);
 			this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
 			this.indented(() => this.genBlock(stmt.body));
@@ -275,11 +411,14 @@ export const statementGenMethods = {
 			(iterType?.kind === "basic" && iterType.name === "string") ||
 			(iterType?.kind === "untyped" && iterType.base === "string")
 		) {
-			// string: for i, ch := range s  → for (const [i, ch] of s.split('').entries())
-			iterExpr =
-				lhs.length === 1
-					? `Array.from(${iteree}).keys()`
-					: `Array.from(${iteree}).entries()`;
+			// string: for i, r := range s  → rune (code point), not JS character
+			// Go spec: iterating a string yields (byte-index, rune) pairs
+			if (lhs.length === 1) {
+				iterExpr = `Array.from(${iteree}).keys()`;
+			} else {
+				// Wrap code points so the value is an integer (rune), not a JS string
+				iterExpr = `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
+			}
 		} else {
 			// slice/array: for i, v := range arr → for (const [i, v] of __s(arr).entries())
 			// null-guard handles nil slices (zero value) gracefully.
@@ -303,6 +442,112 @@ export const statementGenMethods = {
 		this.line("}");
 	},
 
+	genIteratorFor(stmt) {
+		const range = stmt.init.rhs[0];
+		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
+		let iteree = this.genExpr(range.expr);
+		const yieldParams = range._yieldParams;
+
+		// Wrap bare function expressions to avoid "Function statements require a name"
+		if (range.expr.kind === "FuncLit") {
+			iteree = `(${iteree})`;
+		}
+
+		const d = this._iterDepth++;
+		const breakFlag = `__broke${d}`;
+		const retFlag = `__returned${d}`;
+		const retVar = `__retVal${d}`;
+
+		// Yield callback param names (blank vars get _$N to avoid JS syntax error)
+		const cbParams = lhs.map((n, i) => (n === "_" ? `_$${i}` : n));
+
+		this.line("{");
+		this.indented(() => {
+			this.line(`let ${breakFlag} = false;`);
+			this.line(`let ${retFlag} = false;`);
+			this.line(`let ${retVar};`);
+
+			const params = yieldParams.length === 0 ? "" : cbParams.join(", ");
+			this.line(`${iteree}(function(${params}) {`);
+			this.indented(() => {
+				this.line(`if (${breakFlag}) return false;`);
+				const prev = {
+					in: this._inIteratorBody,
+					break: this._iterBreakFlag,
+					ret: this._iterReturnFlag,
+					retVar: this._iterReturnVar,
+				};
+				this._inIteratorBody = true;
+				this._iterBreakFlag = breakFlag;
+				this._iterReturnFlag = retFlag;
+				this._iterReturnVar = retVar;
+
+				this.genBlock(stmt.body);
+
+				this._inIteratorBody = prev.in;
+				this._iterBreakFlag = prev.break;
+				this._iterReturnFlag = prev.ret;
+				this._iterReturnVar = prev.retVar;
+
+				this.line("return true;");
+			});
+			this.line("});");
+			this.line(`if (${retFlag}) return ${retVar};`);
+		});
+		this.line("}");
+		this._iterDepth--;
+	},
+
+	// 0-param iterator: for range iter { body }
+	genIteratorForCond(stmt) {
+		const range = stmt.cond;
+		let iteree = this.genExpr(range.expr);
+
+		if (range.expr.kind === "FuncLit") {
+			iteree = `(${iteree})`;
+		}
+
+		const d = this._iterDepth++;
+		const breakFlag = `__broke${d}`;
+		const retFlag = `__returned${d}`;
+		const retVar = `__retVal${d}`;
+
+		this.line("{");
+		this.indented(() => {
+			this.line(`let ${breakFlag} = false;`);
+			this.line(`let ${retFlag} = false;`);
+			this.line(`let ${retVar};`);
+
+			this.line(`${iteree}(function() {`);
+			this.indented(() => {
+				this.line(`if (${breakFlag}) return false;`);
+				const prev = {
+					in: this._inIteratorBody,
+					break: this._iterBreakFlag,
+					ret: this._iterReturnFlag,
+					retVar: this._iterReturnVar,
+				};
+				this._inIteratorBody = true;
+				this._iterBreakFlag = breakFlag;
+				this._iterReturnFlag = retFlag;
+				this._iterReturnVar = retVar;
+
+				this.genBlock(stmt.body);
+
+				this._inIteratorBody = prev.in;
+				this._iterBreakFlag = prev.break;
+				this._iterReturnFlag = prev.ret;
+				this._iterReturnVar = prev.retVar;
+
+				this.line("return true;");
+			});
+			this.line("});");
+			this.line(`if (${retFlag}) return ${retVar};`);
+		});
+		this.line("}");
+		this._iterDepth--;
+	},
+
 	// Inline a statement as a for-init/post string (no semicolon)
 	stmtInline(stmt) {
 		switch (stmt.kind) {

package/src/codegen.js

@@ -20,6 +20,7 @@
 import { expressionGenMethods } from "./codegen/expressions.js";
 import { buildSourceMap } from "./codegen/source-map.js";
 import { statementGenMethods } from "./codegen/statements.js";
+import { isComplex, isNumeric } from "./typechecker/types.js";
 
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
@@ -38,11 +39,23 @@ export class CodeGen {
 		this.bundledPackages = bundledPackages;
 		this.namedReturnVars = null; // names of current function's named return vars
 		this._srcMappings = []; // { genLine, srcLine } for source map
+		this._boxedVars = new Set(); // address-taken scalar variables that need boxing
 		// Runtime helper usage tracking — only emit helpers that are actually used
 		this._usesLen = false;
 		this._usesAppend = false;
 		this._usesSliceGuard = false;
 		this._usesSprintf = false;
+		this._usesEqual = false;
+		this._usesCmul = false;
+		this._usesCdiv = false;
+		this._usesError = false;
+		this._usesErrorIs = false;
+		// Iterator (range-over-func) context
+		this._inIteratorBody = false;
+		this._iterDepth = 0;
+		this._iterBreakFlag = null;
+		this._iterReturnFlag = null;
+		this._iterReturnVar = null;
 	}
 
 	// ── Output helpers ───────────────────────────────────────────
@@ -120,10 +133,7 @@ export class CodeGen {
 				if (d.name === "init") {
 					const renamed = initCount === 0 ? "init" : `init$${initCount}`;
 					initNames.push(renamed);
-					const saved = d.name;
-					d.name = renamed;
-					this.genFuncDecl(d);
-					d.name = saved;
+					this.genFuncDecl(d, renamed);
 					initCount++;
 				} else {
 					this.genFuncDecl(d);
@@ -149,10 +159,22 @@ export class CodeGen {
 			);
 		if (this._usesSliceGuard)
 			helpers.push("function __s(a) { return a || []; }");
+		if (this._usesEqual)
+			helpers.push(
+				'function __equal(a,b){if(a===b)return true;if(a===null||b===null)return false;if(Array.isArray(a)&&Array.isArray(b)){if(a.length!==b.length)return false;for(let i=0;i<a.length;i++)if(!__equal(a[i],b[i]))return false;return true;}if(typeof a==="object"&&typeof b==="object"){const ka=Object.keys(a),kb=Object.keys(b);if(ka.length!==kb.length)return false;for(const k of ka)if(!__equal(a[k],b[k]))return false;return true;}return false;}',
+			);
+		if (this._usesCmul)
+			helpers.push(
+				"function __cmul(a, b) { return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re }; }",
+			);
+		if (this._usesCdiv)
+			helpers.push(
+				"function __cdiv(a, b) { const d = b.re * b.re + b.im * b.im; return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d }; }",
+			);
 		if (this._usesSprintf)
 			helpers.push(
 				[
-					"function __sprintf(f,...a){let i=0;return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgG%]/g,(m)=>{",
+					"function __sprintf(f,...a){let i=0;return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g,(m)=>{",
 					"if(m==='%%')return'%';const fl=m.slice(1,-1),verb=m.slice(-1),v=a[i++];",
 					"const pad=(s,w,z)=>{w=parseInt(w)||0;if(!w)return s;const p=(z?'0':' ').repeat(Math.max(0,w-s.length));return fl.includes('-')?s+p:p+s;};",
 					"const [,flags,width,prec]=m.match(/^%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)/)||[];",
@@ -160,7 +182,7 @@ export class CodeGen {
 					"switch(verb){",
 					"case's':return pad(String(v==null?'<nil>':v),width,false);",
 					"case'd':return pad(String(Math.trunc(Number(v))),width,zero);",
-					"case'v':return pad(String(v==null?'<nil>':v),width,false);",
+					"case'v':{if(typeof v==='object'&&v!==null&&'re' in v&&'im' in v){const sign=v.im>=0?'+':'';return pad('('+v.re+sign+v.im+'i)',width,false);}return pad(String(v==null?'<nil>':v),width,false);}",
 					"case'f':{const n=Number(v),p=prec!==''?parseInt(prec):6;return pad(n.toFixed(p),width,zero);}",
 					"case't':return pad(String(!!v),width,false);",
 					"case'x':return pad((Number(v)>>>0).toString(16),width,zero);",
@@ -170,10 +192,19 @@ export class CodeGen {
 					"case'q':return pad('\"'+String(v==null?'':v).replace(/\\\\/g,'\\\\\\\\').replace(/\"/g,'\\\\\"')+'\"',width,false);",
 					"case'e':case'E':{const n=Number(v),p=prec!==''?parseInt(prec):6;return pad(n.toExponential(p),width,zero);}",
 					"case'g':case'G':{const n=Number(v);return pad(prec!==''?n.toPrecision(parseInt(prec)):String(n),width,zero);}",
+					"case'w':return pad(String(v==null?'<nil>':typeof v==='object'&&v.Error?v.Error():v),width,false);",
 					"default:return m;}});",
 					"}",
 				].join(""),
 			);
+		if (this._usesError)
+			helpers.push(
+				"function __error(msg, cause) { return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null }; }",
+			);
+		if (this._usesErrorIs)
+			helpers.push(
+				'function __errorIs(err, target) { while (err !== null && err !== undefined) { if (err === target) return true; if (typeof err === "object" && typeof target === "object" && err._msg !== undefined && target._msg !== undefined && err._msg === target._msg) return true; err = err?._cause ?? null; } return false; }',
+			);
 
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
 
@@ -276,18 +307,23 @@ export class CodeGen {
 		const params = decl.params.map((p) => p.name).join(", ");
 		const asyncPrefix = decl.async ? "async " : "";
 		this.line(`${asyncPrefix}${decl.name}(${params}) {`);
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set();
+		this._scanAddressTaken(decl.body);
 		this.indented(() => {
 			if (decl.recvName && decl.recvName !== "_") {
 				this.line(`const ${decl.recvName} = this;`);
 			}
 			this._withNamedReturns(decl, () => this._genBody(decl.body));
 		});
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
 	// ── Function declarations ────────────────────────────────────
 
-	genFuncDecl(decl) {
+	genFuncDecl(decl, nameOverride) {
+		const name = nameOverride ?? decl.name;
 		const params = decl.params
 			.map((p, i) =>
 				p.variadic && i === decl.params.length - 1 ? `...${p.name}` : p.name,
@@ -296,12 +332,16 @@ export class CodeGen {
 		const asyncPrefix = decl.async ? "async " : "";
 		const srcLine = decl._line ?? null;
 		this.line(
-			`${asyncPrefix}function ${decl.name}(${params}) {`,
+			`${asyncPrefix}function ${name}(${params}) {`,
 			srcLine ? srcLine - 1 : null,
 		);
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set();
+		this._scanAddressTaken(decl.body);
 		this.indented(() =>
 			this._withNamedReturns(decl, () => this._genBody(decl.body)),
 		);
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
@@ -354,12 +394,61 @@ export class CodeGen {
 		}
 	}
 
+	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.
+	_scanAddressTaken(node) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) this._scanAddressTaken(child);
+			return;
+		}
+		// &x — the operand ident will have _addressTaken set by typechecker
+		if (node.kind === "Ident" && node._addressTaken) {
+			// Check if the type is a scalar (needs boxing) vs reference type (no boxing)
+			const t = node._type;
+			if (t && !this._isReferenceType(t)) {
+				this._boxedVars.add(node.name);
+			}
+		}
+		// Recurse into FuncLit too — closures may take address of outer vars
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			this._scanAddressTaken(node[key]);
+		}
+	}
+
+	_isReferenceType(t) {
+		if (!t) return false;
+		const base = t.kind === "named" ? t.underlying : t;
+		return (
+			base?.kind === "struct" ||
+			base?.kind === "slice" ||
+			base?.kind === "map" ||
+			base?.kind === "func" ||
+			base?.kind === "interface"
+		);
+	}
+
 	// ── Variable / const declarations ────────────────────────────
 
 	genVarDecl(decl) {
 		for (const spec of decl.decls) {
 			if (spec.value) {
-				const vals = spec.value.map((v) => this.genExpr(v));
+				const vals = spec.value.map((v) => {
+					const js = this.genExpr(v);
+					// Wrap numeric values assigned to complex-typed vars
+					if (
+						spec.type?.name === "complex128" ||
+						spec.type?.name === "complex64"
+					) {
+						if (
+							!isComplex(v._type) &&
+							(isNumeric(v._type) || v._type?.kind === "untyped")
+						) {
+							return `{ re: ${js}, im: 0 }`;
+						}
+					}
+					return js;
+				});
 				if (spec.names.length === 1) {
 					this.line(`let ${spec.names[0]} = ${vals[0]};`);
 				} else {

package/src/dts-parser.js

@@ -74,7 +74,7 @@ export class DtsParser {
 				this.pos += 2;
 				while (!this.eof() && !(this.ch() === "*" && this.ch1() === "/"))
 					this.pos++;
-				this.pos += 2;
+				if (!this.eof()) this.pos += 2;
 				continue;
 			}
 			break;

package/src/index.js

@@ -27,11 +27,11 @@ const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
 import { basename, dirname, join, resolve } from "node:path";
-import { minify } from "terser";
 import { CodeGen } from "./codegen.js";
 import { compileDir } from "./compiler.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
+import { minify } from "./minifier.js";
 import { Parser } from "./parser.js";
 import { isLocalPath, resolveAll, resolveGwDir } from "./resolver.js";
 import { TypeChecker } from "./typechecker.js";
@@ -56,7 +56,8 @@ Usage:
   gofront <input> --check        Type-check only
   gofront <input> --watch        Watch for changes and recompile
   gofront <input> --source-map   Append inline source map to output
-  gofront <input> --minify       Minify output with terser
+  gofront <input> --minify       Minify output
+  gofront <input> --minify --mangle  Minify and mangle identifiers
   gofront <file.go> --ast        Dump AST (debug)
   gofront <file.go> --tokens     Dump tokens (debug)
   gofront init [dir]             Scaffold a new GoFront project
@@ -121,6 +122,7 @@ const dumpTokens = args.includes("--tokens");
 const sourceMap = args.includes("--source-map");
 const watchMode = args.includes("--watch");
 const minifyOutput = args.includes("--minify");
+const mangleOutput = args.includes("--mangle");
 
 // ── Determine input mode ─────────────────────────────────────
 
@@ -232,14 +234,13 @@ function runCompile() {
 
 // ── Minify helper ────────────────────────────────────────────
 
-async function maybeMinify(js) {
+function maybeMinify(js) {
 	if (!minifyOutput) return js;
-	const result = await minify(js, {
-		module: true,
-		compress: true,
-		mangle: true,
-	});
-	return result.code;
+	if (sourceMap) {
+		console.error("gofront: --source-map and --minify cannot be used together");
+		process.exit(1);
+	}
+	return minify(js, { mangle: mangleOutput });
 }
 
 // ── Single-shot mode ─────────────────────────────────────────
@@ -262,7 +263,7 @@ if (!watchMode) {
 
 	let js;
 	try {
-		js = await maybeMinify(result.js);
+		js = maybeMinify(result.js);
 	} catch (e) {
 		console.error(`gofront: minify failed: ${e.message}`);
 		process.exit(1);
@@ -290,11 +291,11 @@ function timestamp() {
 	return new Date().toLocaleTimeString();
 }
 
-async function buildOnce() {
+function buildOnce() {
 	try {
 		const startMs = performance.now();
 		const result = runCompile();
-		const js = await maybeMinify(result.js);
+		const js = maybeMinify(result.js);
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		if (outputFile) {
 			writeFileSync(outputFile, `${js}\n`);

package/src/lexer.js

@@ -8,6 +8,8 @@ export const T = {
 	STRING: "STRING",
 	IDENT: "IDENT",
 
+	IMAG: "IMAG",
+
 	// Keywords
 	FUNC: "func",
 	VAR: "var",
@@ -72,6 +74,7 @@ export const T = {
 	PIPE: "|",
 	CARET: "^",
 	AND_NOT: "&^",
+	TILDE: "~",
 	LSHIFT: "<<",
 	RSHIFT: ">>",
 	ELLIPSIS: "...",
@@ -97,6 +100,7 @@ const SEMI_TRIGGERS = new Set([
 	T.IDENT,
 	T.INT,
 	T.FLOAT,
+	T.IMAG,
 	T.STRING,
 	T.RPAREN,
 	T.RBRACE,
@@ -297,10 +301,20 @@ export class Lexer {
 	}
 
 	readRawString() {
+		const l = this.line,
+			c = this.col;
 		this.advance(); // opening `
 		let s = "";
 		while (this.pos < this.src.length && this.peek() !== "`")
 			s += this.advance();
+		if (this.pos >= this.src.length)
+			throw new LexError(
+				"Unterminated raw string",
+				l,
+				c,
+				this.filename,
+				this.src,
+			);
 		this.advance(); // closing `
 		return s;
 	}
@@ -501,7 +515,13 @@ export class Lexer {
 			// Numbers
 			if (/[0-9]/.test(ch)) {
 				const { n, isFloat } = this.readNumber();
-				this.push(isFloat ? T.FLOAT : T.INT, n, l, c);
+				if (this.src[this.pos] === "i") {
+					this.pos++;
+					this.col++;
+					this.push(T.IMAG, n, l, c);
+				} else {
+					this.push(isFloat ? T.FLOAT : T.INT, n, l, c);
+				}
 				continue;
 			}
 
@@ -574,6 +594,9 @@ export class Lexer {
 					if (this.match("=")) this.push(T.CARET_ASSIGN, "^=", l, c);
 					else this.push(T.CARET, "^", l, c);
 					break;
+				case "~":
+					this.push(T.TILDE, "~", l, c);
+					break;
 				case ":":
 					if (this.match("=")) this.push(T.DEFINE, ":=", l, c);
 					else this.push(T.COLON, ":", l, c);