gofront 0.0.8 → 1.0.0

package/src/codegen/stdlib/rand.js

@@ -0,0 +1,24 @@
+// CodeGen for Go `math/rand` package.
+
+const RAND_DISPATCH = {
+	Intn: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Int63n: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Int31n: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Float64: () => "Math.random()",
+	Float32: () => "Math.random()",
+	Int: () => "Math.floor(Math.random() * 2147483647)",
+	Int31: () => "Math.floor(Math.random() * 2147483647)",
+	Int63: () => "Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)",
+	Seed: () => "(void 0)",
+	Shuffle: (a) =>
+		`((n, f) => { for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${a[0]}, ${a[1]})`,
+	Perm: (a) =>
+		`((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
+};
+
+export const randMethods = {
+	_genRand(fn, a) {
+		const gen = RAND_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/regexp.js

@@ -0,0 +1,51 @@
+// CodeGen for Go `regexp` package and `*Regexp` methods.
+
+const REGEXP_METHOD = {
+	MatchString: (re, a) => `${re}.test(${a[0]})`,
+	FindString: (re, a) => `(${re}.exec(${a[0]})?.[0] ?? "")`,
+	FindStringIndex: (re, a) =>
+		`((m => m ? [m.index, m.index + m[0].length] : null)(${re}.exec(${a[0]})))`,
+	FindAllString: (re, a) =>
+		`[...${a[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${a[1]} < 0 ? undefined : ${a[1]}).map(m => m[0])`,
+	FindStringSubmatch: (re, a) => `[...(${re}.exec(${a[0]}) ?? [])]`,
+	FindAllStringSubmatch: (re, a) =>
+		`[...${a[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${a[1]} < 0 ? undefined : ${a[1]}).map(m => [...m])`,
+	ReplaceAllString: (re, a) =>
+		`${a[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${a[1]})`,
+	ReplaceAllLiteralString: (re, a) =>
+		`${a[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${a[1]}.replace(/\\$/g, '$$$$'))`,
+	Split: (re, a) =>
+		`${a[0]}.split(${re}).slice(0, ${a[1]} < 0 ? undefined : ${a[1]})`,
+	String: (re) => `${re}.source`,
+};
+
+export const regexpMethods = {
+	_genRegexp(fn, a) {
+		// Converts a Go regexp pattern string (which may contain inline flags like (?i))
+		// into a JS RegExp, extracting the flags into the second constructor argument.
+		const makeRegExp = (pat) =>
+			`((p) => { const m = /^\\(\\?([gimsuy]+)\\)/.exec(p); return m ? new RegExp(p.slice(m[0].length), m[1]) : new RegExp(p); })(${pat})`;
+		switch (fn) {
+			case "MustCompile":
+				return makeRegExp(a()[0]);
+			case "Compile":
+				return `[${makeRegExp(a()[0])}, null]`;
+			case "MatchString": {
+				const [pat, s] = a();
+				return `[new RegExp(${pat}).test(${s}), null]`;
+			}
+			case "QuoteMeta":
+				return `${a()[0]}.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&')`;
+		}
+		return undefined;
+	},
+
+	_genRegexpMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		// *Regexp is a plain JS RegExp — no .value boxing needed
+		const re = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+		const gen = REGEXP_METHOD[method];
+		return gen ? gen(re, args) : undefined;
+	},
+};

package/src/codegen/stdlib/slices.js

@@ -0,0 +1,48 @@
+// CodeGen for Go `slices` package.
+
+const SLICES_DISPATCH = {
+	Contains: (a) => `${a[0]}.includes(${a[1]})`,
+	Index: (a) => `${a[0]}.indexOf(${a[1]})`,
+	Compare: (a) =>
+		`((a, b) => { for (let i = 0; i < a.length && i < b.length; i++) { if (a[i] < b[i]) return -1; if (a[i] > b[i]) return 1; } return a.length - b.length; })(${a[0]}, ${a[1]})`,
+	Sort: (a) => `${a[0]}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`,
+	SortFunc: (a) => `${a[0]}.sort(${a[1]})`,
+	SortStableFunc: (a) => `${a[0]}.sort(${a[1]})`,
+	IsSorted: (a) =>
+		`((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${a[0]})`,
+	IsSortedFunc: (a) =>
+		`((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${a[0]}, ${a[1]})`,
+	Reverse: (a) => `${a[0]}.reverse()`,
+	Max: (a) => `Math.max(...${a[0]})`,
+	Min: (a) => `Math.min(...${a[0]})`,
+	MaxFunc: (a) =>
+		`((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${a[0]}, ${a[1]})`,
+	MinFunc: (a) =>
+		`((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${a[0]}, ${a[1]})`,
+	Clone: (a) => `${a[0]}.slice()`,
+	Compact: (a) =>
+		`((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${a[0]})`,
+	CompactFunc: (a) =>
+		`((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${a[0]}, ${a[1]})`,
+	Concat: (a) => `[].concat(${a.join(", ")})`,
+	Delete: (a) => `[...${a[0]}.slice(0, ${a[1]}), ...${a[0]}.slice(${a[2]})]`,
+	DeleteFunc: (a) => `${a[0]}.filter((v) => !${a[1]}(v))`,
+	Insert: (a) =>
+		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(2).join(", ")}, ...${a[0]}.slice(${a[1]})]`,
+	Replace: (a) =>
+		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(3).join(", ")}, ...${a[0]}.slice(${a[2]})]`,
+	Grow: (a) => `${a[0]}.slice()`,
+	Clip: (a) => `${a[0]}.slice()`,
+};
+
+export const slicesMethods = {
+	_genSlices(fn, a) {
+		if (fn === "Equal") {
+			this._usesEqual = true;
+			const [a1, b1] = a();
+			return `__equal(${a1}, ${b1})`;
+		}
+		const gen = SLICES_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/sort.js

@@ -0,0 +1,28 @@
+// CodeGen for Go `sort` package.
+
+const SORT_DISPATCH = {
+	Ints: (a) => `${a[0]}.sort((a, b) => a - b)`,
+	Float64s: (a) => `${a[0]}.sort((a, b) => a - b)`,
+	Strings: (a) => `${a[0]}.sort()`,
+	Slice: (a) =>
+		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
+	SliceStable: (a) =>
+		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
+	SliceIsSorted: (a) =>
+		`${a[0]}.every((v, i, a) => i === 0 || ${a[1]}(a[i - 1], v))`,
+	Search: (a) =>
+		`((n, f) => { let lo = 0, hi = n; while (lo < hi) { const mid = (lo + hi) >>> 1; if (f(mid)) hi = mid; else lo = mid + 1; } return lo; })(${a[0]}, ${a[1]})`,
+	IntsAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+	Float64sAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+	StringsAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+};
+
+export const sortMethods = {
+	_genSort(fn, a) {
+		const gen = SORT_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/strconv.js

@@ -0,0 +1,30 @@
+// CodeGen for Go `strconv` package.
+
+const STRCONV_DISPATCH = {
+	Itoa: (a) => `String(${a[0]})`,
+	Atoi: (a) =>
+		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}) | 0, null])`,
+	FormatBool: (a) => `String(${a[0]})`,
+	FormatInt: (a) => `(${a[0]}).toString(${a[1]})`,
+	FormatFloat: (a) => `String(${a[0]})`,
+	ParseFloat: (a) =>
+		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}), null])`,
+	ParseInt: (a) =>
+		`(Number.isNaN(parseInt(${a[0]}, ${a[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${a[0]}, ${a[1]} || 10), null])`,
+	ParseBool: (a) =>
+		`(${a[0]} === "true" || ${a[0]} === "1" ? [true, null] : ${a[0]} === "false" || ${a[0]} === "0" ? [false, null] : [false, "invalid syntax"])`,
+	Quote: (a) => `JSON.stringify(${a[0]})`,
+	Unquote: (a) =>
+		`((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", "invalid syntax"]; } })(${a[0]})`,
+	AppendInt: (a) =>
+		`[...(${a[0]}), ...new TextEncoder().encode((${a[1]}).toString(${a[2]}))]`,
+	AppendFloat: (a) =>
+		`[...(${a[0]}), ...new TextEncoder().encode(${a[1]}.toFixed(${a[3]} < 0 ? 6 : ${a[3]}))]`,
+};
+
+export const strconvMethods = {
+	_genStrconv(fn, a) {
+		const gen = STRCONV_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/strings.js

@@ -0,0 +1,83 @@
+// CodeGen for Go `strings` package.
+
+const STRINGS_M1 = {
+	ToUpper: "toUpperCase",
+	ToLower: "toLowerCase",
+	TrimSpace: "trim",
+	ToTitle: "toUpperCase",
+};
+const STRINGS_M2 = {
+	Contains: "includes",
+	HasPrefix: "startsWith",
+	HasSuffix: "endsWith",
+	Index: "indexOf",
+	LastIndex: "lastIndexOf",
+	Repeat: "repeat",
+	Split: "split",
+	Join: "join",
+};
+const STRINGS_DISPATCH = {
+	Count: ([s, s2]) =>
+		`((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${s}, ${s2})`,
+	Replace: ([s, s2, s3]) => `${s}.replace(${s2}, ${s3})`,
+	ReplaceAll: ([s, s2, s3]) => `${s}.replaceAll(${s2}, ${s3})`,
+	Trim: ([s, s2]) =>
+		`${s}.replace(new RegExp(\`^[\${${s2}}]+|[\${${s2}}]+$\`, "g"), "")`,
+	TrimPrefix: ([s, s2]) =>
+		`((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${s}, ${s2})`,
+	TrimSuffix: ([s, s2]) =>
+		`((s, suf) => !suf.length || !s.endsWith(suf) ? s : s.slice(0, -suf.length))(${s}, ${s2})`,
+	TrimLeft: ([s, s2]) => `${s}.replace(new RegExp(\`^[\${${s2}}]+\`), "")`,
+	TrimRight: ([s, s2]) => `${s}.replace(new RegExp(\`[\${${s2}}]+$\`), "")`,
+	EqualFold: ([s, s2]) => `${s}.toLowerCase() === ${s2}.toLowerCase()`,
+	Fields: ([s]) => `(${s}).trim() === '' ? [] : (${s}).trim().split(/\\s+/)`,
+	Cut: ([s, s2]) =>
+		`((s, sep) => { const i = s.indexOf(sep); return i < 0 ? [s, "", false] : [s.slice(0, i), s.slice(i + sep.length), true]; })(${s}, ${s2})`,
+	CutPrefix: ([s, s2]) =>
+		`(${s}).startsWith(${s2}) ? [(${s}).slice((${s2}).length), true] : [${s}, false]`,
+	CutSuffix: ([s, s2]) =>
+		`(${s}).endsWith(${s2}) ? [(${s}).slice(0, -(${s2}).length), true] : [${s}, false]`,
+	SplitN: ([s, s2, s3]) =>
+		`((s, sep, n) => { if (n === 0) return []; if (n < 0) return s.split(sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${s}, ${s2}, ${s3})`,
+	SplitAfter: ([s, s2]) =>
+		`((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(${s}, ${s2})`,
+	SplitAfterN: ([s, s2, s3]) =>
+		`((s, sep, n) => { if (n === 0) return []; if (n < 0 || sep === "") return ((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(s, sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${s}, ${s2}, ${s3})`,
+	IndexAny: ([s, s2]) =>
+		`((s, chars) => { let m = -1; for (const c of chars) { const i = s.indexOf(c); if (i >= 0 && (m < 0 || i < m)) m = i; } return m; })(${s}, ${s2})`,
+	LastIndexAny: ([s, s2]) =>
+		`((s, chars) => { let m = -1; for (const c of chars) { const i = s.lastIndexOf(c); if (i > m) m = i; } return m; })(${s}, ${s2})`,
+	ContainsAny: ([s, s2]) => `[...(${s2})].some(c => (${s}).includes(c))`,
+	ContainsRune: ([s, s2]) => `(${s}).includes(String.fromCodePoint(${s2}))`,
+	IndexRune: ([s, s2]) => `(${s}).indexOf(String.fromCodePoint(${s2}))`,
+	IndexByte: ([s, s2]) => `(${s}).indexOf(String.fromCharCode(${s2}))`,
+	LastIndexByte: ([s, s2]) => `(${s}).lastIndexOf(String.fromCharCode(${s2}))`,
+	Map: ([s, s2]) =>
+		`[...(${s2})].map(c => String.fromCodePoint((${s})(c.codePointAt(0)))).join("")`,
+	Title: ([s]) => `(${s}).replace(/\\b\\w/g, c => c.toUpperCase())`,
+	TrimFunc: ([s, s2]) =>
+		`((s, f) => { let l = 0, r = s.length; while (l < r && f(s.codePointAt(l))) l++; while (r > l && f(s.codePointAt(r - 1))) r--; return s.slice(l, r); })(${s}, ${s2})`,
+	TrimLeftFunc: ([s, s2]) =>
+		`((s, f) => { let l = 0; while (l < s.length && f(s.codePointAt(l))) l++; return s.slice(l); })(${s}, ${s2})`,
+	TrimRightFunc: ([s, s2]) =>
+		`((s, f) => { let r = s.length; while (r > 0 && f(s.codePointAt(r - 1))) r--; return s.slice(0, r); })(${s}, ${s2})`,
+	IndexFunc: ([s, s2]) =>
+		`((s, f) => { for (let i = 0; i < s.length; i++) { const cp = s.codePointAt(i); if (f(cp)) return i; if (cp > 0xFFFF) i++; } return -1; })(${s}, ${s2})`,
+	LastIndexFunc: ([s, s2]) =>
+		`((s, f) => { for (let i = s.length - 1; i >= 0; i--) { const cp = s.codePointAt(i); if (f(cp)) return i; } return -1; })(${s}, ${s2})`,
+	NewReader: ([s]) =>
+		`{_src: ${s}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src.charCodeAt(this._pos + i); this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(s) { this._src = s; this._pos = 0; }}`,
+	NewReplacer: (args) =>
+		`((...pairs) => { const p = []; for (let i = 0; i < pairs.length; i += 2) p.push([pairs[i], pairs[i+1]]); return { _p: p, Replace(s) { let r = s; for (const [o, n] of this._p) r = r.split(o).join(n); return r; } }; })(${args.join(", ")})`,
+};
+
+export const stringsMethods = {
+	_genStrings(fn, a) {
+		const args = a();
+		const [s, s2] = args;
+		if (STRINGS_M1[fn]) return `${s}.${STRINGS_M1[fn]}()`;
+		if (STRINGS_M2[fn]) return `${s}.${STRINGS_M2[fn]}(${s2})`;
+		const gen = STRINGS_DISPATCH[fn];
+		return gen ? gen(args) : undefined;
+	},
+};

package/src/codegen/stdlib/time.js

@@ -0,0 +1,54 @@
+// CodeGen for Go `time` package — `time.Now`, `time.Since`, etc., plus `*Time` methods.
+
+const TIME_METHOD_DISPATCH = {
+	Year: (r) => `${r}._d.getFullYear()`,
+	Month: (r) => `${r}._d.getMonth() + 1`,
+	Day: (r) => `${r}._d.getDate()`,
+	Hour: (r) => `${r}._d.getHours()`,
+	Minute: (r) => `${r}._d.getMinutes()`,
+	Second: (r) => `${r}._d.getSeconds()`,
+	Weekday: (r) => `${r}._d.getDay()`,
+	Unix: (r) => `Math.floor(${r}._d.getTime() / 1000)`,
+	UnixMilli: (r) => `${r}._d.getTime()`,
+	Add: (r, a) => `{_d: new Date(${r}._d.getTime() + (${a[0]}))}`,
+	Sub: (r, a) => `${r}._d.getTime() - (${a[0]})._d.getTime()`,
+	Before: (r, a) => `${r}._d < (${a[0]})._d`,
+	After: (r, a) => `${r}._d > (${a[0]})._d`,
+	Equal: (r, a) => `${r}._d.getTime() === (${a[0]})._d.getTime()`,
+};
+
+const TIME_DISPATCH = {
+	Now: () => "{_d: new Date()}",
+	Since: (a) => `(Date.now() - (${a[0]})._d.getTime())`,
+	Sleep: (a) => `await new Promise(r => setTimeout(r, ${a[0]} / 1000000))`,
+	Unix: (a) => `{_d: new Date((${a[0]}) * 1000)}`,
+	Date: (a) =>
+		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]})}`,
+};
+
+export const timeMethods = {
+	_genTimeMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		const recvJs = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+		if (method === "Format") {
+			this._usesTimeFmt = true;
+			return `__timeFmt(${recvJs}._d, ${args[0]})`;
+		}
+		if (method === "String") {
+			this._usesTimeFmt = true;
+			return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
+		}
+		const gen = TIME_METHOD_DISPATCH[method];
+		return gen ? gen(recvJs, args) : undefined;
+	},
+
+	_genTime(fn, a) {
+		if (fn === "Parse") {
+			this._usesTimeParse = true;
+			return `__timeParse(${a()[0]}, ${a()[1]})`;
+		}
+		const gen = TIME_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/unicode.js

@@ -0,0 +1,22 @@
+// CodeGen for Go `unicode` package.
+
+export const unicodeMethods = {
+	_genUnicode(fn, a) {
+		const [arg] = a();
+		const cp = `String.fromCodePoint(${arg})`;
+		const UNICODE_TEST = {
+			IsLetter: `/\\p{L}/u.test(${cp})`,
+			IsDigit: `/\\p{Nd}/u.test(${cp})`,
+			IsSpace: `/\\s/.test(${cp})`,
+			IsUpper: `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(${cp})`,
+			IsLower: `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(${cp})`,
+			IsPunct: `/\\p{P}/u.test(${cp})`,
+			IsControl: `/\\p{Cc}/u.test(${cp})`,
+			IsPrint: `!/\\p{Cc}/u.test(${cp})`,
+			IsGraphic: `!/\\p{Cc}/u.test(${cp})`,
+			ToUpper: `${cp}.toUpperCase().codePointAt(0)`,
+			ToLower: `${cp}.toLowerCase().codePointAt(0)`,
+		};
+		return UNICODE_TEST[fn] ?? undefined;
+	},
+};

package/src/codegen/stdlib/utf8.js

@@ -0,0 +1,23 @@
+// CodeGen for Go `unicode/utf8` package.
+
+const UTF8_DISPATCH = {
+	RuneCountInString: (a) => `[...(${a[0]})].length`,
+	RuneLen: (a) =>
+		`((r) => r < 0 ? -1 : r <= 0x7F ? 1 : r <= 0x7FF ? 2 : r <= 0xFFFF ? (r >= 0xD800 && r <= 0xDFFF ? -1 : 3) : r <= 0x10FFFF ? 4 : -1)(${a[0]})`,
+	ValidString: (a) =>
+		`/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/.test(${a[0]}) === false`,
+	ValidRune: (a) =>
+		`(${a[0]}) >= 0 && (${a[0]}) <= 0x10FFFF && !((${a[0]}) >= 0xD800 && (${a[0]}) <= 0xDFFF)`,
+	DecodeRuneInString: (a) =>
+		`((s) => { if (!s) return [0xFFFD, 0]; const cp = s.codePointAt(0); return [cp, cp > 0xFFFF ? 2 : 1]; })(${a[0]})`,
+	DecodeLastRuneInString: (a) =>
+		`((s) => { if (!s) return [0xFFFD, 0]; const i = s.length > 1 && s.charCodeAt(s.length - 1) >= 0xDC00 && s.charCodeAt(s.length - 1) <= 0xDFFF ? s.length - 2 : s.length - 1; const cp = s.codePointAt(i); return [cp, cp > 0xFFFF ? 2 : 1]; })(${a[0]})`,
+	FullRuneInString: (a) => `(${a[0]}).length > 0`,
+};
+
+export const utf8Methods = {
+	_genUtf8(fn, a) {
+		const gen = UTF8_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/templ.js

@@ -0,0 +1,281 @@
+// Templ (.templ file) code-generation mixin for CodeGen.
+// Mounts an HTML/expression tree onto a parent DOM node by emitting plain
+// document.createElement / appendChild / setAttribute calls.
+
+import { Parser } from "../parser/index.js";
+import { T, Token } from "../tokens.js";
+
+export const templGenMethods = {
+	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":
+				return this._genTemplComponentMount(node, 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;
+		}
+	},
+
+	_genTemplComponentMount(node, p) {
+		// 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});`,
+		);
+	},
+
+	_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;
+
+		const loopHeader = this._genTemplRangeHeader(keyName, valName, iterJs);
+		this.line(loopHeader);
+		this.indented(() => this._genTemplNodes(templBody, mountParent));
+		this.line("}");
+	},
+
+	_genTemplRangeHeader(keyName, valName, iterJs) {
+		if (valName === null || valName === undefined) {
+			return `for (const ${keyName === "_" ? "_$" : keyName} of ${iterJs}) {`;
+		}
+		if (keyName === "_" && valName === "_")
+			return `for (const _$ of ${iterJs}) {`;
+		if (keyName === "_") return `for (const ${valName} of ${iterJs}) {`;
+		if (valName === "_")
+			return `for (const [${keyName}] of Object.entries(${iterJs})) {`;
+		// Default to .entries() for arrays, Object.entries for objects
+		this._usesSliceGuard = true;
+		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
+	},
+
+	// 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}`;
+	},
+};