gofront 0.0.5 → 0.0.7

package/src/codegen/expressions.js

@@ -147,6 +147,15 @@ export const expressionGenMethods = {
 							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) {
@@ -184,7 +193,11 @@ export const expressionGenMethods = {
 			}
 
 			case "IndexExpr": {
-				const base = this.genExpr(expr.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) {
 					const zero = this.zeroValueForType(expr._mapValueType);
@@ -196,7 +209,6 @@ export const expressionGenMethods = {
 					return `(${base}[${idx}] ?? ${zero})`;
 				}
 				// String indexing returns a byte (charCodeAt), not a JS character
-				const exprType = expr.expr._type;
 				const isStr =
 					(exprType?.kind === "basic" && exprType.name === "string") ||
 					(exprType?.kind === "untyped" && exprType.base === "string");
@@ -212,6 +224,7 @@ export const expressionGenMethods = {
 				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})`;
 			}
 
@@ -284,6 +297,10 @@ export const expressionGenMethods = {
 					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"
@@ -339,6 +356,16 @@ export const expressionGenMethods = {
 	},
 
 	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
+		}
+
 		// Unwrap InstantiationExpr for function calls: Foo[int](42) → Foo(42)
 		const funcExpr =
 			expr.func.kind === "InstantiationExpr" ? expr.func.expr : expr.func;
@@ -351,6 +378,10 @@ export const expressionGenMethods = {
 					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;
@@ -443,6 +474,19 @@ export const expressionGenMethods = {
 			if (result !== undefined) return result;
 		}
 
+		// 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);
+			}
+		}
+
 		// 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);
@@ -459,6 +503,18 @@ export const expressionGenMethods = {
 	},
 
 	genAppend(expr) {
+		const retType = expr._type;
+		const wrapField = this._namedWrapperField(retType, expr.args[0]);
+		if (wrapField) {
+			// Named slice wrapper: append(g, x) → new G(__append(g._items, x))
+			const sliceJS = `${this.genExpr(expr.args[0])}.${wrapField}`;
+			const elems = expr.args
+				.slice(1)
+				.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)));
+			if (elems.length === 0) return this.genExpr(expr.args[0]);
+			this._usesAppend = true;
+			return `new ${retType.name}(__append(${sliceJS}, ${elems.join(", ")}))`;
+		}
 		const slice = this.genExpr(expr.args[0]);
 		const elems = expr.args
 			.slice(1)
@@ -543,6 +599,34 @@ export const expressionGenMethods = {
 			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
 		}
 
+		// 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),
+				)
+				.join(", ");
+			return `new ${typeName}([${elems}])`;
+		}
+
 		// Fallback: named type that's not a struct but has positional elements → treat as struct
 		if (expr.elems.some((e) => e._positionalField)) {
 			if (typeName) {
@@ -604,7 +688,8 @@ export const expressionGenMethods = {
 		if (typeNode.kind === "Ident") return typeNode.name;
 		if (typeNode.kind === "InstantiationExpr")
 			return this.getTypeName(typeNode.expr);
-		if (typeNode.kind === "SelectorExpr") return typeNode.field;
+		if (typeNode.kind === "SelectorExpr")
+			return `${this.getTypeName(typeNode.expr)}.${typeNode.field}`;
 		return null;
 	},
 
@@ -662,6 +747,8 @@ 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";
@@ -706,6 +793,8 @@ 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";
 			default:
@@ -776,6 +865,294 @@ 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})`;
+			}
+		}
+		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": {
+				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]; })`;
+			}
+		}
+		return undefined;
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -815,11 +1192,170 @@ export const expressionGenMethods = {
 				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 "gom":
+				return this._genGom(fn, expr);
 			default:
 				return undefined;
 		}
 	},
 
+	_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(",")})`
+			);
+		}
+		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;
+	},
+
 	_genFmt(fn, _a, expr) {
 		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
 		switch (fn) {
@@ -843,6 +1379,52 @@ export const expressionGenMethods = {
 			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}))`;
+			}
 			default:
 				return undefined;
 		}
@@ -862,7 +1444,7 @@ export const expressionGenMethods = {
 			case "LastIndex":
 				return `${args[0]}.lastIndexOf(${args[1]})`;
 			case "Count":
-				return `${args[0]}.split(${args[1]}).length - 1`;
+				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":
@@ -878,9 +1460,9 @@ export const expressionGenMethods = {
 			case "Trim":
 				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), "")`;
 			case "TrimPrefix":
-				return `(${args[0]}.startsWith(${args[1]}) ? ${args[0]}.slice(${args[1]}.length) : ${args[0]})`;
+				return `((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${args[0]}, ${args[1]})`;
 			case "TrimSuffix":
-				return `(${args[0]}.endsWith(${args[1]}) ? ${args[0]}.slice(0, -${args[1]}.length) : ${args[0]})`;
+				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":
@@ -910,7 +1492,7 @@ export const expressionGenMethods = {
 			case "Index":
 				return `${__bs}(${args[0]}).indexOf(${__bs}(${args[1]}))`;
 			case "Count":
-				return `${__bs}(${args[0]}).split(${__bs}(${args[1]})).length - 1`;
+				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":