gofront 0.0.7 → 0.0.9

package/src/codegen.js

@@ -20,6 +20,8 @@
 import { expressionGenMethods } from "./codegen/expressions.js";
 import { buildSourceMap } from "./codegen/source-map.js";
 import { statementGenMethods } from "./codegen/statements.js";
+import { T, Token } from "./lexer.js";
+import { Parser } from "./parser.js";
 import { isComplex, isNumeric } from "./typechecker/types.js";
 
 export class CodeGen {
@@ -52,6 +54,9 @@ export class CodeGen {
 		this._usesCdiv = false;
 		this._usesError = false;
 		this._usesErrorIs = false;
+		this._usesPathClean = false;
+		this._usesTimeFmt = false;
+		this._usesTimeParse = false;
 		// Iterator (range-over-func) context
 		this._inIteratorBody = false;
 		this._iterDepth = 0;
@@ -143,7 +148,7 @@ export class CodeGen {
 			}
 		}
 
-		// Emit functions — rename duplicate init() to init$0, init$1, etc.
+		// Emit functions and templ components
 		let initCount = 0;
 		const initNames = [];
 		for (const d of program.decls) {
@@ -158,6 +163,10 @@ export class CodeGen {
 					this.genFuncDecl(d);
 				}
 				this.blank();
+			} else if (d.kind === "TemplDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
+				this.genTemplDecl(d);
+				this.blank();
 			}
 		}
 
@@ -226,6 +235,47 @@ export class CodeGen {
 			helpers.push(
 				'var __errorIs = __errorIs || function(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 (this._usesPathClean)
+			helpers.push(
+				'var __pathClean = __pathClean || function(p) { if (!p) return "."; const abs = p.startsWith("/"); const parts = p.split("/").reduce((acc, s) => { if (s === "" || s === ".") return acc; if (s === "..") { if (acc.length && acc[acc.length-1] !== "..") acc.pop(); else if (!abs) acc.push(".."); } else acc.push(s); return acc; }, []); return (abs ? "/" : "") + (parts.join("/") || "."); };',
+			);
+		if (this._usesTimeFmt)
+			helpers.push(
+				[
+					"var __timeFmt = __timeFmt || function(d, layout) {",
+					'const pad = (n, w=2) => String(n).padStart(w, "0");',
+					'const DAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];',
+					'const MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];',
+					"return layout.replace(/2006|06|Monday|Mon|January|Jan|01|1|02|2|15|PM|3|04|4|05|5|Z07:00|\\.000|\\.999/g, t => {",
+					"switch(t){",
+					'case "2006": return d.getFullYear();',
+					'case "06": return String(d.getFullYear()).slice(-2);',
+					'case "Monday": return DAYS[d.getDay()];',
+					'case "Mon": return DAYS[d.getDay()].slice(0,3);',
+					'case "January": return MONTHS[d.getMonth()];',
+					'case "Jan": return MONTHS[d.getMonth()].slice(0,3);',
+					'case "01": return pad(d.getMonth()+1);',
+					'case "1": return String(d.getMonth()+1);',
+					'case "02": return pad(d.getDate());',
+					'case "2": return String(d.getDate());',
+					'case "15": return pad(d.getHours());',
+					'case "PM": return d.getHours()<12?"AM":"PM";',
+					'case "3": return String(d.getHours()%12||12);',
+					'case "04": return pad(d.getMinutes());',
+					'case "4": return String(d.getMinutes());',
+					'case "05": return pad(d.getSeconds());',
+					'case "5": return String(d.getSeconds());',
+					'case "Z07:00": { const o=-d.getTimezoneOffset(); return o===0?"Z":(o>0?"+":"-")+pad(Math.floor(Math.abs(o)/60))+":"+pad(Math.abs(o)%60); }',
+					'case ".000": return "."+pad(d.getMilliseconds(),3);',
+					'case ".999": return d.getMilliseconds()>0?"."+String(d.getMilliseconds()).replace(/0+$/,""):"";',
+					"default: return t;}});",
+					"};",
+				].join(""),
+			);
+		if (this._usesTimeParse)
+			helpers.push(
+				'var __timeParse = __timeParse || function(layout, value) { try { const d = new Date(value); if (isNaN(d.getTime())) throw 0; return [{_d:d}, null]; } catch { return [{_d:new Date(0)}, "parsing time: cannot parse"]; } };',
+			);
 
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
 
@@ -248,9 +298,10 @@ export class CodeGen {
 
 	// Returns a source map JSON string for the last generate() call.
 	// sources: string[] of source filenames (relative to the output file).
-	getSourceMap(sources) {
+	// sourcesContent: string[] of original file contents (embedded for DevTools breakpoints).
+	getSourceMap(sources, sourcesContent) {
 		const srcArray = Array.isArray(sources) ? sources : [sources];
-		return buildSourceMap(srcArray, this._srcMappings);
+		return buildSourceMap(srcArray, this._srcMappings, sourcesContent);
 	}
 
 	// ── Type declarations ────────────────────────────────────────
@@ -422,6 +473,277 @@ export class CodeGen {
 		this.line("}");
 	}
 
+	// ── TemplDecl code generation ────────────────────────────────
+
+	genTemplDecl(decl) {
+		const params = decl.params
+			.map((p, i) =>
+				p.variadic && i === decl.params.length - 1 ? `...${p.name}` : p.name,
+			)
+			.join(", ");
+		this.line(`function ${decl.name}(${params}) {`);
+		this.indented(() => {
+			this.line(`return {Mount(___p) {`);
+			this.indented(() => {
+				this._genTemplNodes(decl.body, "___p");
+			});
+			this.line(`}};`);
+		});
+		this.line("}");
+	}
+
+	// Emit mount statements for an array of TemplNodes into parent variable `p`.
+	_genTemplNodes(nodes, p) {
+		if (!nodes || nodes.length === 0) return;
+		if (nodes.length === 1) {
+			this._genTemplNodeMount(nodes[0], p);
+			return;
+		}
+		// Wrap multiple root nodes in a fragment div? No — emit each directly.
+		for (const node of nodes) {
+			this._genTemplNodeMount(node, p);
+		}
+	}
+
+	// Emit JS to mount a single TemplNode onto parent `p`.
+	_genTemplNodeMount(node, p) {
+		switch (node.kind) {
+			case "TemplElement":
+				return this._genTemplElement(node, p);
+			case "TemplText":
+				return this.line(
+					`${p}.appendChild(document.createTextNode(${JSON.stringify(node.value)}));`,
+				);
+			case "TemplExpr":
+				return this.line(
+					`${p}.appendChild(document.createTextNode(String(${this._genTemplTokenExpr(node.tokens)})));`,
+				);
+			case "TemplComponent": {
+				// Special case: @templ.Raw(expr) → insertAdjacentHTML
+				const toks = node.tokens;
+				if (
+					toks.length >= 4 &&
+					toks[0]?.value === "templ" &&
+					toks[1]?.type === T.DOT &&
+					toks[2]?.value === "Raw" &&
+					toks[3]?.type === T.LPAREN
+				) {
+					const argTokens = toks.slice(4, toks.length - 1);
+					const argJs = this._genTemplTokenExpr(argTokens);
+					return this.line(`${p}.insertAdjacentHTML("beforeend", ${argJs});`);
+				}
+				return this.line(
+					`(${this._genTemplTokenCallExpr(node.tokens)}).Mount(${p});`,
+				);
+			}
+			case "TemplChildren":
+				// children is a variadic gom.Node param — mount each child
+				return this.line(
+					`if(typeof children!=="undefined")(Array.isArray(children)?children:[...children]).forEach(___c=>___c?.Mount?.(${p}));`,
+				);
+			case "TemplIf":
+				return this._genTemplIf(node, p);
+			case "TemplFor":
+				return this._genTemplFor(node, p);
+			case "TemplSwitch":
+				return this._genTemplSwitch(node, p);
+			default:
+				break;
+		}
+	}
+
+	_genTemplElement(node, p) {
+		const { tag, attrs, children } = node;
+		const elVar = this._freshVar("e");
+		this.line(
+			`const ${elVar} = document.createElement(${JSON.stringify(tag)});`,
+		);
+		for (const attr of attrs) {
+			this._genTemplAttr(attr, elVar);
+		}
+		this._genTemplNodes(children, elVar);
+		this.line(`${p}.appendChild(${elVar});`);
+	}
+
+	_genTemplAttr(attr, el) {
+		const { name } = attr;
+		if (attr.kind === "static") {
+			if (name === "class") {
+				this.line(`${el}.className = ${JSON.stringify(attr.value)};`);
+			} else {
+				this.line(
+					`${el}.setAttribute(${JSON.stringify(name)}, ${JSON.stringify(attr.value)});`,
+				);
+			}
+		} else if (attr.kind === "expr") {
+			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			if (name === "class") {
+				this.line(`${el}.className = ${exprJs};`);
+			} else {
+				this.line(
+					`${el}.setAttribute(${JSON.stringify(name)}, String(${exprJs}));`,
+				);
+			}
+		} else if (attr.kind === "bool") {
+			this.line(`${el}.setAttribute(${JSON.stringify(name)}, "");`);
+		} else if (attr.kind === "cond-bool") {
+			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			this.line(
+				`if(${exprJs})${el}.setAttribute(${JSON.stringify(name)}, "");`,
+			);
+		}
+	}
+
+	_genTemplIf(node, p) {
+		const condJs = this._genTemplCondTokens(node.condTokens);
+		this.line(`if (${condJs}) {`);
+		this.indented(() => this._genTemplNodes(node.then, p));
+		this._genTemplIfElse(node.else_, p);
+	}
+
+	_genTemplIfElse(else_, p) {
+		if (!else_ || else_.length === 0) {
+			this.line(`}`);
+			return;
+		}
+		if (else_.length === 1 && else_[0].kind === "TemplIf") {
+			const elseIf = else_[0];
+			this.line(`} else if (${this._genTemplCondTokens(elseIf.condTokens)}) {`);
+			this.indented(() => this._genTemplNodes(elseIf.then, p));
+			this._genTemplIfElse(elseIf.else_, p);
+		} else {
+			this.line(`} else {`);
+			this.indented(() => this._genTemplNodes(else_, p));
+			this.line(`}`);
+		}
+	}
+
+	_genTemplSwitch(node, p) {
+		const { exprTokens, cases } = node;
+		if (cases.length === 0) return;
+		const exprJs = this._genTemplTokenExpr(exprTokens);
+		this.line(`switch (${exprJs}) {`);
+		this.indented(() => {
+			for (const c of cases) {
+				const label =
+					c.caseTokens === null
+						? "default"
+						: `case ${this._genTemplTokenExpr(c.caseTokens)}`;
+				this.line(`${label}: {`);
+				this.indented(() => this._genTemplNodes(c.body, p));
+				this.line(`break; }`);
+			}
+		});
+		this.line(`}`);
+	}
+
+	_genTemplFor(node, p) {
+		// stmtTokens include the `for` keyword plus the range clause (no body).
+		// Strip any trailing semicolons (inserted by the Go lexer on newlines),
+		// then add a fake empty body `{ }` so the parser can complete the ForStmt.
+		let tokens = node.stmtTokens;
+		while (tokens.length > 0 && tokens[tokens.length - 1].type === T.SEMICOLON)
+			tokens = tokens.slice(0, -1);
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const lbrace = new Token(T.LBRACE, "{", 1, 1);
+		const rbrace = new Token(T.RBRACE, "}", 1, 1);
+		const semi = new Token(T.SEMICOLON, ";", 1, 1);
+		const withFor =
+			tokens[0]?.type === T.FOR
+				? [...tokens, lbrace, rbrace, semi, eofTok]
+				: [
+						new Token(T.FOR, "for", 1, 1),
+						...tokens,
+						lbrace,
+						rbrace,
+						semi,
+						eofTok,
+					];
+		try {
+			const p2 = new Parser(withFor);
+			const forStmt = p2.parseFor();
+			this._genTemplRangeFor(forStmt, node.body, p);
+		} catch {
+			// Fallback for non-range loops: emit a comment + skip
+			this.line(`/* templ for: ${this._tokensToSource(tokens)} */`);
+		}
+	}
+
+	_genTemplRangeFor(forStmt, templBody, mountParent) {
+		const init = forStmt.init;
+		if (!init?.rhs?.[0] || init.rhs[0].kind !== "RangeExpr") {
+			// Plain for loop (cond-only or three-clause)
+			const condJs = forStmt.cond ? this.genExpr(forStmt.cond) : "true";
+			this.line(`while (${condJs}) {`);
+			this.indented(() => this._genTemplNodes(templBody, mountParent));
+			this.line("}");
+			return;
+		}
+		// Range for: for key, val := range iter
+		const range = init.rhs[0];
+		const iterJs = this.genExpr(range.expr);
+		const lhs = init.lhs.map((e) => e.name ?? "_");
+		const keyName = lhs[0] ?? "_";
+		const valName = lhs[1] ?? null;
+
+		let loopHeader;
+		if (valName === null || valName === undefined) {
+			loopHeader = `for (const ${keyName === "_" ? "_$" : keyName} of ${iterJs}) {`;
+		} else if (keyName === "_" && valName === "_") {
+			loopHeader = `for (const _$ of ${iterJs}) {`;
+		} else if (keyName === "_") {
+			loopHeader = `for (const ${valName} of ${iterJs}) {`;
+		} else if (valName === "_") {
+			loopHeader = `for (const [${keyName}] of Object.entries(${iterJs})) {`;
+		} else {
+			// Default to .entries() for arrays, Object.entries for objects
+			this._usesSliceGuard = true;
+			loopHeader = `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
+		}
+		this.line(loopHeader);
+		this.indented(() => this._genTemplNodes(templBody, mountParent));
+		this.line("}");
+	}
+
+	// Parse a token array as a Go expression and emit JS.
+	_genTemplTokenExpr(tokens) {
+		if (!tokens || tokens.length === 0) return '""';
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...tokens, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	}
+
+	// Parse a token array as a Go call expression and emit JS.
+	_genTemplTokenCallExpr(tokens) {
+		if (!tokens || tokens.length === 0) return "null";
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...tokens, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	}
+
+	// Extract condition JS from condTokens (which may start with `if`).
+	_genTemplCondTokens(tokens) {
+		if (!tokens || tokens.length === 0) return "false";
+		let toks = tokens;
+		if (toks[0]?.type === T.IF) toks = toks.slice(1); // skip `if` keyword
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...toks, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	}
+
+	_tokensToSource(tokens) {
+		return tokens.map((t) => t.value).join(" ");
+	}
+
+	// Fresh variable name counter
+	_freshVar(prefix = "v") {
+		this._templVarCount = (this._templVarCount ?? 0) + 1;
+		return `___${prefix}${this._templVarCount}`;
+	}
+
 	_withNamedReturns(decl, fn) {
 		const named = decl.returnType?._namedReturns;
 		const prev = this.namedReturnVars;
@@ -534,7 +856,10 @@ export class CodeGen {
 				}
 			} else {
 				const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
-				for (const name of spec.names) this.line(`let ${name} = ${zero};`);
+				for (const name of spec.names) {
+					const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
+					this.line(`let ${name} = ${val};`);
+				}
 			}
 		}
 	}

package/src/compiler.js

@@ -15,29 +15,63 @@
 // Cross-package access uses the qualified form: `pkg.Foo`.  The codegen
 // de-qualifies it because the dependency is inlined.
 
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { CodeGen } from "./codegen.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
 import { Parser } from "./parser.js";
 import { isLocalPath, resolveAll, resolveGwDir } from "./resolver.js";
+import { TemplLexer } from "./templ-lexer.js";
+import { TemplParser } from "./templ-parser.js";
 import { TypeChecker } from "./typechecker.js";
 
+// ── Parse cache ──────────────────────────────────────────────
+
+// Map<filePath, { mtime: number, ast: object }>
+const _parseCache = new Map();
+
+export function clearParseCache() {
+	_parseCache.clear();
+}
+
+export function parseCacheSize() {
+	return _parseCache.size;
+}
+
 // ── Helpers ──────────────────────────────────────────────────
 
 function parseFile(filePath) {
+	const mtime = statSync(filePath).mtimeMs;
+	const cached = _parseCache.get(filePath);
+	if (cached && cached.mtime === mtime) return cached.ast;
+
 	const source = readFileSync(filePath, "utf8");
 	const filename = basename(filePath);
 	const tokens = new Lexer(source, filename).tokenize();
 	const ast = new Parser(tokens, filename, source).parse();
 	ast._source = source;
+	_parseCache.set(filePath, { mtime, ast });
+	return ast;
+}
+
+function parseTemplFile(filePath) {
+	const mtime = statSync(filePath).mtimeMs;
+	const cached = _parseCache.get(filePath);
+	if (cached && cached.mtime === mtime) return cached.ast;
+
+	const source = readFileSync(filePath, "utf8");
+	const filename = basename(filePath);
+	const tokens = new TemplLexer(source, filename).tokenize();
+	const ast = new TemplParser(tokens, filename, source).parse();
+	ast._source = source;
+	_parseCache.set(filePath, { mtime, ast });
 	return ast;
 }
 
 function gwFilesIn(dir) {
 	return readdirSync(dir)
-		.filter((f) => f.endsWith(".go"))
+		.filter((f) => f.endsWith(".go") || f.endsWith(".templ"))
 		.sort() // deterministic order
 		.map((f) => join(dir, f));
 }
@@ -58,7 +92,7 @@ export function compileFiles(files, options = {}) {
 	const programs = [];
 	for (const f of files) {
 		try {
-			programs.push(parseFile(f));
+			programs.push(f.endsWith(".templ") ? parseTemplFile(f) : parseFile(f));
 		} catch (e) {
 			parseErrors.push(e.message);
 		}
@@ -170,7 +204,8 @@ export function compileFiles(files, options = {}) {
 	if (options.sourceMap) {
 		const outputDir = options.outputDir ?? fromDir;
 		const sourceFiles = files.map((f) => relative(outputDir, f));
-		const map = codegen.getSourceMap(sourceFiles);
+		const sourcesContent = files.map((f) => readFileSync(f, "utf8"));
+		const map = codegen.getSourceMap(sourceFiles, sourcesContent);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}

package/src/dev-server.js

@@ -10,6 +10,7 @@ const MIME = {
 	".js": "application/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
 	".json": "application/json; charset=utf-8",
+	".go": "text/plain; charset=utf-8",
 	".svg": "image/svg+xml",
 	".png": "image/png",
 	".jpg": "image/jpeg",

package/src/index.js

@@ -232,7 +232,7 @@ function runCompile() {
 	if (sourceMap) {
 		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
 		const srcPath = relative(outputDir, inputPath);
-		const map = cg.getSourceMap(srcPath);
+		const map = cg.getSourceMap(srcPath, [source]);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}
@@ -311,7 +311,7 @@ if (serveMode) {
 	devServer = createDevServer(serveDir, servePort);
 }
 
-function buildOnce() {
+function buildOnce(changedFile = null) {
 	try {
 		const startMs = performance.now();
 		const result = runCompile();
@@ -326,16 +326,19 @@ function buildOnce() {
 			}
 		}
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
+		const changeNote = changedFile ? ` — ${changedFile} changed` : "";
 		if (outputFile) {
 			writeFileSync(outputFile, `${js}\n`);
 			console.error(
-				`[${timestamp()}] gofront: OK — wrote ${outputFile} (${elapsedMs}ms)`,
+				`[${timestamp()}] gofront: OK — wrote ${outputFile} (${elapsedMs}ms${changeNote})`,
 			);
 		} else {
 			// Clear screen then print
 			process.stdout.write("\x1Bc");
 			console.log(js);
-			console.error(`[${timestamp()}] gofront: OK (${elapsedMs}ms)`);
+			console.error(
+				`[${timestamp()}] gofront: OK (${elapsedMs}ms${changeNote})`,
+			);
 		}
 		devServer?.notify();
 	} catch (e) {
@@ -352,9 +355,10 @@ const watchTarget = isDir ? inputPath : dirname(inputPath);
 
 let debounce = null;
 watch(watchTarget, { recursive: true }, (_event, filename) => {
-	if (filename && !filename.endsWith(".go")) return;
+	if (filename && !filename.endsWith(".go") && !filename.endsWith(".templ"))
+		return;
 	clearTimeout(debounce);
-	debounce = setTimeout(() => buildOnce(), 80);
+	debounce = setTimeout(() => buildOnce(filename), 80);
 });
 
 console.error(`[${timestamp()}] gofront: watching ${inputArg} ...`);

package/src/lexer.js

@@ -262,7 +262,7 @@ export class Lexer {
 		const l = this.line,
 			c = this.col;
 		this.advance(); // opening "
-		let s = "";
+		const parts = [];
 		while (this.pos < this.src.length && this.peek() !== '"') {
 			if (this.peek() === "\n") this.err("Unterminated string literal");
 			if (this.peek() === "\\") {
@@ -270,43 +270,42 @@ export class Lexer {
 				const esc = this.advance();
 				switch (esc) {
 					case "n":
-						s += "\n";
+						parts.push("\n");
 						break;
 					case "t":
-						s += "\t";
+						parts.push("\t");
 						break;
 					case "r":
-						s += "\r";
+						parts.push("\r");
 						break;
 					case '"':
-						s += '"';
+						parts.push('"');
 						break;
 					case "\\":
-						s += "\\";
+						parts.push("\\");
 						break;
 					case "0":
-						s += "\0";
+						parts.push("\0");
 						break;
 					default:
-						s += `\\${esc}`;
+						parts.push(`\\${esc}`);
 				}
 			} else {
-				s += this.advance();
+				parts.push(this.advance());
 			}
 		}
 		if (this.pos >= this.src.length)
 			throw new LexError("Unterminated string", l, c, this.filename, this.src);
 		this.advance(); // closing "
-		return s;
+		return parts.join("");
 	}
 
 	readRawString() {
 		const l = this.line,
 			c = this.col;
 		this.advance(); // opening `
-		let s = "";
-		while (this.pos < this.src.length && this.peek() !== "`")
-			s += this.advance();
+		const start = this.pos;
+		while (this.pos < this.src.length && this.peek() !== "`") this.advance();
 		if (this.pos >= this.src.length)
 			throw new LexError(
 				"Unterminated raw string",
@@ -315,8 +314,9 @@ export class Lexer {
 				this.filename,
 				this.src,
 			);
+		const raw = this.src.slice(start, this.pos);
 		this.advance(); // closing `
-		return s;
+		return raw;
 	}
 
 	readRuneLiteral() {

package/src/parser/expressions.js

@@ -365,9 +365,10 @@ export const expressionParserMethods = {
 	},
 
 	parsePrimary() {
-		const line = this.peek().line;
+		const t = this.peek();
 		const expr = this._parsePrimary();
-		if (!expr._line) expr._line = line;
+		if (!expr._line) expr._line = t.line;
+		if (!expr._col) expr._col = t.col;
 		return expr;
 	},
 

package/src/parser/statements.js

@@ -20,10 +20,14 @@ export const statementParserMethods = {
 		const t = this.peek();
 		const stmt = this._parseStmt(t);
 		if (Array.isArray(stmt)) {
-			for (const s of stmt) s._line = t.line;
+			for (const s of stmt) {
+				s._line = t.line;
+				s._col = t.col;
+			}
 			return stmt;
 		}
 		stmt._line = t.line;
+		stmt._col = t.col;
 		return stmt;
 	},
 

package/src/parser.js

@@ -107,7 +107,14 @@ export class Parser {
 			if (Array.isArray(result)) decls.push(...result);
 			else decls.push(result);
 		}
-		return { kind: "Program", pkg, imports, decls, _filename: this.filename };
+		return {
+			kind: "Program",
+			pkg,
+			imports,
+			decls,
+			_filename: this.filename,
+			_source: this.source,
+		};
 	}
 
 	parsePackage() {