gofront 0.0.9 → 1.0.0

package/src/codegen/expressions.js

@@ -2,6 +2,57 @@
 
 import { ERROR, isComplex } from "../typechecker/types.js";
 
+// Namespace constants: pkg.Field → JS literal
+const NS_CONSTANTS = {
+	math: {
+		Pi: "Math.PI",
+		E: "Math.E",
+		MaxFloat64: "Number.MAX_VALUE",
+		SmallestNonzeroFloat64: "Number.MIN_VALUE",
+		MaxInt: "Number.MAX_SAFE_INTEGER",
+		MinInt: "Number.MIN_SAFE_INTEGER",
+	},
+	io: {
+		EOF: '"EOF"',
+		Discard:
+			"{ WriteString(s) { return s.length; }, Write(b) { return b.length; } }",
+	},
+	os: { Args: "process.argv" },
+	time: {
+		Millisecond: "1000000",
+		Second: "1000000000",
+		Minute: "60000000000",
+		Hour: "3600000000000",
+		RFC3339: '"2006-01-02T15:04:05Z07:00"',
+		RFC3339Nano: '"2006-01-02T15:04:05.999999999Z07:00"',
+		DateOnly: '"2006-01-02"',
+		TimeOnly: '"15:04:05"',
+		DateTime: '"2006-01-02 15:04:05"',
+		UTC: "null",
+		Local: "null",
+		January: "1",
+		February: "2",
+		March: "3",
+		April: "4",
+		May: "5",
+		June: "6",
+		July: "7",
+		August: "8",
+		September: "9",
+		October: "10",
+		November: "11",
+		December: "12",
+		Sunday: "0",
+		Monday: "1",
+		Tuesday: "2",
+		Wednesday: "3",
+		Thursday: "4",
+		Friday: "5",
+		Saturday: "6",
+	},
+	utf8: { RuneError: "0xFFFD", MaxRune: "0x10FFFF", UTFMax: "4" },
+};
+
 const INT_TYPE_NAMES = new Set([
 	"int",
 	"uint",
@@ -18,553 +69,325 @@ const INT_TYPE_NAMES = new Set([
 	"rune",
 ]);
 
+// Zero-value JS literals for basic Go types.
+const ZERO_FOR_BASIC = {
+	int: "0",
+	uint: "0",
+	int8: "0",
+	int16: "0",
+	int32: "0",
+	int64: "0",
+	uint8: "0",
+	uint16: "0",
+	uint32: "0",
+	uint64: "0",
+	uintptr: "0",
+	float32: "0",
+	float64: "0",
+	byte: "0",
+	rune: "0",
+	complex64: "{ re: 0, im: 0 }",
+	complex128: "{ re: 0, im: 0 }",
+	string: '""',
+	bool: "false",
+};
+
+// Set of all numeric type names (for type-assertion codegen).
+const TYPEOF_NUMBER_NAMES = new Set([...INT_TYPE_NAMES, "float32", "float64"]);
+
+// Builtin function codegen — keyed by builtin name, value is (self, expr) => string.
+const BUILTIN_GEN = {
+	append: (s, e) => s.genAppend(e),
+	len: (s, e) => s._genBuiltinLen(e),
+	cap: (s, e) => `${s.genExpr(e.args[0])}.length`,
+	make: (s, e) => s.genMake(e),
+	delete: (s, e) => {
+		const [m, k] = e.args.map((a) => s.genExpr(a));
+		return `(delete ${m}[${k}])`;
+	},
+	copy: (s, e) => {
+		const [dst, src] = e.args.map((a) => s.genExpr(a));
+		return `((__cd,__cs)=>{const n=Math.min(__cd.length,__cs.length);__cd.splice(0,n,...__cs.slice(0,n));return n;})(${dst},${src})`;
+	},
+	new: (s, e) => `{ value: ${s.zeroValueForExpr(e.args[0])} }`,
+	print: (s, e) => `console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	println: (s, e) =>
+		`console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	panic: (s, e) => `(() => { throw new Error(${s.genExpr(e.args[0])}); })()`,
+	recover: () =>
+		`(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`,
+	error: (s, e) => {
+		s._usesError = true;
+		return `__error(${s.genExpr(e.args[0])})`;
+	},
+	min: (s, e) => `Math.min(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	max: (s, e) => `Math.max(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	clear: (s, e) => s._genBuiltinClear(e),
+	complex: (s, e) =>
+		`{ re: ${s.genExpr(e.args[0])}, im: ${s.genExpr(e.args[1])} }`,
+	real: (s, e) => `(${s.genExpr(e.args[0])}).re`,
+	imag: (s, e) => `(${s.genExpr(e.args[0])}).im`,
+};
+
+// Method-name dispatch for genExpr — string values add no static call edges.
+const EXPR_GEN_DELEGATE = {
+	UnaryExpr: "_genUnaryExpr",
+	BinaryExpr: "_genBinaryExpr",
+	CallExpr: "genCall",
+	SelectorExpr: "_genSelectorExpr",
+	IndexExpr: "_genIndexExpr",
+	SliceExpr: "_genSliceExpr",
+	CompositeLit: "genCompositeLit",
+	FuncLit: "_genFuncLit",
+	TypeConversion: "_genTypeConversion",
+	TypeAssertExpr: "_genTypeAssertExpr",
+};
+
 export const expressionGenMethods = {
 	genExpr(expr) {
 		switch (expr.kind) {
 			case "BasicLit":
 				if (expr.litKind === "STRING") return JSON.stringify(expr.value);
 				return expr.value; // int, float, bool, nil(null)
-
 			case "ImagLit":
 				return `{ re: 0, im: ${expr.value} }`;
-
 			case "Ident":
 				if (this._boxedVars.has(expr.name) && !expr._isAddressOf)
 					return `${expr.name}.value`;
 				return expr.name;
-
-			case "UnaryExpr": {
-				const op = expr.op === "^" ? "~" : expr.op; // bitwise NOT
-				// Address-of: &x
-				if (op === "&") {
-					if (expr.operand.kind === "Ident") {
-						// Mark so Ident codegen does NOT append .value
-						expr.operand._isAddressOf = true;
-						// For boxed vars, &x returns the box itself
-						if (this._boxedVars.has(expr.operand.name)) {
-							return this.genExpr(expr.operand);
-						}
-					}
-					// For non-boxed vars (structs, etc.), wrap in { value: x }
-					return `{ value: ${this.genExpr(expr.operand)} }`;
-				}
-				// Dereference: *p → p.value
-				if (op === "*") {
-					return `${this.genExpr(expr.operand)}.value`;
-				}
-				// Unary minus/plus on complex
-				if ((op === "-" || op === "+") && isComplex(expr.operand._type)) {
-					const inner = this.genExpr(expr.operand);
-					if (op === "-") return `{ re: -${inner}.re, im: -${inner}.im }`;
-					return inner;
-				}
-				return `${op}${this.genExpr(expr.operand)}`;
-			}
-
-			case "BinaryExpr": {
-				// Complex binary operations
-				if (
-					isComplex(expr._type) ||
-					isComplex(expr.left._type) ||
-					isComplex(expr.right._type)
-				) {
-					const l = this._genComplexOperand(expr.left);
-					const r = this._genComplexOperand(expr.right);
-					switch (expr.op) {
-						case "+":
-							return `{ re: ${l}.re + ${r}.re, im: ${l}.im + ${r}.im }`;
-						case "-":
-							return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
-						case "*":
-							this._usesCmul = true;
-							return `__cmul(${l}, ${r})`;
-						case "/":
-							this._usesCdiv = true;
-							return `__cdiv(${l}, ${r})`;
-						case "==":
-							return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
-						case "!=":
-							return `(${l}.re !== ${r}.re || ${l}.im !== ${r}.im)`;
-					}
-				}
-				const l = this.genExpr(expr.left);
-				const r = this.genExpr(expr.right);
-				// Integer division: only when both sides are int
-				if (
-					expr.op === "/" &&
-					this.isIntType(expr.left._type) &&
-					this.isIntType(expr.right._type)
-				) {
-					return `Math.trunc(${l} / ${r})`;
-				}
-				// Go &^ (bit clear / AND NOT) → JS & ~
-				if (expr.op === "&^") {
-					return `${l} & ~${r}`;
-				}
-				// Struct/array equality: use __equal for value comparison
-				if (expr.op === "==" || expr.op === "!=") {
-					const lt = expr.left._type;
-					if (this._isStructOrArrayType(lt)) {
-						this._usesEqual = true;
-						const cmp = `__equal(${l}, ${r})`;
-						return expr.op === "==" ? cmp : `!${cmp}`;
-					}
-				}
-				// Go == and != are strict — map to JS === / !==
-				const op =
-					expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
-				return `${l} ${op} ${r}`;
-			}
-
-			case "CallExpr":
-				return this.genCall(expr);
-
+			case "AwaitExpr":
+				return `await ${this.genExpr(expr.expr)}`;
 			case "InstantiationExpr":
-				return this.genExpr(expr.expr); // type erasure
-
-			case "SelectorExpr": {
-				// Method expression: TypeName.MethodName → (recv, ...args) => recv.method(...args)
-				if (expr._isMethodExpr) {
-					const method = expr.field;
-					return `((recv, ...args) => recv.${method}(...args))`;
-				}
-				// math constants
-				if (expr.expr.kind === "Ident" && expr.expr.name === "math") {
-					switch (expr.field) {
-						case "Pi":
-							return "Math.PI";
-						case "E":
-							return "Math.E";
-						case "MaxFloat64":
-							return "Number.MAX_VALUE";
-						case "SmallestNonzeroFloat64":
-							return "Number.MIN_VALUE";
-						case "MaxInt":
-							return "Number.MAX_SAFE_INTEGER";
-						case "MinInt":
-							return "Number.MIN_SAFE_INTEGER";
-					}
-				}
-				// io constants
-				if (expr.expr.kind === "Ident" && expr.expr.name === "io") {
-					switch (expr.field) {
-						case "EOF":
-							return '"EOF"';
-						case "Discard":
-							return "{ WriteString(s) { return s.length; }, Write(b) { return b.length; } }";
-					}
-				}
-				// os constants/vars
-				if (expr.expr.kind === "Ident" && expr.expr.name === "os") {
-					switch (expr.field) {
-						case "Args":
-							return "process.argv";
-					}
-				}
-				// time constants (nanosecond durations and layout strings)
-				if (expr.expr.kind === "Ident" && expr.expr.name === "time") {
-					switch (expr.field) {
-						case "Millisecond":
-							return "1000000";
-						case "Second":
-							return "1000000000";
-						case "Minute":
-							return "60000000000";
-						case "Hour":
-							return "3600000000000";
-						case "RFC3339":
-							return '"2006-01-02T15:04:05Z07:00"';
-						case "RFC3339Nano":
-							return '"2006-01-02T15:04:05.999999999Z07:00"';
-						case "DateOnly":
-							return '"2006-01-02"';
-						case "TimeOnly":
-							return '"15:04:05"';
-						case "DateTime":
-							return '"2006-01-02 15:04:05"';
-						case "UTC":
-						case "Local":
-							return "null";
-						case "January":
-							return "1";
-						case "February":
-							return "2";
-						case "March":
-							return "3";
-						case "April":
-							return "4";
-						case "May":
-							return "5";
-						case "June":
-							return "6";
-						case "July":
-							return "7";
-						case "August":
-							return "8";
-						case "September":
-							return "9";
-						case "October":
-							return "10";
-						case "November":
-							return "11";
-						case "December":
-							return "12";
-						case "Sunday":
-							return "0";
-						case "Monday":
-							return "1";
-						case "Tuesday":
-							return "2";
-						case "Wednesday":
-							return "3";
-						case "Thursday":
-							return "4";
-						case "Friday":
-							return "5";
-						case "Saturday":
-							return "6";
-					}
-				}
-				// utf8 constants
-				if (expr.expr.kind === "Ident" && expr.expr.name === "utf8") {
-					switch (expr.field) {
-						case "RuneError":
-							return "0xFFFD";
-						case "MaxRune":
-							return "0x10FFFF";
-						case "UTFMax":
-							return "4";
-					}
-				}
-				const base = this.genExpr(expr.expr);
-				// Bundled GoFront packages are inlined — drop the qualifier.
-				if (this.bundledPackages.has(base)) return expr.field;
-				// Pointer types: route through .value
-				if (expr.expr._type?.kind === "pointer" && expr.field !== "value") {
-					const sel = `${base}.value.${expr.field}`;
-					if (expr._isMethodValue && !expr._callee)
-						return `${sel}.bind(${base}.value)`;
-					return sel;
-				}
-				const sel = `${base}.${expr.field}`;
-				// Method used as value (not called) — bind the receiver
-				if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
-				return sel;
-			}
-
-			case "IndexExpr": {
-				const exprType = expr.expr._type;
-				const wrapField = this._namedWrapperField(exprType, expr.expr);
-				const base = wrapField
-					? `${this.genExpr(expr.expr)}.${wrapField}`
-					: this.genExpr(expr.expr);
-				const idx = this.genExpr(expr.index);
-				if (expr._mapValueType && !expr._lvalue) {
-					const zero = this.zeroValueForType(expr._mapValueType);
-					// Use an IIFE to avoid double-evaluating base/key when either
-					// could be a function call or other expression with side effects.
-					if (this._hasCallExpr(expr.expr) || this._hasCallExpr(expr.index)) {
-						return `((__m, __k) => __m[__k] ?? ${zero})(${base}, ${idx})`;
-					}
-					return `(${base}[${idx}] ?? ${zero})`;
-				}
-				// String indexing returns a byte (charCodeAt), not a JS character
-				const isStr =
-					(exprType?.kind === "basic" && exprType.name === "string") ||
-					(exprType?.kind === "untyped" && exprType.base === "string");
-				if (isStr && !expr._lvalue) {
-					return `${base}.charCodeAt(${idx})`;
-				}
-				return `${base}[${idx}]`;
-			}
-
-			case "SliceExpr": {
-				const base = this.genExpr(expr.expr);
-				const lo = expr.low ? this.genExpr(expr.low) : "";
-				const hi = expr.high ? this.genExpr(expr.high) : "";
-				if (!lo && !hi) return `${base}.slice()`;
-				if (!hi) return `${base}.slice(${lo})`;
-				if (!lo) return `${base}.slice(0, ${hi})`;
-				return `${base}.slice(${lo}, ${hi})`;
-			}
-
-			case "CompositeLit":
-				return this.genCompositeLit(expr);
-
-			case "FuncLit": {
-				const params = expr.params.map((p) => p.name).join(", ");
-				const asyncPrefix = expr.async ? "async " : "";
-				const saved = this.out;
-				const prevBoxed = this._boxedVars;
-				this._boxedVars = new Set(prevBoxed); // inherit parent's boxed vars (closures)
-				this._scanAddressTaken(expr.body);
-				this.out = [];
-				this.indented(() => this._genBody(expr.body));
-				const body = this.out.join("\n");
-				this.out = saved;
-				this._boxedVars = prevBoxed;
-				return `${asyncPrefix}function(${params}) {\n${body}\n${"  ".repeat(this.indent)}}`;
+			case "RangeExpr":
+				return this.genExpr(expr.expr);
+			default: {
+				const m = EXPR_GEN_DELEGATE[expr.kind];
+				if (m) return this[m](expr);
+				throw new Error(`CodeGen: unhandled expression kind '${expr.kind}'`);
 			}
+		}
+	},
 
-			case "TypeConversion": {
-				const inner = this.genExpr(expr.expr);
-				const t = expr.targetType;
-
-				// Complex type conversions
-				if (t?.name === "complex128" || t?.name === "complex64") {
-					const srcType = expr.expr._type;
-					if (isComplex(srcType)) return inner; // complex→complex identity
-					return `{ re: ${inner}, im: 0 }`; // numeric→complex
-				}
+	_genUnaryExpr(expr) {
+		const op = expr.op === "^" ? "~" : expr.op; // bitwise NOT
+		// Address-of: &x
+		if (op === "&") {
+			if (expr.operand.kind === "Ident") {
+				// Mark so Ident codegen does NOT append .value
+				expr.operand._isAddressOf = true;
+				// For boxed vars, &x returns the box itself
+				if (this._boxedVars.has(expr.operand.name)) {
+					return this.genExpr(expr.operand);
+				}
+			}
+			// For non-boxed vars (structs, etc.), wrap in { value: x }
+			return `{ value: ${this.genExpr(expr.operand)} }`;
+		}
+		// Dereference: *p → p.value
+		if (op === "*") return `${this.genExpr(expr.operand)}.value`;
+		// Unary minus/plus on complex
+		if ((op === "-" || op === "+") && isComplex(expr.operand._type)) {
+			const inner = this.genExpr(expr.operand);
+			if (op === "-") return `{ re: -${inner}.re, im: -${inner}.im }`;
+			return inner;
+		}
+		return `${op}${this.genExpr(expr.operand)}`;
+	},
 
-				// Array type conversion: [N]T(slice) → slice(0, N)
-				if (t?.kind === "ArrayType") {
-					const srcType = expr.expr._type;
-					const srcResolved =
-						srcType?.kind === "named" ? srcType.underlying : srcType;
-					if (srcResolved?.kind === "slice") {
-						const size =
-							t.size?.value !== undefined ? Number(t.size.value) : t.size;
-						return `${inner}.slice(0, ${size})`;
-					}
-					return inner;
-				}
+	_genSelectorExpr(expr) {
+		if (expr._isMethodExpr) {
+			return `((recv, ...args) => recv.${expr.field}(...args))`;
+		}
+		if (expr.expr.kind === "Ident") {
+			const nsConst = NS_CONSTANTS[expr.expr.name]?.[expr.field];
+			if (nsConst !== undefined) return nsConst;
+		}
+		const base = this.genExpr(expr.expr);
+		if (this.bundledPackages.has(base)) return expr.field;
+		if (expr.expr._type?.kind === "pointer" && expr.field !== "value")
+			return this._genPointerSelectorField(expr, base);
+		const sel = `${base}.${expr.field}`;
+		if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+		return sel;
+	},
 
-				// Slice type conversions
-				if (t?.kind === "SliceType") {
-					const elem = t.elem?.name;
-					// []byte(s) → UTF-8 byte array
-					if (elem === "byte" || elem === "uint8") {
-						return `Array.from(new TextEncoder().encode(${inner}))`;
-					}
-					// []rune(s) → Unicode code point array (only when source is a string)
-					if (elem === "rune" || elem === "int32" || elem === "int") {
-						const srcType = expr.expr._type;
-						if (
-							(srcType?.kind === "basic" && srcType?.name === "string") ||
-							(srcType?.kind === "untyped" && srcType?.base === "string")
-						) {
-							return `Array.from(${inner}, __c => __c.codePointAt(0))`;
-						}
-						return `Array.from(${inner})`;
-					}
-					return `Array.from(${inner})`;
-				}
+	_genPointerSelectorField(expr, base) {
+		const sel = `${base}.value.${expr.field}`;
+		if (expr._isMethodValue && !expr._callee)
+			return `${sel}.bind(${base}.value)`;
+		return sel;
+	},
 
-				const target = t?.name;
-				// error("msg") → __error("msg")
-				if (target === "error") {
-					this._usesError = true;
-					return `__error(${inner})`;
-				}
-				// Named wrapper type: NodeFunc(fn) → new NodeFunc(fn)
-				if (target && this.namedWrapperNames.has(target)) {
-					return `new ${target}(${inner})`;
-				}
-				switch (target) {
-					case "string": {
-						// Go string(65) → "A" (Unicode code point), not "65"
-						const srcType = expr.expr._type;
-						if (srcType && this.isIntType(srcType)) {
-							return `String.fromCodePoint(${inner})`;
-						}
-						// string([]byte) → decode byte array to string
-						if (
-							srcType &&
-							srcType.kind === "slice" &&
-							srcType.elem?.name === "int"
-						) {
-							return `${inner}.map(c => String.fromCharCode(c)).join("")`;
-						}
-						return `String(${inner})`;
-					}
-					case "int":
-					case "byte":
-					case "rune":
-						return `Math.trunc(Number(${inner}))`;
-					case "float64":
-						return `Number(${inner})`;
-					case "bool":
-						return `Boolean(${inner})`;
-					default:
-						return inner;
-				}
-			}
+	_genIndexExpr(expr) {
+		const exprType = expr.expr._type;
+		const wrapField = this._namedWrapperField(exprType, expr.expr);
+		const base = wrapField
+			? `${this.genExpr(expr.expr)}.${wrapField}`
+			: this.genExpr(expr.expr);
+		const idx = this.genExpr(expr.index);
+		if (expr._mapValueType && !expr._lvalue)
+			return this._genMapIndexExpr(expr, base, idx);
+		if (this._isStringExprType(exprType) && !expr._lvalue)
+			return `${base}.charCodeAt(${idx})`;
+		return `${base}[${idx}]`;
+	},
 
-			case "TypeAssertExpr": {
-				const val = this.genExpr(expr.expr);
-				const check = this._typeCheckExpr(expr.type, val);
-				if (!expr._commaOk) {
-					// plain assertion: panic if check fails (matches Go behavior)
-					if (check === "true") return val; // can't check at runtime — pass through
-					return `(${check} ? ${val} : (() => { throw new Error("interface conversion: type assertion failed"); })())`;
-				}
-				// comma-ok: emit [value-or-zero, runtimeTypeCheck]
-				const zero = this.zeroValueForTypeNode(expr.type);
-				return `(${check} ? [${val}, true] : [${zero}, false])`;
-			}
+	_genMapIndexExpr(expr, base, idx) {
+		const zero = this.zeroValueForType(expr._mapValueType);
+		if (this._hasCallExpr(expr.expr) || this._hasCallExpr(expr.index))
+			return `((__m, __k) => __m[__k] ?? ${zero})(${base}, ${idx})`;
+		return `(${base}[${idx}] ?? ${zero})`;
+	},
 
-			case "AwaitExpr":
-				return `await ${this.genExpr(expr.expr)}`;
+	_isStringExprType(exprType) {
+		return (
+			(exprType?.kind === "basic" && exprType.name === "string") ||
+			(exprType?.kind === "untyped" && exprType.base === "string")
+		);
+	},
 
-			case "RangeExpr":
-				return this.genExpr(expr.expr);
+	_genSliceExpr(expr) {
+		const base = this.genExpr(expr.expr);
+		const lo = expr.low ? this.genExpr(expr.low) : "";
+		const hi = expr.high ? this.genExpr(expr.high) : "";
+		if (!lo && !hi) return `${base}.slice()`;
+		if (!hi) return `${base}.slice(${lo})`;
+		if (!lo) return `${base}.slice(0, ${hi})`;
+		return `${base}.slice(${lo}, ${hi})`;
+	},
 
-			default:
-				throw new Error(`CodeGen: unhandled expression kind '${expr.kind}'`);
-		}
+	_genFuncLit(expr) {
+		const params = expr.params.map((p) => p.name).join(", ");
+		const asyncPrefix = expr.async ? "async " : "";
+		const saved = this.out;
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set(prevBoxed); // inherit parent's boxed vars (closures)
+		this._scanAddressTaken(expr.body);
+		this.out = [];
+		this.indented(() => this._genBody(expr.body));
+		const body = this.out.join("\n");
+		this.out = saved;
+		this._boxedVars = prevBoxed;
+		return `${asyncPrefix}function(${params}) {\n${body}\n${"  ".repeat(this.indent)}}`;
+	},
+
+	_genTypeAssertExpr(expr) {
+		const val = this.genExpr(expr.expr);
+		const check = this._typeCheckExpr(expr.type, val);
+		if (!expr._commaOk) {
+			// plain assertion: panic if check fails (matches Go behavior)
+			if (check === "true") return val; // can't check at runtime — pass through
+			return `(${check} ? ${val} : (() => { throw new Error("interface conversion: type assertion failed"); })())`;
+		}
+		// comma-ok: emit [value-or-zero, runtimeTypeCheck]
+		const zero = this.zeroValueForTypeNode(expr.type);
+		return `(${check} ? [${val}, true] : [${zero}, false])`;
+	},
+
+	_genTypeConversionCall(expr) {
+		const name = expr._conversionTargetType?.name;
+		const arg = this.genExpr(expr.args[0]);
+		if (name && this.namedWrapperNames.has(name)) return `new ${name}(${arg})`;
+		return arg;
 	},
 
 	genCall(expr) {
-		// Named type constructor call: Greeter(fn), NodeFunc(fn) → new Greeter(fn)
-		if (expr._isTypeConversion) {
-			const name = expr._conversionTargetType?.name;
-			const arg = this.genExpr(expr.args[0]);
-			if (name && this.namedWrapperNames.has(name)) {
-				return `new ${name}(${arg})`;
-			}
-			return arg; // non-wrapper named types: identity
-		}
+		if (expr._isTypeConversion) return this._genTypeConversionCall(expr);
 
-		// Unwrap InstantiationExpr for function calls: Foo[int](42) → Foo(42)
 		const funcExpr =
 			expr.func.kind === "InstantiationExpr" ? expr.func.expr : expr.func;
-		// Handle built-ins that need special JS translation
 		if (funcExpr.kind === "Ident") {
-			switch (funcExpr.name) {
-				case "append":
-					return this.genAppend(expr);
-				case "len": {
-					if (expr._constLen != null) return String(expr._constLen);
-					const arg = expr.args[0];
-					const t = arg?._type;
-					const wrapField = this._namedWrapperField(t, arg);
-					if (wrapField) {
-						return `${this.genExpr(arg)}.${wrapField}.length`;
-					}
-					const js = this.genExpr(arg);
-					if (t?.kind === "map") return `Object.keys(${js}).length`;
-					this._usesLen = true;
-					return `__len(${js})`;
-				}
-				case "cap":
-					return `${this.genExpr(expr.args[0])}.length`;
-				case "make":
-					return this.genMake(expr);
-				case "delete": {
-					const [m, k] = expr.args.map((a) => this.genExpr(a));
-					return `(delete ${m}[${k}])`;
-				}
-				case "copy": {
-					const [dst, src] = expr.args.map((a) => this.genExpr(a));
-					return `((__cd,__cs)=>{const n=Math.min(__cd.length,__cs.length);__cd.splice(0,n,...__cs.slice(0,n));return n;})(${dst},${src})`;
-				}
-				case "new": {
-					const zero = this.zeroValueForExpr(expr.args[0]);
-					return `{ value: ${zero} }`;
-				}
-				case "print":
-				case "println": {
-					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
-					return `console.log(${args})`;
-				}
-				case "panic": {
-					const arg = this.genExpr(expr.args[0]);
-					return `(() => { throw new Error(${arg}); })()`;
-				}
-				case "recover":
-					return `(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`;
-				case "error": {
-					this._usesError = true;
-					const arg = this.genExpr(expr.args[0]);
-					return `__error(${arg})`;
-				}
-				case "min": {
-					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
-					return `Math.min(${args})`;
-				}
-				case "max": {
-					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
-					return `Math.max(${args})`;
-				}
-				case "clear": {
-					const arg = expr.args[0];
-					const t = arg?._type;
-					const js = this.genExpr(arg);
-					if (
-						t?.kind === "map" ||
-						(t?.kind === "named" && t.underlying?.kind === "map")
-					) {
-						return `((__m) => { for (const __k in __m) delete __m[__k]; })(${js})`;
-					}
-					return `(${js}).length = 0`;
-				}
-				case "complex": {
-					const re = this.genExpr(expr.args[0]);
-					const im = this.genExpr(expr.args[1]);
-					return `{ re: ${re}, im: ${im} }`;
-				}
-				case "real":
-					return `(${this.genExpr(expr.args[0])}).re`;
-				case "imag":
-					return `(${this.genExpr(expr.args[0])}).im`;
-			}
-		}
-
-		// error.Error() → real method call
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.field === "Error" &&
-			expr.func.expr._type &&
-			(expr.func.expr._type === ERROR ||
-				expr.func.expr._type?.name === "error" ||
-				(expr.func.expr._type?.kind === "named" &&
-					expr.func.expr._type?.underlying?.kind === "interface"))
-		) {
-			return `${this.genExpr(expr.func.expr)}.Error()`;
-		}
-
-		// fmt.Sprintf / fmt.Printf / fmt.Println / fmt.Print / fmt.Errorf
-		// Standard library namespace dispatch — all follow the pattern:
-		// pkg.Func(args) → inline JS
-		if (expr.func.kind === "SelectorExpr" && expr.func.expr.kind === "Ident") {
-			const ns = expr.func.expr.name;
-			const fn = expr.func.field;
-			const result = this._genStdlibCall(ns, fn, expr);
-			if (result !== undefined) return result;
+			const builtin = this._genBuiltinIdent(funcExpr.name, expr);
+			if (builtin !== undefined) return builtin;
 		}
 
-		// strings.Builder / bytes.Buffer / regexp.Regexp method dispatch
 		if (expr.func.kind === "SelectorExpr") {
-			const recvType = expr.func.expr._type;
-			const recvName = recvType?.name ?? recvType?.base?.name;
-			if (recvName === "strings.Builder" || recvName === "bytes.Buffer") {
-				const typeName = recvType?.name ?? recvType?.base?.name;
-				return this._genBuilderCall(typeName, expr.func.field, expr);
-			}
-			if (recvName === "regexp.Regexp") {
-				return this._genRegexpMethodCall(expr.func.field, expr);
-			}
-			if (recvName === "time.Time") {
-				return this._genTimeMethodCall(expr.func.field, expr);
-			}
+			const result = this._genSelectorCall(expr);
+			if (result !== undefined) return result;
 		}
 
-		// Mark the callee so SelectorExpr knows it's being called, not used as a value
 		expr.func._callee = true;
 		const rawFn = this.genExpr(expr.func);
-		// Wrap function literals in parens so `function(){}()` → `(function(){})()`
 		const fn = expr.func.kind === "FuncLit" ? `(${rawFn})` : rawFn;
-		// Multi-value forwarding: f(g()) where g() returns multiple values → f(...g())
-		if (expr._multiForward) {
-			return `${fn}(...${this.genExpr(expr.args[0])})`;
-		}
+		if (expr._multiForward) return `${fn}(...${this.genExpr(expr.args[0])})`;
 		const args = expr.args
 			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
 			.join(", ");
 		return `${fn}(${args})`;
 	},
 
+	_isErrorInterfaceType(t) {
+		return t?.kind === "named" && t?.underlying?.kind === "interface";
+	},
+
+	_isErrorType(t) {
+		return (
+			t && (t === ERROR || t?.name === "error" || this._isErrorInterfaceType(t))
+		);
+	},
+
+	_isErrorMethodCall(expr) {
+		if (expr.func.field !== "Error") return false;
+		return this._isErrorType(expr.func.expr._type);
+	},
+
+	_resolveRecvName(recvType) {
+		return recvType?.name ?? recvType?.base?.name;
+	},
+
+	_genReceiverTypeCall(recvName, expr) {
+		if (recvName === "strings.Builder" || recvName === "bytes.Buffer")
+			return this._genBuilderCall(recvName, expr.func.field, expr);
+		if (recvName === "regexp.Regexp")
+			return this._genRegexpMethodCall(expr.func.field, expr);
+		if (recvName === "time.Time")
+			return this._genTimeMethodCall(expr.func.field, expr);
+		return undefined;
+	},
+
+	_genSelectorCall(expr) {
+		if (this._isErrorMethodCall(expr))
+			return `${this.genExpr(expr.func.expr)}.Error()`;
+		if (expr.func.expr.kind === "Ident") {
+			const ns = expr.func.expr.name;
+			const fn = expr.func.field;
+			const result = this._genStdlibCall(ns, fn, expr);
+			if (result !== undefined) return result;
+		}
+		const recvType = expr.func.expr._type;
+		const recvName = this._resolveRecvName(recvType);
+		return this._genReceiverTypeCall(recvName, expr);
+	},
+
+	_genBuiltinLen(expr) {
+		if (expr._constLen != null) return String(expr._constLen);
+		const arg = expr.args[0];
+		const t = arg?._type;
+		const wrapField = this._namedWrapperField(t, arg);
+		if (wrapField) return `${this.genExpr(arg)}.${wrapField}.length`;
+		const js = this.genExpr(arg);
+		if (t?.kind === "map") return `Object.keys(${js}).length`;
+		this._usesLen = true;
+		return `__len(${js})`;
+	},
+
+	_genBuiltinClear(expr) {
+		const arg = expr.args[0];
+		const t = arg?._type;
+		const js = this.genExpr(arg);
+		if (
+			t?.kind === "map" ||
+			(t?.kind === "named" && t.underlying?.kind === "map")
+		)
+			return `((__m) => { for (const __k in __m) delete __m[__k]; })(${js})`;
+		return `(${js}).length = 0`;
+	},
+
+	_genBuiltinIdent(name, expr) {
+		const gen = BUILTIN_GEN[name];
+		return gen ? gen(this, expr) : undefined;
+	},
+
 	genAppend(expr) {
 		const retType = expr._type;
 		const wrapField = this._namedWrapperField(retType, expr.args[0]);
@@ -631,74 +454,55 @@ export const expressionGenMethods = {
 			.join(", ");
 	},
 
-	genCompositeLit(expr) {
-		const t = expr.typeExpr;
-
-		// Implicit composite literal: {X: 1} or {1, 2} inside a slice/map — type inferred from context
-		if (t === null) {
-			const typeName = expr._type?.name ?? expr._type?.underlying?.name;
-			const hasPositional = expr.elems.some((e) => e._positionalField);
-			const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
-			if (hasPositional || hasKeyed) {
-				if (typeName && this.structNames.has(typeName)) {
-					return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
-				}
-				const fields = expr.elems
-					.map((e) => {
-						if (e._positionalField)
-							return `${e._positionalField}: ${this.genExpr(e)}`;
-						return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
-					})
-					.join(", ");
-				return `{ ${fields} }`;
-			}
-			return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
-		}
+	_isSliceOrArrayType(t) {
+		return t?.kind === "SliceType" || t?.kind === "ArrayType";
+	},
 
-		const typeName = this.getTypeName(t);
+	_isMapTypeNode(t) {
+		return t?.kind === "MapType";
+	},
 
-		// Struct: new Foo({ X: 1, Y: 2 }) — keyed or positional
-		if (typeName && this.structNames.has(typeName)) {
-			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
-		}
+	_genMapLitEntries(elems) {
+		return elems
+			.map((e) => {
+				if (e.kind === "KeyValueExpr") {
+					const k =
+						e.key.litKind === "STRING"
+							? JSON.stringify(e.key.value)
+							: `[${this.genExpr(e.key)}]`;
+					return `${k}: ${this.genExpr(e.value)}`;
+				}
+				return this.genExpr(e);
+			})
+			.join(", ");
+	},
 
-		// Named wrapper type: Group{a, b} → new Group([a, b])
-		if (typeName && this.namedWrapperNames.has(typeName)) {
-			const namedType = this.checker?.types.get(typeName);
-			const u = namedType?.underlying;
-			if (u?.kind === "map") {
-				const entries = expr.elems
-					.map((e) => {
-						if (e.kind === "KeyValueExpr") {
-							const k =
-								e.key.litKind === "STRING"
-									? JSON.stringify(e.key.value)
-									: `[${this.genExpr(e.key)}]`;
-							return `${k}: ${this.genExpr(e.value)}`;
-						}
-						return this.genExpr(e);
-					})
-					.join(", ");
-				return `new ${typeName}({ ${entries} })`;
-			}
-			// Default: slice
-			const elems = expr.elems
-				.map((e) =>
-					e.kind === "KeyValueExpr" ? this.genExpr(e.value) : this.genExpr(e),
+	_genFallbackCompositeLit(expr) {
+		if (expr.elems.length > 0 && expr.elems[0]?.kind === "KeyValueExpr") {
+			const fields = expr.elems
+				.map(
+					(e) =>
+						`${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
 				)
 				.join(", ");
-			return `new ${typeName}([${elems}])`;
+			return `{ ${fields} }`;
 		}
+		return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
+	},
 
-		// Fallback: named type that's not a struct but has positional elements → treat as struct
+	genCompositeLit(expr) {
+		const t = expr.typeExpr;
+		if (t === null) return this._genImplicitCompositeLit(expr);
+		const typeName = this.getTypeName(t);
+		if (typeName && this.structNames.has(typeName))
+			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+		if (typeName && this.namedWrapperNames.has(typeName))
+			return this._genNamedWrapperLit(typeName, expr);
 		if (expr.elems.some((e) => e._positionalField)) {
-			if (typeName) {
+			if (typeName)
 				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
-			}
 		}
-
-		// Slice/array: [1, 2, 3]
-		if (t?.kind === "SliceType" || t?.kind === "ArrayType") {
+		if (this._isSliceOrArrayType(t)) {
 			const elems = expr.elems
 				.map((e) =>
 					e.kind === "KeyValueExpr" ? this.genExpr(e.value) : this.genExpr(e),
@@ -706,9 +510,35 @@ export const expressionGenMethods = {
 				.join(", ");
 			return `[${elems}]`;
 		}
+		if (this._isMapTypeNode(t))
+			return `{ ${this._genMapLitEntries(expr.elems)} }`;
+		return this._genFallbackCompositeLit(expr);
+	},
+
+	_genImplicitCompositeLit(expr) {
+		const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+		const hasPositional = expr.elems.some((e) => e._positionalField);
+		const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
+		if (hasPositional || hasKeyed) {
+			if (typeName && this.structNames.has(typeName)) {
+				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+			}
+			const fields = expr.elems
+				.map((e) => {
+					if (e._positionalField)
+						return `${e._positionalField}: ${this.genExpr(e)}`;
+					return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
+				})
+				.join(", ");
+			return `{ ${fields} }`;
+		}
+		return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
+	},
 
-		// Map: { key: value }
-		if (t?.kind === "MapType") {
+	_genNamedWrapperLit(typeName, expr) {
+		const namedType = this.checker?.types.get(typeName);
+		const u = namedType?.underlying;
+		if (u?.kind === "map") {
 			const entries = expr.elems
 				.map((e) => {
 					if (e.kind === "KeyValueExpr") {
@@ -721,20 +551,15 @@ export const expressionGenMethods = {
 					return this.genExpr(e);
 				})
 				.join(", ");
-			return `{ ${entries} }`;
-		}
-
-		// Fallback: key-value pairs → plain object, positional → array
-		if (expr.elems.length > 0 && expr.elems[0]?.kind === "KeyValueExpr") {
-			const fields = expr.elems
-				.map(
-					(e) =>
-						`${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
-				)
-				.join(", ");
-			return `{ ${fields} }`;
+			return `new ${typeName}({ ${entries} })`;
 		}
-		return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
+		// Default: slice
+		const elems = expr.elems
+			.map((e) =>
+				e.kind === "KeyValueExpr" ? this.genExpr(e.value) : this.genExpr(e),
+			)
+			.join(", ");
+		return `new ${typeName}([${elems}])`;
 	},
 
 	// ── Helpers ───────────────────────────────────────────────────
@@ -775,33 +600,14 @@ export const expressionGenMethods = {
 
 	// Returns the JS zero-value literal for a basic type name, or null if not a basic type.
 	_zeroForBasicName(name) {
-		switch (name) {
-			case "int":
-			case "uint":
-			case "int8":
-			case "int16":
-			case "int32":
-			case "int64":
-			case "uint8":
-			case "uint16":
-			case "uint32":
-			case "uint64":
-			case "uintptr":
-			case "float32":
-			case "float64":
-			case "byte":
-			case "rune":
-				return "0";
-			case "complex64":
-			case "complex128":
-				return "{ re: 0, im: 0 }";
-			case "string":
-				return '""';
-			case "bool":
-				return "false";
-			default:
-				return null;
-		}
+		return Object.hasOwn(ZERO_FOR_BASIC, name) ? ZERO_FOR_BASIC[name] : null;
+	},
+
+	_zeroForNamedType(name) {
+		if (name === "strings.Builder") return '{ _buf: "" }';
+		if (name === "bytes.Buffer") return "{ _buf: [] }";
+		if (this.structNames.has(name)) return `new ${name}()`;
+		return "null";
 	},
 
 	zeroValueForTypeNode(typeNode) {
@@ -810,11 +616,7 @@ export const expressionGenMethods = {
 			case "TypeName": {
 				const basic = this._zeroForBasicName(typeNode.name);
 				if (basic !== null) return basic;
-				if (typeNode.name === "strings.Builder") return '{ _buf: "" }';
-				if (typeNode.name === "bytes.Buffer") return "{ _buf: [] }";
-				if (this.structNames.has(typeNode.name))
-					return `new ${typeNode.name}()`;
-				return "null";
+				return this._zeroForNamedType(typeNode.name);
 			}
 			case "SliceType":
 				return "null";
@@ -856,10 +658,7 @@ export const expressionGenMethods = {
 				return `{ ${fields} }`;
 			}
 			case "named":
-				if (t.name === "strings.Builder") return '{ _buf: "" }';
-				if (t.name === "bytes.Buffer") return "{ _buf: [] }";
-				if (this.structNames.has(t.name)) return `new ${t.name}()`;
-				return "null";
+				return this._zeroForNamedType(t.name);
 			default:
 				return "null";
 		}
@@ -869,36 +668,15 @@ export const expressionGenMethods = {
 	_typeCheckExpr(typeNode, val) {
 		if (!typeNode) return "true";
 		if (typeNode.kind === "TypeName") {
-			switch (typeNode.name) {
-				case "int":
-				case "uint":
-				case "int8":
-				case "int16":
-				case "int32":
-				case "int64":
-				case "uint8":
-				case "uint16":
-				case "uint32":
-				case "uint64":
-				case "uintptr":
-				case "float32":
-				case "float64":
-				case "byte":
-				case "rune":
-					return `typeof ${val} === "number"`;
-				case "string":
-					return `typeof ${val} === "string"`;
-				case "bool":
-					return `typeof ${val} === "boolean"`;
-				case "nil":
-					return `${val} === null`;
-				case "error":
-					return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
-				default:
-					if (this.structNames.has(typeNode.name))
-						return `${val} instanceof ${typeNode.name}`;
-					return "true"; // unknown type — can't check at runtime
-			}
+			const name = typeNode.name;
+			if (TYPEOF_NUMBER_NAMES.has(name)) return `typeof ${val} === "number"`;
+			if (name === "string") return `typeof ${val} === "string"`;
+			if (name === "bool") return `typeof ${val} === "boolean"`;
+			if (name === "nil") return `${val} === null`;
+			if (name === "error")
+				return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
+			if (this.structNames.has(name)) return `${val} instanceof ${name}`;
+			return "true"; // unknown type — can't check at runtime
 		}
 		return "true";
 	},
@@ -928,1099 +706,124 @@ export const expressionGenMethods = {
 		return base?.kind === "struct" || base?.kind === "array";
 	},
 
-	_genBuilderCall(typeName, method, expr) {
-		// Resolve the receiver — may be a direct var or a &var (pointer)
-		const recv = expr.func.expr;
-		const isPtr = recv._type?.kind === "pointer";
-		const base = isPtr ? `${this.genExpr(recv)}.value` : this.genExpr(recv);
-		const args = expr.args.map((a) => this.genExpr(a));
-
-		if (typeName === "strings.Builder") {
-			switch (method) {
-				case "WriteString":
-					return `(${base}._buf += ${args[0]}, [${args[0]}.length, null])`;
-				case "WriteByte":
-				case "WriteRune":
-					return `(${base}._buf += String.fromCodePoint(${args[0]}))`;
-				case "Write":
-					return `(${base}._buf += String.fromCharCode(...${args[0]}))`;
-				case "String":
-					return `${base}._buf`;
-				case "Len":
-					return `${base}._buf.length`;
-				case "Reset":
-					return `(${base}._buf = "")`;
-				case "Grow":
-					return "undefined";
-			}
-		}
-
-		if (typeName === "bytes.Buffer") {
-			switch (method) {
-				case "WriteString":
-					return `(${base}._buf.push(...new TextEncoder().encode(${args[0]})), [${args[0]}.length, null])`;
-				case "WriteByte":
-					return `${base}._buf.push(${args[0]})`;
-				case "Write":
-					return `(${base}._buf.push(...${args[0]}), [${args[0]}.length, null])`;
-				case "String":
-					return `new TextDecoder().decode(new Uint8Array(${base}._buf))`;
-				case "Bytes":
-					return `${base}._buf.slice()`;
-				case "Len":
-					return `${base}._buf.length`;
-				case "Reset":
-					return `(${base}._buf = [])`;
-				case "Grow":
-					return "undefined";
-			}
-		}
-
-		return undefined;
-	},
-
-	_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));
-
-		switch (method) {
-			case "MatchString":
-				return `${re}.test(${args[0]})`;
-			case "FindString":
-				return `(${re}.exec(${args[0]})?.[0] ?? "")`;
-			case "FindStringIndex":
-				return `((m => m ? [m.index, m.index + m[0].length] : null)(${re}.exec(${args[0]})))`;
-			case "FindAllString":
-				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => m[0])`;
-			case "FindStringSubmatch":
-				return `[...(${re}.exec(${args[0]}) ?? [])]`;
-			case "FindAllStringSubmatch":
-				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => [...m])`;
-			case "ReplaceAllString":
-				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]})`;
-			case "ReplaceAllLiteralString":
-				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]}.replace(/\\$/g, '$$$$'))`;
-			case "Split":
-				return `${args[0]}.split(${re}).slice(0, ${args[1]} < 0 ? undefined : ${args[1]})`;
-			case "String":
-				return `${re}.source`;
-		}
-		return undefined;
-	},
-
-	_genSlices(fn, a) {
-		switch (fn) {
-			case "Contains": {
-				const [s, v] = a();
-				return `${s}.includes(${v})`;
-			}
-			case "Index": {
-				const [s, v] = a();
-				return `${s}.indexOf(${v})`;
-			}
-			case "Equal": {
-				this._usesEqual = true;
-				const [a1, b1] = a();
-				return `__equal(${a1}, ${b1})`;
-			}
-			case "Compare": {
-				const [a1, b1] = a();
-				return `((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; })(${a1}, ${b1})`;
-			}
-			case "Sort": {
-				const [s] = a();
-				return `${s}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`;
-			}
-			case "SortFunc": {
-				const [s, cmp] = a();
-				return `${s}.sort(${cmp})`;
-			}
-			case "SortStableFunc": {
-				const [s, cmp] = a();
-				return `${s}.sort(${cmp})`;
-			}
-			case "IsSorted": {
-				const [s] = a();
-				return `((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${s})`;
-			}
-			case "IsSortedFunc": {
-				const [s, cmp] = a();
-				return `((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${s}, ${cmp})`;
-			}
-			case "Reverse": {
-				const [s] = a();
-				return `${s}.reverse()`;
-			}
-			case "Max": {
-				const [s] = a();
-				return `Math.max(...${s})`;
-			}
-			case "Min": {
-				const [s] = a();
-				return `Math.min(...${s})`;
-			}
-			case "MaxFunc": {
-				const [s, cmp] = a();
-				return `((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${s}, ${cmp})`;
-			}
-			case "MinFunc": {
-				const [s, cmp] = a();
-				return `((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${s}, ${cmp})`;
-			}
-			case "Clone": {
-				const [s] = a();
-				return `${s}.slice()`;
-			}
-			case "Compact": {
-				const [s] = a();
-				return `((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${s})`;
-			}
-			case "CompactFunc": {
-				const [s, eq] = a();
-				return `((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${s}, ${eq})`;
-			}
-			case "Concat": {
-				const args = a();
-				return `[].concat(${args.join(", ")})`;
-			}
-			case "Delete": {
-				const [s, i, j] = a();
-				return `[...${s}.slice(0, ${i}), ...${s}.slice(${j})]`;
-			}
-			case "DeleteFunc": {
-				const [s, fn2] = a();
-				return `${s}.filter((v) => !${fn2}(v))`;
-			}
-			case "Insert": {
-				const args = a();
-				const s = args[0];
-				const i = args[1];
-				const vs = args.slice(2);
-				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${i})]`;
-			}
-			case "Replace": {
-				const args = a();
-				const s = args[0];
-				const i = args[1];
-				const j = args[2];
-				const vs = args.slice(3);
-				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${j})]`;
-			}
-			case "Grow":
-			case "Clip": {
-				const [s] = a();
-				return `${s}.slice()`;
-			}
-		}
-		return undefined;
-	},
-
-	_genIo(fn, _a, expr) {
-		switch (fn) {
-			case "WriteString": {
-				const writerArg = expr.args[0];
-				const writerType = writerArg._type;
-				const typeName =
-					writerType?.name ??
-					(writerType?.kind === "pointer" ? writerType.base?.name : null);
-				const w = this.genExpr(writerArg);
-				const s = this.genExpr(expr.args[1]);
-				const isPtr = writerType?.kind === "pointer";
-				const base = isPtr ? `${w}.value` : w;
-				if (typeName === "strings.Builder") {
-					return `((b,s) => { b._buf += s; return [s.length, null]; })(${base}, ${s})`;
-				}
-				if (typeName === "bytes.Buffer") {
-					return `((b,s) => { b._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; })(${base}, ${s})`;
-				}
-				// Generic: auto-dereference pointer, then dispatch on concrete writer type.
-				// strings.Builder has { _buf: string }, bytes.Buffer has { _buf: [] }.
-				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return [w.WriteString(s), null]; if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { w._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; } return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
-			}
-			case "ReadAll": {
-				const r = this.genExpr(expr.args[0]);
-				return `((r) => { const w = r?.value ?? r; if (typeof w._src === "string") { const s = w._src.slice(w._pos); w._pos = w._src.length; return [[...s].map(c => c.charCodeAt(0)), null]; } if (Array.isArray(w._src)) { const b = w._src.slice(w._pos); w._pos = w._src.length; return [b, null]; } const chunks = []; const buf = new Array(4096); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) chunks.push(...buf.slice(0, n)); err = e; } return [chunks, err === "EOF" ? null : err]; })(${r})`;
-			}
-		}
-		return undefined;
-	},
-
-	_genHtml(fn, a) {
-		switch (fn) {
-			case "EscapeString": {
-				const [s] = a();
-				return `${s}.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&#34;").replace(/'/g,"&#39;")`;
-			}
-			case "UnescapeString": {
-				const [s] = a();
-				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
-			}
-		}
-		return undefined;
-	},
-
-	_genMaps(fn, a) {
-		switch (fn) {
-			case "Keys": {
-				const [m] = a();
-				return `Object.keys(${m})`;
-			}
-			case "Values": {
-				const [m] = a();
-				return `Object.values(${m})`;
-			}
-			case "Clone": {
-				const [m] = a();
-				return `({...${m}})`;
-			}
-			case "Copy": {
-				const [dst, src] = a();
-				return `Object.assign(${dst}, ${src})`;
-			}
-			case "Equal": {
+	_genComplexBinary(expr) {
+		const l = this._genComplexOperand(expr.left);
+		const r = this._genComplexOperand(expr.right);
+		switch (expr.op) {
+			case "+":
+				return `{ re: ${l}.re + ${r}.re, im: ${l}.im + ${r}.im }`;
+			case "-":
+				return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
+			case "*":
+				this._usesCmul = true;
+				return `__cmul(${l}, ${r})`;
+			case "/":
+				this._usesCdiv = true;
+				return `__cdiv(${l}, ${r})`;
+			case "==":
+				return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
+			case "!=":
+				return `(${l}.re !== ${r}.re || ${l}.im !== ${r}.im)`;
+		}
+	},
+
+	_genBinaryExpr(expr) {
+		if (
+			isComplex(expr._type) ||
+			isComplex(expr.left._type) ||
+			isComplex(expr.right._type)
+		)
+			return this._genComplexBinary(expr);
+		const l = this.genExpr(expr.left);
+		const r = this.genExpr(expr.right);
+		if (
+			expr.op === "/" &&
+			this.isIntType(expr.left._type) &&
+			this.isIntType(expr.right._type)
+		)
+			return `Math.trunc(${l} / ${r})`;
+		if (expr.op === "&^") return `${l} & ~${r}`;
+		if (expr.op === "==" || expr.op === "!=") {
+			if (this._isStructOrArrayType(expr.left._type)) {
 				this._usesEqual = true;
-				const [a1, b1] = a();
-				return `__equal(${a1}, ${b1})`;
-			}
-			case "EqualFunc": {
-				const [m1, m2, eq] = a();
-				return `((a, b, f) => { const ka = Object.keys(a); if (ka.length !== Object.keys(b).length) return false; return ka.every(k => k in b && f(a[k], b[k])); })(${m1}, ${m2}, ${eq})`;
-			}
-			case "Delete": {
-				const [m, k] = a();
-				return `(delete ${m}[${k}], undefined)`;
-			}
-			case "DeleteFunc": {
-				const [m, fn2] = a();
-				return `Object.keys(${m}).forEach(k => { if (${fn2}(k, ${m}[k])) delete ${m}[k]; })`;
+				const cmp = `__equal(${l}, ${r})`;
+				return expr.op === "==" ? cmp : `!${cmp}`;
 			}
 		}
-		return undefined;
+		const op = expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
+		return `${l} ${op} ${r}`;
 	},
 
-	typeComment(typeNode) {
-		if (!typeNode) return "unknown";
-		switch (typeNode.kind) {
-			case "TypeName":
-				return typeNode.name;
-			case "SliceType":
-				return `[]${this.typeComment(typeNode.elem)}`;
-			case "MapType":
-				return `map[${this.typeComment(typeNode.key)}]${this.typeComment(typeNode.value)}`;
-			default:
-				return typeNode.kind;
+	_genTypeConversion(expr) {
+		const inner = this.genExpr(expr.expr);
+		const t = expr.targetType;
+		if (t?.name === "complex128" || t?.name === "complex64") {
+			return isComplex(expr.expr._type) ? inner : `{ re: ${inner}, im: 0 }`;
 		}
-	},
-
-	// Dispatch table for stdlib namespace calls (pkg.Func → inline JS).
-	// Returns the generated JS string, or undefined if not handled.
-	_genStdlibCall(ns, fn, expr) {
-		const a = () => expr.args.map((e) => this.genExpr(e));
-		switch (ns) {
-			case "fmt":
-				return this._genFmt(fn, a, expr);
-			case "strings":
-				return this._genStrings(fn, a);
-			case "bytes":
-				return this._genBytes(fn, a);
-			case "strconv":
-				return this._genStrconv(fn, a);
-			case "sort":
-				return this._genSort(fn, a);
-			case "math":
-				return this._genMath(fn, a);
-			case "unicode":
-				return this._genUnicode(fn, a);
-			case "os":
-				return this._genOs(fn, a);
-			case "errors":
-				return this._genErrors(fn, a);
-			case "time":
-				return this._genTime(fn, a);
-			case "regexp":
-				return this._genRegexp(fn, a);
-			case "slices":
-				return this._genSlices(fn, a);
-			case "maps":
-				return this._genMaps(fn, a);
-			case "html":
-				return this._genHtml(fn, a);
-			case "io":
-				return this._genIo(fn, a, expr);
-			case "rand":
-				return this._genRand(fn, a);
-			case "utf8":
-				return this._genUtf8(fn, a);
-			case "path":
-				return this._genPath(fn, a, expr);
-			case "gom":
-				return this._genGom(fn, expr);
-			default:
-				return undefined;
+		if (t?.kind === "ArrayType")
+			return this._genArrayTypeConversion(expr, inner, t);
+		if (t?.kind === "SliceType")
+			return this._genSliceTypeConversion(expr, inner, t);
+		const target = t?.name;
+		if (target === "error") {
+			this._usesError = true;
+			return `__error(${inner})`;
 		}
+		if (target && this.namedWrapperNames.has(target))
+			return `new ${target}(${inner})`;
+		return this._genPrimitiveConversion(expr, inner, target);
 	},
 
-	_genGom(fn, expr) {
-		const a = () =>
-			expr.args.map((e) =>
-				e._spread ? `...${this.genExpr(e)}` : this.genExpr(e),
-			);
-		const elementTags = {
-			Div: "div",
-			Section: "section",
-			Article: "article",
-			Aside: "aside",
-			Header: "header",
-			Footer: "footer",
-			Main: "main",
-			Nav: "nav",
-			Figure: "figure",
-			H1: "h1",
-			H2: "h2",
-			H3: "h3",
-			H4: "h4",
-			H5: "h5",
-			H6: "h6",
-			Span: "span",
-			A: "a",
-			Strong: "strong",
-			Em: "em",
-			Code: "code",
-			Pre: "pre",
-			Small: "small",
-			Mark: "mark",
-			P: "p",
-			Br: "br",
-			Hr: "hr",
-			Ul: "ul",
-			Ol: "ol",
-			Li: "li",
-			Dl: "dl",
-			Dt: "dt",
-			Dd: "dd",
-			Form: "form",
-			Input: "input",
-			Button: "button",
-			Textarea: "textarea",
-			Select: "select",
-			Option: "option",
-			Label: "label",
-			Fieldset: "fieldset",
-			Legend: "legend",
-			Img: "img",
-			Video: "video",
-			Audio: "audio",
-			Canvas: "canvas",
-			Table: "table",
-			Thead: "thead",
-			Tbody: "tbody",
-			Tfoot: "tfoot",
-			Tr: "tr",
-			Th: "th",
-			Td: "td",
-		};
-		if (elementTags[fn]) {
-			const tag = elementTags[fn];
-			const args = a();
-			if (args.length === 0)
-				return `(()=>({Mount(p){const e=document.createElement("${tag}");p.appendChild(e);}}))()`;
-			return (
-				`((...c)=>({Mount(p){const e=document.createElement("${tag}");c.forEach(n=>n?.Mount?.(e));p.appendChild(e);}}))` +
-				`(${args.join(",")})`
-			);
+	_genArrayTypeConversion(expr, inner, t) {
+		const srcResolved =
+			expr.expr._type?.kind === "named"
+				? expr.expr._type.underlying
+				: expr.expr._type;
+		if (srcResolved?.kind === "slice") {
+			const size = t.size?.value !== undefined ? Number(t.size.value) : t.size;
+			return `${inner}.slice(0, ${size})`;
 		}
-		const attrHelpers = {
-			For: "for",
-			Name: "name",
-			Value: "value",
-			Target: "target",
-			Rel: "rel",
-			Alt: "alt",
-			Title: "title",
-			Lang: "lang",
-			Action: "action",
-			Method: "method",
-			AutoComplete: "autocomplete",
-			Draggable: "draggable",
-			Role: "role",
-			StyleAttr: "style",
-		};
-		if (attrHelpers[fn]) {
-			const [v] = a();
-			return `((v)=>({Mount(e){e.setAttribute("${attrHelpers[fn]}",v)}}))(${v})`;
-		}
-		if (fn === "AriaLabel") {
-			const [v] = a();
-			return `((v)=>({Mount(e){e.setAttribute("aria-label",v)}}))(${v})`;
-		}
-		const boolAttrs = {
-			Disabled: "disabled",
-			Checked: "checked",
-			Selected: "selected",
-			Readonly: "readonly",
-		};
-		if (boolAttrs[fn])
-			return `({Mount(e){e.setAttribute("${boolAttrs[fn]}","")}})`;
-
-		const args = a();
-		switch (fn) {
-			case "El": {
-				const [tag, ...children] = args;
-				if (children.length === 0)
-					return `((t)=>({Mount(p){const e=document.createElement(t);p.appendChild(e);}})) (${tag})`;
-				return (
-					`((t,...c)=>({Mount(p){const e=document.createElement(t);c.forEach(n=>n?.Mount?.(e));p.appendChild(e);}}))` +
-					`(${tag},${children.join(",")})`
-				);
-			}
-			case "Text": {
-				const [s] = args;
-				return `((s)=>({Mount(p){p.appendChild(document.createTextNode(s))}}))(${s})`;
-			}
-			case "Attr": {
-				const [name, value] = args;
-				return `((n,v)=>({Mount(e){e.setAttribute(n,v)}}))(${name},${value})`;
-			}
-			case "Class":
-				return `((v)=>({Mount(e){e.className=v}}))(${args[0]})`;
-			case "Type":
-				return `((v)=>({Mount(e){e.type=v}}))(${args[0]})`;
-			case "Href":
-				return `((v)=>({Mount(e){e.href=v}}))(${args[0]})`;
-			case "Src":
-				return `((v)=>({Mount(e){e.src=v}}))(${args[0]})`;
-			case "Placeholder":
-				return `((v)=>({Mount(e){e.placeholder=v}}))(${args[0]})`;
-			case "DataAttr":
-				return `((k,v)=>({Mount(e){e.setAttribute("data-"+k,v)}}))(${args[0]},${args[1]})`;
-			case "If":
-				return `((c,n)=>c?n:{Mount(){}})(${args[0]},${args[1]})`;
-			case "Map":
-				return `((s,f)=>{const c=s.map(f);return{_items:c,Mount(p){c.forEach(n=>n.Mount(p))}}})(${args[0]},${args[1]})`;
-			case "Style":
-				return `((s)=>({Mount(p){const e=document.createElement("style");e.textContent=s;p.appendChild(e);}})) (${args[0]})`;
-			case "Mount":
-				return `((sel,n)=>{const e=document.querySelector(sel);e.innerHTML="";n.Mount(e)})(${args[0]},${args[1]})`;
-			case "MountTo":
-				return `((sel,n)=>{const e=document.querySelector(sel);n.Mount(e)})(${args[0]},${args[1]})`;
-		}
-		return undefined;
+		return inner;
 	},
 
-	_genFmt(fn, _a, expr) {
-		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
-		switch (fn) {
-			case "Sprintf":
-				this._usesSprintf = true;
-				return `__sprintf(${fmtArgs})`;
-			case "Errorf": {
-				this._usesSprintf = true;
-				this._usesError = true;
-				const fmtStr = expr.args[0];
-				if (fmtStr?.kind === "BasicLit" && fmtStr.value?.includes("%w")) {
-					const lastArg = this.genExpr(expr.args[expr.args.length - 1]);
-					return `__error(__sprintf(${fmtArgs}), ${lastArg})`;
-				}
-				return `__error(__sprintf(${fmtArgs}))`;
-			}
-			case "Printf":
-			case "Print":
-				this._usesSprintf = true;
-				return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
-			case "Println":
-				this._usesSprintf = true;
-				return `console.log(__sprintf(${fmtArgs}))`;
-			case "Fprintf":
-			case "Fprintln":
-			case "Fprint": {
-				this._usesSprintf = true;
-				const writerArg = expr.args[0];
-				const rest = expr.args.slice(1);
-				const restJs = rest.map((e) => this.genExpr(e)).join(", ");
-				// Resolve the writer to its underlying buffer expression
-				const writerType = writerArg._type;
-				const targetTypeName =
-					writerType?.name ??
-					(writerType?.kind === "pointer" ? writerType.base?.name : null);
-				let buf;
-				if (targetTypeName === "strings.Builder") {
-					const w = this.genExpr(writerArg);
-					buf =
-						writerType?.kind === "pointer" ? `${w}.value._buf` : `${w}._buf`;
-				} else if (targetTypeName === "bytes.Buffer") {
-					const w = this.genExpr(writerArg);
-					const base = writerType?.kind === "pointer" ? `${w}.value` : w;
-					buf = null;
-					if (fn === "Fprintf") {
-						return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, __sprintf(${restJs}))`;
-					}
-					const valJs =
-						fn === "Fprintln"
-							? `__sprintf("%v\\n", ${restJs})`
-							: `__sprintf("%v", ${restJs})`;
-					return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${valJs})`;
-				} else {
-					// Generic io.Writer fallback — call .WriteString if available
-					const w = this.genExpr(writerArg);
-					const formatted =
-						fn === "Fprintf"
-							? `__sprintf(${restJs})`
-							: fn === "Fprintln"
-								? `__sprintf("%v\\n", ${restJs})`
-								: `__sprintf("%v", ${restJs})`;
-					return `${w}.WriteString(${formatted})`;
-				}
-				// strings.Builder path
-				if (fn === "Fprintf") return `(${buf} += __sprintf(${restJs}))`;
-				if (fn === "Fprintln")
-					return `(${buf} += __sprintf("%v\\n", ${restJs}))`;
-				return `(${buf} += __sprintf("%v", ${restJs}))`;
-			}
-			case "Sscan": {
-				const strArg = this.genExpr(expr.args[0]);
-				const restArgs = expr.args
-					.slice(1)
-					.map((e) => this.genExpr(e))
-					.join(", ");
-				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
-			}
-			case "Sscanln": {
-				const strArg = this.genExpr(expr.args[0]);
-				const restArgs = expr.args
-					.slice(1)
-					.map((e) => this.genExpr(e))
-					.join(", ");
-				return `((str, ...ptrs) => { const line = str.split("\\n")[0]; const tokens = line.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
-			}
-			case "Sscanf": {
-				const strArg = this.genExpr(expr.args[0]);
-				const fmtArg = this.genExpr(expr.args[1]);
-				const restArgs = expr.args
-					.slice(2)
-					.map((e) => this.genExpr(e))
-					.join(", ");
-				return `((str, _fmt, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "input does not match format" : null]; })(${strArg}, ${fmtArg}, ${restArgs})`;
-			}
-			default:
-				return undefined;
-		}
+	_isStringSource(srcType) {
+		return (
+			(srcType?.kind === "basic" && srcType?.name === "string") ||
+			(srcType?.kind === "untyped" && srcType?.base === "string")
+		);
 	},
 
-	_genStrings(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Contains":
-				return `${args[0]}.includes(${args[1]})`;
-			case "HasPrefix":
-				return `${args[0]}.startsWith(${args[1]})`;
-			case "HasSuffix":
-				return `${args[0]}.endsWith(${args[1]})`;
-			case "Index":
-				return `${args[0]}.indexOf(${args[1]})`;
-			case "LastIndex":
-				return `${args[0]}.lastIndexOf(${args[1]})`;
-			case "Count":
-				return `((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${args[0]}, ${args[1]})`;
-			case "Repeat":
-				return `${args[0]}.repeat(${args[1]})`;
-			case "Replace":
-				return `${args[0]}.replace(${args[1]}, ${args[2]})`;
-			case "ReplaceAll":
-				return `${args[0]}.replaceAll(${args[1]}, ${args[2]})`;
-			case "ToUpper":
-				return `${args[0]}.toUpperCase()`;
-			case "ToLower":
-				return `${args[0]}.toLowerCase()`;
-			case "TrimSpace":
-				return `${args[0]}.trim()`;
-			case "Trim":
-				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), "")`;
-			case "TrimPrefix":
-				return `((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${args[0]}, ${args[1]})`;
-			case "TrimSuffix":
-				return `((s, suf) => !suf.length || !s.endsWith(suf) ? s : s.slice(0, -suf.length))(${args[0]}, ${args[1]})`;
-			case "TrimLeft":
-				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+\`), "")`;
-			case "TrimRight":
-				return `${args[0]}.replace(new RegExp(\`[\${${args[1]}}]+$\`), "")`;
-			case "Split":
-				return `${args[0]}.split(${args[1]})`;
-			case "Join":
-				return `${args[0]}.join(${args[1]})`;
-			case "EqualFold":
-				return `${args[0]}.toLowerCase() === ${args[1]}.toLowerCase()`;
-			case "Fields":
-				return `(${args[0]}).trim() === '' ? [] : (${args[0]}).trim().split(/\\s+/)`;
-			case "Cut":
-				return `((s, sep) => { const i = s.indexOf(sep); return i < 0 ? [s, "", false] : [s.slice(0, i), s.slice(i + sep.length), true]; })(${args[0]}, ${args[1]})`;
-			case "CutPrefix":
-				return `(${args[0]}).startsWith(${args[1]}) ? [(${args[0]}).slice((${args[1]}).length), true] : [${args[0]}, false]`;
-			case "CutSuffix":
-				return `(${args[0]}).endsWith(${args[1]}) ? [(${args[0]}).slice(0, -(${args[1]}).length), true] : [${args[0]}, false]`;
-			case "SplitN":
-				return `((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; })(${args[0]}, ${args[1]}, ${args[2]})`;
-			case "SplitAfter":
-				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; })(${args[0]}, ${args[1]})`;
-			case "SplitAfterN":
-				return `((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; })(${args[0]}, ${args[1]}, ${args[2]})`;
-			case "IndexAny":
-				return `((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; })(${args[0]}, ${args[1]})`;
-			case "LastIndexAny":
-				return `((s, chars) => { let m = -1; for (const c of chars) { const i = s.lastIndexOf(c); if (i > m) m = i; } return m; })(${args[0]}, ${args[1]})`;
-			case "ContainsAny":
-				return `[...(${args[1]})].some(c => (${args[0]}).includes(c))`;
-			case "ContainsRune":
-				return `(${args[0]}).includes(String.fromCodePoint(${args[1]}))`;
-			case "IndexRune":
-				return `(${args[0]}).indexOf(String.fromCodePoint(${args[1]}))`;
-			case "IndexByte":
-				return `(${args[0]}).indexOf(String.fromCharCode(${args[1]}))`;
-			case "LastIndexByte":
-				return `(${args[0]}).lastIndexOf(String.fromCharCode(${args[1]}))`;
-			case "Map":
-				return `[...(${args[1]})].map(c => String.fromCodePoint((${args[0]})(c.codePointAt(0)))).join("")`;
-			case "Title":
-				return `(${args[0]}).replace(/\\b\\w/g, c => c.toUpperCase())`;
-			case "ToTitle":
-				return `(${args[0]}).toUpperCase()`;
-			case "TrimFunc":
-				return `((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); })(${args[0]}, ${args[1]})`;
-			case "TrimLeftFunc":
-				return `((s, f) => { let l = 0; while (l < s.length && f(s.codePointAt(l))) l++; return s.slice(l); })(${args[0]}, ${args[1]})`;
-			case "TrimRightFunc":
-				return `((s, f) => { let r = s.length; while (r > 0 && f(s.codePointAt(r - 1))) r--; return s.slice(0, r); })(${args[0]}, ${args[1]})`;
-			case "IndexFunc":
-				return `((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; })(${args[0]}, ${args[1]})`;
-			case "LastIndexFunc":
-				return `((s, f) => { for (let i = s.length - 1; i >= 0; i--) { const cp = s.codePointAt(i); if (f(cp)) return i; } return -1; })(${args[0]}, ${args[1]})`;
-			case "NewReader":
-				return `{_src: ${args[0]}, _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; }}`;
-			case "NewReplacer": {
-				const allArgs = args.join(", ");
-				return `((...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; } }; })(${allArgs})`;
-			}
-			default:
-				return undefined;
+	_genSliceTypeConversion(expr, inner, t) {
+		const elem = t.elem?.name;
+		if (elem === "byte" || elem === "uint8")
+			return `Array.from(new TextEncoder().encode(${inner}))`;
+		if (elem === "rune" || elem === "int32" || elem === "int") {
+			if (this._isStringSource(expr.expr._type))
+				return `Array.from(${inner}, __c => __c.codePointAt(0))`;
 		}
+		return `Array.from(${inner})`;
 	},
 
-	_genBytes(fn, a) {
-		const __bs = `(b => String.fromCharCode(...b))`;
-		const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
-		const args = a();
-		switch (fn) {
-			case "Contains":
-				return `${__bs}(${args[0]}).includes(${__bs}(${args[1]}))`;
-			case "HasPrefix":
-				return `((b, p) => { for (let i = 0; i < p.length; i++) if (b[i] !== p[i]) return false; return b.length >= p.length; })(${args[0]}, ${args[1]})`;
-			case "HasSuffix":
-				return `((b, s) => { const off = b.length - s.length; if (off < 0) return false; for (let i = 0; i < s.length; i++) if (b[off + i] !== s[i]) return false; return true; })(${args[0]}, ${args[1]})`;
-			case "Index":
-				return `${__bs}(${args[0]}).indexOf(${__bs}(${args[1]}))`;
-			case "Count":
-				return `((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${args[0]}, ${args[1]})`;
-			case "Repeat":
-				return `${__sb}(${__bs}(${args[0]}).repeat(${args[1]}))`;
-			case "Replace":
-				return `((b, o, n, cnt) => { let s = ${__bs}(b), os = ${__bs}(o), ns = ${__bs}(n); if (cnt < 0) return ${__sb}(s.replaceAll(os, ns)); for (let i = 0; i < cnt; i++) s = s.replace(os, ns); return ${__sb}(s); })(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
-			case "ToUpper":
-				return `${__sb}(${__bs}(${args[0]}).toUpperCase())`;
-			case "ToLower":
-				return `${__sb}(${__bs}(${args[0]}).toLowerCase())`;
-			case "TrimSpace":
-				return `${__sb}(${__bs}(${args[0]}).trim())`;
-			case "Trim":
-				return `${__sb}(${__bs}(${args[0]}).replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), ""))`;
-			case "Equal":
-				return `((a, b) => { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false; return true; })(${args[0]}, ${args[1]})`;
-			case "Split":
-				return `${__bs}(${args[0]}).split(${__bs}(${args[1]})).map(p => ${__sb}(p))`;
-			case "Join":
-				return `${__sb}(${args[0]}.map(p => ${__bs}(p)).join(${__bs}(${args[1]})))`;
-			case "ReplaceAll":
-				return `((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else r.push(b[i++]); } return r.concat(b.slice(i)); })(${args[0]}, ${args[1]}, ${args[2]})`;
-			case "TrimPrefix":
-				return `((b, p) => p.every((v, i) => b[i] === v) ? b.slice(p.length) : b.slice())(${args[0]}, ${args[1]})`;
-			case "TrimSuffix":
-				return `((b, s) => s.length && s.every((v, i) => b[b.length - s.length + i] === v) ? b.slice(0, -s.length) : b.slice())(${args[0]}, ${args[1]})`;
-			case "TrimLeft":
-				return `((b, c) => { let i = 0; while (i < b.length && c.includes(String.fromCharCode(b[i]))) i++; return b.slice(i); })(${args[0]}, ${args[1]})`;
-			case "TrimRight":
-				return `((b, c) => { let i = b.length; while (i > 0 && c.includes(String.fromCharCode(b[i - 1]))) i--; return b.slice(0, i); })(${args[0]}, ${args[1]})`;
-			case "TrimFunc":
-				return `((b, f) => { let l = 0, r = b.length; while (l < r && f(b[l])) l++; while (r > l && f(b[r - 1])) r--; return b.slice(l, r); })(${args[0]}, ${args[1]})`;
-			case "IndexByte":
-				return `(${args[0]}).indexOf(${args[1]})`;
-			case "LastIndex":
-				return `((b, s) => { for (let i = b.length - s.length; i >= 0; i--) if (s.every((v, j) => b[i + j] === v)) return i; return -1; })(${args[0]}, ${args[1]})`;
-			case "LastIndexByte":
-				return `(${args[0]}).lastIndexOf(${args[1]})`;
-			case "Fields":
-				return `((b) => { const s = String.fromCharCode(...b).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => [...w].map(c => c.charCodeAt(0))); })(${args[0]})`;
-			case "Cut":
-				return `((b, sep) => { for (let i = 0; i <= b.length - sep.length; i++) if (sep.every((v, j) => b[i + j] === v)) return [b.slice(0, i), b.slice(i + sep.length), true]; return [b.slice(), [], false]; })(${args[0]}, ${args[1]})`;
-			case "ContainsAny":
-				return `[...(${args[1]})].some(c => (${args[0]}).includes(c.charCodeAt(0)))`;
-			case "ContainsRune":
-				return `(${args[0]}).includes(${args[1]})`;
-			case "Map":
-				return `(${args[1]}).map(v => (${args[0]})(v))`;
-			case "SplitN":
-				return `((b, sep, n) => { if (n === 0) return []; if (n < 0) return ((b, sep) => { const r = []; let i = 0; while (i <= b.length) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0 || j >= b.length) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(b, sep); const r = []; let i = 0; for (let c = 1; c < n; c++) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(${args[0]}, ${args[1]}, ${args[2]})`;
-			case "NewReader":
-				return `{_src: ${args[0]}, _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[this._pos + i]; this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(b) { this._src = b; this._pos = 0; }}`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genStrconv(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Itoa":
-				return `String(${args[0]})`;
-			case "Atoi":
-				return `(Number.isNaN(Number(${args[0]})) ? [0, "invalid syntax"] : [Number(${args[0]}) | 0, null])`;
-			case "FormatBool":
-				return `String(${args[0]})`;
-			case "FormatInt":
-				return `(${args[0]}).toString(${args[1]})`;
-			case "FormatFloat":
-				return `String(${args[0]})`;
-			case "ParseFloat":
-				return `(Number.isNaN(Number(${args[0]})) ? [0, "invalid syntax"] : [Number(${args[0]}), null])`;
-			case "ParseInt":
-				return `(Number.isNaN(parseInt(${args[0]}, ${args[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${args[0]}, ${args[1]} || 10), null])`;
-			case "ParseBool":
-				return `(${args[0]} === "true" || ${args[0]} === "1" ? [true, null] : ${args[0]} === "false" || ${args[0]} === "0" ? [false, null] : [false, "invalid syntax"])`;
-			case "Quote":
-				return `JSON.stringify(${args[0]})`;
-			case "Unquote":
-				return `((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", "invalid syntax"]; } })(${args[0]})`;
-			case "AppendInt":
-				return `[...(${args[0]}), ...new TextEncoder().encode((${args[1]}).toString(${args[2]}))]`;
-			case "AppendFloat":
-				return `[...(${args[0]}), ...new TextEncoder().encode(${args[1]}.toFixed(${args[3]} < 0 ? 6 : ${args[3]}))]`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genSort(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Ints":
-			case "Float64s":
-				return `${args[0]}.sort((a, b) => a - b)`;
-			case "Strings":
-				return `${args[0]}.sort()`;
-			case "Slice":
-			case "SliceStable":
-				return `${args[0]}.sort((a, b) => ${args[1]}(a, b) ? -1 : ${args[1]}(b, a) ? 1 : 0)`;
-			case "SliceIsSorted":
-				return `${args[0]}.every((v, i, a) => i === 0 || ${args[1]}(a[i - 1], v))`;
-			case "Search":
-				return `((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; })(${args[0]}, ${args[1]})`;
-			case "IntsAreSorted":
-			case "Float64sAreSorted":
-			case "StringsAreSorted":
-				return `(${args[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genMath(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Abs":
-				return `Math.abs(${args[0]})`;
-			case "Floor":
-				return `Math.floor(${args[0]})`;
-			case "Ceil":
-				return `Math.ceil(${args[0]})`;
-			case "Round":
-				return `Math.round(${args[0]})`;
-			case "Sqrt":
-				return `Math.sqrt(${args[0]})`;
-			case "Cbrt":
-				return `Math.cbrt(${args[0]})`;
-			case "Pow":
-				return `Math.pow(${args[0]}, ${args[1]})`;
-			case "Log":
-				return `Math.log(${args[0]})`;
-			case "Log2":
-				return `Math.log2(${args[0]})`;
-			case "Log10":
-				return `Math.log10(${args[0]})`;
-			case "Sin":
-				return `Math.sin(${args[0]})`;
-			case "Cos":
-				return `Math.cos(${args[0]})`;
-			case "Tan":
-				return `Math.tan(${args[0]})`;
-			case "Min":
-				return `Math.min(${args[0]}, ${args[1]})`;
-			case "Max":
-				return `Math.max(${args[0]}, ${args[1]})`;
-			case "Mod":
-				return `${args[0]} % ${args[1]}`;
-			case "Inf":
-				return `(${args[0]} >= 0 ? Infinity : -Infinity)`;
-			case "IsNaN":
-				return `Number.isNaN(${args[0]})`;
-			case "IsInf":
-				return `(${args[1]} > 0 ? ${args[0]} === Infinity : ${args[1]} < 0 ? ${args[0]} === -Infinity : !Number.isFinite(${args[0]}))`;
-			case "NaN":
-				return "NaN";
-			case "Atan":
-				return `Math.atan(${args[0]})`;
-			case "Atan2":
-				return `Math.atan2(${args[0]}, ${args[1]})`;
-			case "Asin":
-				return `Math.asin(${args[0]})`;
-			case "Acos":
-				return `Math.acos(${args[0]})`;
-			case "Exp":
-				return `Math.exp(${args[0]})`;
-			case "Exp2":
-				return `Math.pow(2, ${args[0]})`;
-			case "Trunc":
-				return `Math.trunc(${args[0]})`;
-			case "Hypot":
-				return `Math.hypot(${args[0]}, ${args[1]})`;
-			case "Signbit":
-				return `(${args[0]} < 0 || Object.is(${args[0]}, -0))`;
-			case "Copysign":
-				return `(Math.abs(${args[0]}) * (${args[1]} < 0 || Object.is(${args[1]}, -0) ? -1 : 1))`;
-			case "Dim":
-				return `Math.max(${args[0]} - ${args[1]}, 0)`;
-			case "Remainder":
-				return `(${args[0]} - Math.round(${args[0]} / ${args[1]}) * ${args[1]})`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genUnicode(fn, a) {
-		const args = a();
-		const cp = `String.fromCodePoint(${args[0]})`;
-		switch (fn) {
-			case "IsLetter":
-				return `/\\p{L}/u.test(${cp})`;
-			case "IsDigit":
-				return `/\\p{Nd}/u.test(${cp})`;
-			case "IsSpace":
-				return `/\\s/.test(${cp})`;
-			case "IsUpper":
-				return `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(${cp})`;
-			case "IsLower":
-				return `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(${cp})`;
-			case "IsPunct":
-				return `/\\p{P}/u.test(${cp})`;
-			case "IsControl":
-				return `/\\p{Cc}/u.test(${cp})`;
-			case "IsPrint":
-				return `!/\\p{Cc}/u.test(${cp})`;
-			case "IsGraphic":
-				return `!/\\p{Cc}/u.test(${cp})`;
-			case "ToUpper":
-				return `${cp}.toUpperCase().codePointAt(0)`;
-			case "ToLower":
-				return `${cp}.toLowerCase().codePointAt(0)`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genOs(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Exit":
-				return `process.exit(${args[0]})`;
-			case "Getenv":
-				return `(process.env[${args[0]}] ?? "")`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genErrors(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "New":
-				this._usesError = true;
-				return `__error(${args[0]})`;
-			case "Is":
-				this._usesErrorIs = true;
-				return `__errorIs(${args[0]}, ${args[1]})`;
-			case "Unwrap":
-				return `(${args[0]}?._cause ?? null)`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genTimeMethodCall(method, expr) {
-		const recv = expr.func.expr;
-		const recvJs = this.genExpr(recv);
-		const args = expr.args.map((a) => this.genExpr(a));
-		switch (method) {
-			case "Format":
-				this._usesTimeFmt = true;
-				return `__timeFmt(${recvJs}._d, ${args[0]})`;
-			case "String":
-				this._usesTimeFmt = true;
-				return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
-			case "Year":
-				return `${recvJs}._d.getFullYear()`;
-			case "Month":
-				return `${recvJs}._d.getMonth() + 1`;
-			case "Day":
-				return `${recvJs}._d.getDate()`;
-			case "Hour":
-				return `${recvJs}._d.getHours()`;
-			case "Minute":
-				return `${recvJs}._d.getMinutes()`;
-			case "Second":
-				return `${recvJs}._d.getSeconds()`;
-			case "Weekday":
-				return `${recvJs}._d.getDay()`;
-			case "Unix":
-				return `Math.floor(${recvJs}._d.getTime() / 1000)`;
-			case "UnixMilli":
-				return `${recvJs}._d.getTime()`;
-			case "Add":
-				return `{_d: new Date(${recvJs}._d.getTime() + (${args[0]}))}`;
-			case "Sub":
-				return `${recvJs}._d.getTime() - (${args[0]})._d.getTime()`;
-			case "Before":
-				return `${recvJs}._d < (${args[0]})._d`;
-			case "After":
-				return `${recvJs}._d > (${args[0]})._d`;
-			case "Equal":
-				return `${recvJs}._d.getTime() === (${args[0]})._d.getTime()`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genTime(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Now":
-				return "{_d: new Date()}";
-			case "Since":
-				return `(Date.now() - (${args[0]})._d.getTime())`;
-			case "Sleep":
-				return `await new Promise(r => setTimeout(r, ${args[0]} / 1000000))`;
-			case "Parse":
-				this._usesTimeParse = true;
-				return `__timeParse(${args[0]}, ${args[1]})`;
-			case "Unix":
-				return `{_d: new Date((${args[0]}) * 1000)}`;
-			case "Date":
-				return `{_d: new Date(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]})}`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genRand(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "Intn":
-			case "Int63n":
-			case "Int31n":
-				return `Math.floor(Math.random() * ${args[0]})`;
-			case "Float64":
-			case "Float32":
-				return "Math.random()";
-			case "Int":
-			case "Int31":
-				return "Math.floor(Math.random() * 2147483647)";
-			case "Int63":
-				return "Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)";
-			case "Seed":
-				return "(void 0)";
-			case "Shuffle":
-				return `((n, f) => { for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${args[0]}, ${args[1]})`;
-			case "Perm":
-				return `((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; })(${args[0]})`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genUtf8(fn, a) {
-		const args = a();
-		switch (fn) {
-			case "RuneCountInString":
-				return `[...(${args[0]})].length`;
-			case "RuneLen":
-				return `((r) => r < 0 ? -1 : r <= 0x7F ? 1 : r <= 0x7FF ? 2 : r <= 0xFFFF ? (r >= 0xD800 && r <= 0xDFFF ? -1 : 3) : r <= 0x10FFFF ? 4 : -1)(${args[0]})`;
-			case "ValidString":
-				return `/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/.test(${args[0]}) === false`;
-			case "ValidRune":
-				return `(${args[0]}) >= 0 && (${args[0]}) <= 0x10FFFF && !((${args[0]}) >= 0xD800 && (${args[0]}) <= 0xDFFF)`;
-			case "DecodeRuneInString":
-				return `((s) => { if (!s) return [0xFFFD, 0]; const cp = s.codePointAt(0); return [cp, cp > 0xFFFF ? 2 : 1]; })(${args[0]})`;
-			case "DecodeLastRuneInString":
-				return `((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]; })(${args[0]})`;
-			case "FullRuneInString":
-				return `(${args[0]}).length > 0`;
-			default:
-				return undefined;
-		}
-	},
-
-	_genPath(fn, a, expr) {
-		const args = a();
-		switch (fn) {
-			case "Base":
-				return `((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${args[0]})`;
-			case "Dir":
-				return `((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; if (i === 0) return "/"; return p.slice(0, i); })(${args[0]})`;
-			case "Ext":
-				return `((p) => { const b = p.slice(p.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); })(${args[0]})`;
-			case "Join": {
-				this._usesPathClean = true;
-				const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
-				return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
+	_genPrimitiveConversion(expr, inner, target) {
+		switch (target) {
+			case "string": {
+				const srcType = expr.expr._type;
+				if (srcType && this.isIntType(srcType))
+					return `String.fromCodePoint(${inner})`;
+				if (srcType?.kind === "slice" && srcType.elem?.name === "int")
+					return `${inner}.map(c => String.fromCharCode(c)).join("")`;
+				return `String(${inner})`;
 			}
-			case "Clean":
-				this._usesPathClean = true;
-				return `__pathClean(${args[0]})`;
-			case "IsAbs":
-				return `(${args[0]}).startsWith("/")`;
-			case "Split":
-				return `((p) => { const i = p.lastIndexOf("/"); return i < 0 ? ["", p] : [p.slice(0, i + 1), p.slice(i + 1)]; })(${args[0]})`;
-			case "Match":
-				return `((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${args[0]}, ${args[1]})`;
+			case "int":
+			case "byte":
+			case "rune":
+				return `Math.trunc(Number(${inner}))`;
+			case "float64":
+				return `Number(${inner})`;
+			case "bool":
+				return `Boolean(${inner})`;
 			default:
-				return undefined;
+				return inner;
 		}
 	},
 };