gofront 0.0.8 → 1.0.0

package/src/codegen/stdlib/builder.js

@@ -0,0 +1,36 @@
+// CodeGen for `strings.Builder` and `bytes.Buffer` method calls.
+
+const BUILDER_STR = {
+	WriteString: (b, a) => `(${b}._buf += ${a[0]}, [${a[0]}.length, null])`,
+	WriteByte: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
+	Write: (b, a) => `(${b}._buf += String.fromCharCode(...${a[0]}))`,
+	String: (b) => `${b}._buf`,
+	Reset: (b) => `(${b}._buf = "")`,
+};
+const BUILDER_BYTES = {
+	WriteString: (b, a) =>
+		`(${b}._buf.push(...new TextEncoder().encode(${a[0]})), [${a[0]}.length, null])`,
+	WriteByte: (b, a) => `${b}._buf.push(${a[0]})`,
+	Write: (b, a) => `(${b}._buf.push(...${a[0]}), [${a[0]}.length, null])`,
+	String: (b) => `new TextDecoder().decode(new Uint8Array(${b}._buf))`,
+	Reset: (b) => `(${b}._buf = [])`,
+};
+const BUILDER_COMMON = {
+	WriteRune: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
+	Bytes: (b) => `${b}._buf.slice()`,
+	Len: (b) => `${b}._buf.length`,
+	Grow: () => "undefined",
+};
+
+export const builderMethods = {
+	_genBuilderCall(typeName, method, expr) {
+		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));
+		const isStr = typeName === "strings.Builder";
+		const table = isStr ? BUILDER_STR : BUILDER_BYTES;
+		const gen = table[method] ?? BUILDER_COMMON[method];
+		return gen ? gen(base, args) : undefined;
+	},
+};

package/src/codegen/stdlib/bytes.js

@@ -0,0 +1,62 @@
+// CodeGen for Go `bytes` package.
+
+const __bs = `(b => String.fromCharCode(...b))`;
+const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
+
+const BYTES_DISPATCH = {
+	Contains: (a) => `${__bs}(${a[0]}).includes(${__bs}(${a[1]}))`,
+	HasPrefix: (a) =>
+		`((b, p) => { for (let i = 0; i < p.length; i++) if (b[i] !== p[i]) return false; return b.length >= p.length; })(${a[0]}, ${a[1]})`,
+	HasSuffix: (a) =>
+		`((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; })(${a[0]}, ${a[1]})`,
+	Index: (a) => `${__bs}(${a[0]}).indexOf(${__bs}(${a[1]}))`,
+	Count: (a) =>
+		`((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${a[0]}, ${a[1]})`,
+	Repeat: (a) => `${__sb}(${__bs}(${a[0]}).repeat(${a[1]}))`,
+	Replace: (a) =>
+		`((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); })(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`,
+	ToUpper: (a) => `${__sb}(${__bs}(${a[0]}).toUpperCase())`,
+	ToLower: (a) => `${__sb}(${__bs}(${a[0]}).toLowerCase())`,
+	TrimSpace: (a) => `${__sb}(${__bs}(${a[0]}).trim())`,
+	Trim: (a) =>
+		`${__sb}(${__bs}(${a[0]}).replace(new RegExp(\`^[\${${a[1]}}]+|[\${${a[1]}}]+$\`, "g"), ""))`,
+	Equal: (a) =>
+		`((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; })(${a[0]}, ${a[1]})`,
+	Split: (a) => `${__bs}(${a[0]}).split(${__bs}(${a[1]})).map(p => ${__sb}(p))`,
+	Join: (a) => `${__sb}(${a[0]}.map(p => ${__bs}(p)).join(${__bs}(${a[1]})))`,
+	ReplaceAll: (a) =>
+		`((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)); })(${a[0]}, ${a[1]}, ${a[2]})`,
+	TrimPrefix: (a) =>
+		`((b, p) => p.every((v, i) => b[i] === v) ? b.slice(p.length) : b.slice())(${a[0]}, ${a[1]})`,
+	TrimSuffix: (a) =>
+		`((b, s) => s.length && s.every((v, i) => b[b.length - s.length + i] === v) ? b.slice(0, -s.length) : b.slice())(${a[0]}, ${a[1]})`,
+	TrimLeft: (a) =>
+		`((b, c) => { let i = 0; while (i < b.length && c.includes(String.fromCharCode(b[i]))) i++; return b.slice(i); })(${a[0]}, ${a[1]})`,
+	TrimRight: (a) =>
+		`((b, c) => { let i = b.length; while (i > 0 && c.includes(String.fromCharCode(b[i - 1]))) i--; return b.slice(0, i); })(${a[0]}, ${a[1]})`,
+	TrimFunc: (a) =>
+		`((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); })(${a[0]}, ${a[1]})`,
+	IndexByte: (a) => `(${a[0]}).indexOf(${a[1]})`,
+	LastIndex: (a) =>
+		`((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; })(${a[0]}, ${a[1]})`,
+	LastIndexByte: (a) => `(${a[0]}).lastIndexOf(${a[1]})`,
+	Fields: (a) =>
+		`((b) => { const s = String.fromCharCode(...b).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => [...w].map(c => c.charCodeAt(0))); })(${a[0]})`,
+	Cut: (a) =>
+		`((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]; })(${a[0]}, ${a[1]})`,
+	ContainsAny: (a) =>
+		`[...(${a[1]})].some(c => (${a[0]}).includes(c.charCodeAt(0)))`,
+	ContainsRune: (a) => `(${a[0]}).includes(${a[1]})`,
+	Map: (a) => `(${a[1]}).map(v => (${a[0]})(v))`,
+	SplitN: (a) =>
+		`((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; })(${a[0]}, ${a[1]}, ${a[2]})`,
+	NewReader: (a) =>
+		`{_src: ${a[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; }}`,
+};
+
+export const bytesMethods = {
+	_genBytes(fn, a) {
+		const gen = BYTES_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/errors.js

@@ -0,0 +1,17 @@
+// CodeGen for Go `errors` package.
+
+export const errorsMethods = {
+	_genErrors(fn, a) {
+		const args = a();
+		if (fn === "New") {
+			this._usesError = true;
+			return `__error(${args[0]})`;
+		}
+		if (fn === "Is") {
+			this._usesErrorIs = true;
+			return `__errorIs(${args[0]}, ${args[1]})`;
+		}
+		if (fn === "Unwrap") return `(${args[0]}?._cause ?? null)`;
+		return undefined;
+	},
+};

package/src/codegen/stdlib/fmt.js

@@ -0,0 +1,101 @@
+// CodeGen for Go `fmt` package — installed onto CodeGen.prototype via stdlibGenMethods.
+
+const _SSCAN_LOOP =
+	`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++; }`;
+
+export const fmtMethods = {
+	_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":
+				return this._genFmtFprint(fn, expr);
+			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); ${_SSCAN_LOOP} 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 tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} 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); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "input does not match format" : null]; })(${strArg}, ${fmtArg}, ${restArgs})`;
+			}
+			default:
+				return undefined;
+		}
+	},
+
+	_genFmtFprint(fn, expr) {
+		this._usesSprintf = true;
+		const writerArg = expr.args[0];
+		const rest = expr.args.slice(1);
+		const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+		const writerType = writerArg._type;
+		const targetTypeName =
+			writerType?.name ??
+			(writerType?.kind === "pointer" ? writerType.base?.name : null);
+		const sprintfCall = this._buildFprintSprintfCall(fn, rest.length, restJs);
+		if (targetTypeName === "strings.Builder") {
+			const w = this.genExpr(writerArg);
+			const buf =
+				writerType?.kind === "pointer" ? `${w}.value._buf` : `${w}._buf`;
+			return `(${buf} += ${sprintfCall})`;
+		}
+		if (targetTypeName === "bytes.Buffer") {
+			const w = this.genExpr(writerArg);
+			const base = writerType?.kind === "pointer" ? `${w}.value` : w;
+			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
+		}
+		// Generic io.Writer fallback — call .WriteString if available
+		const w = this.genExpr(writerArg);
+		return `${w}.WriteString(${sprintfCall})`;
+	},
+
+	_buildFprintSprintfCall(fn, argc, restJs) {
+		if (fn === "Fprintf") return `__sprintf(${restJs})`;
+		const sep = fn === "Fprintln" ? " " : "";
+		const suffix = fn === "Fprintln" ? "\\n" : "";
+		const fmt = Array(argc).fill("%v").join(sep) + suffix;
+		return `__sprintf("${fmt}", ${restJs})`;
+	},
+};

package/src/codegen/stdlib/gom.js

@@ -0,0 +1,152 @@
+// CodeGen for the GoFront-built-in `gom` DOM-rendering package.
+
+const GOM_ELEMENT_TAGS = {
+	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",
+};
+const GOM_ATTR_HELPERS = {
+	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",
+	AriaLabel: "aria-label",
+};
+const GOM_BOOL_ATTRS = {
+	Disabled: "disabled",
+	Checked: "checked",
+	Selected: "selected",
+	Readonly: "readonly",
+};
+const GOM_PROP_SETTERS = {
+	Class: "className",
+	Type: "type",
+	Href: "href",
+	Src: "src",
+	Placeholder: "placeholder",
+};
+
+export const gomMethods = {
+	_genGom(fn, expr) {
+		const a = () =>
+			expr.args.map((e) =>
+				e._spread ? `...${this.genExpr(e)}` : this.genExpr(e),
+			);
+
+		if (GOM_ELEMENT_TAGS[fn]) {
+			const tag = GOM_ELEMENT_TAGS[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(",")})`
+			);
+		}
+
+		if (GOM_ATTR_HELPERS[fn]) {
+			const [v] = a();
+			return `((v)=>({Mount(e){e.setAttribute("${GOM_ATTR_HELPERS[fn]}",v)}}))(${v})`;
+		}
+
+		if (GOM_BOOL_ATTRS[fn])
+			return `({Mount(e){e.setAttribute("${GOM_BOOL_ATTRS[fn]}","")}})`;
+
+		const args = a();
+
+		if (GOM_PROP_SETTERS[fn])
+			return `((v)=>({Mount(e){e.${GOM_PROP_SETTERS[fn]}=v}}))(${args[0]})`;
+
+		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 "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;
+	},
+};

package/src/codegen/stdlib/html.js

@@ -0,0 +1,17 @@
+// CodeGen for Go `html` package.
+
+export const htmlMethods = {
+	_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;
+	},
+};

package/src/codegen/stdlib/index.js

@@ -0,0 +1,95 @@
+// CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
+// One file per Go package under ./stdlib/. This index merges them.
+
+import { builderMethods } from "./builder.js";
+import { bytesMethods } from "./bytes.js";
+import { errorsMethods } from "./errors.js";
+import { fmtMethods } from "./fmt.js";
+import { gomMethods } from "./gom.js";
+import { htmlMethods } from "./html.js";
+import { ioMethods } from "./io.js";
+import { mapsMethods } from "./maps.js";
+import { mathMethods } from "./math.js";
+import { osMethods } from "./os.js";
+import { pathMethods } from "./path.js";
+import { randMethods } from "./rand.js";
+import { regexpMethods } from "./regexp.js";
+import { slicesMethods } from "./slices.js";
+import { sortMethods } from "./sort.js";
+import { strconvMethods } from "./strconv.js";
+import { stringsMethods } from "./strings.js";
+import { timeMethods } from "./time.js";
+import { unicodeMethods } from "./unicode.js";
+import { utf8Methods } from "./utf8.js";
+
+// Stdlib namespace → handler method name. Used by _genStdlibCall to dispatch
+// dynamically without creating static call edges.
+const STDLIB_METHOD_MAP = {
+	fmt: "_genFmt",
+	strings: "_genStrings",
+	bytes: "_genBytes",
+	strconv: "_genStrconv",
+	sort: "_genSort",
+	math: "_genMath",
+	unicode: "_genUnicode",
+	os: "_genOs",
+	errors: "_genErrors",
+	time: "_genTime",
+	regexp: "_genRegexp",
+	slices: "_genSlices",
+	maps: "_genMaps",
+	html: "_genHtml",
+	io: "_genIo",
+	rand: "_genRand",
+	utf8: "_genUtf8",
+	path: "_genPath",
+};
+
+const dispatchMethods = {
+	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;
+		}
+	},
+
+	// 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));
+		if (ns === "gom") return this._genGom(fn, expr);
+		const method = STDLIB_METHOD_MAP[ns];
+		return method ? this[method](fn, a, expr) : undefined;
+	},
+};
+
+export const stdlibGenMethods = {
+	...builderMethods,
+	...bytesMethods,
+	...errorsMethods,
+	...fmtMethods,
+	...gomMethods,
+	...htmlMethods,
+	...ioMethods,
+	...mapsMethods,
+	...mathMethods,
+	...osMethods,
+	...pathMethods,
+	...randMethods,
+	...regexpMethods,
+	...slicesMethods,
+	...sortMethods,
+	...strconvMethods,
+	...stringsMethods,
+	...timeMethods,
+	...unicodeMethods,
+	...utf8Methods,
+	...dispatchMethods,
+};

package/src/codegen/stdlib/io.js

@@ -0,0 +1,33 @@
+// CodeGen for Go `io` package.
+
+export const ioMethods = {
+	_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;
+	},
+};

package/src/codegen/stdlib/maps.js

@@ -0,0 +1,42 @@
+// CodeGen for Go `maps` package.
+
+export const mapsMethods = {
+	_genMaps(fn, a) {
+		if (fn === "Equal") {
+			this._usesEqual = true;
+			const [a1, b1] = a();
+			return `__equal(${a1}, ${b1})`;
+		}
+		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 "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;
+	},
+};

package/src/codegen/stdlib/math.js

@@ -0,0 +1,53 @@
+// CodeGen for Go `math` package.
+
+const MATH1 = {
+	Abs: "abs",
+	Floor: "floor",
+	Ceil: "ceil",
+	Round: "round",
+	Sqrt: "sqrt",
+	Cbrt: "cbrt",
+	Log: "log",
+	Log2: "log2",
+	Log10: "log10",
+	Sin: "sin",
+	Cos: "cos",
+	Tan: "tan",
+	Atan: "atan",
+	Asin: "asin",
+	Acos: "acos",
+	Exp: "exp",
+	Trunc: "trunc",
+};
+const MATH2 = {
+	Pow: "pow",
+	Min: "min",
+	Max: "max",
+	Atan2: "atan2",
+	Hypot: "hypot",
+};
+const MATH_EXTRA = {
+	Mod: ([x, y]) => `${x} % ${y}`,
+	Inf: ([x]) => `(${x} >= 0 ? Infinity : -Infinity)`,
+	IsNaN: ([x]) => `Number.isNaN(${x})`,
+	IsInf: ([x, y]) =>
+		`(${y} > 0 ? ${x} === Infinity : ${y} < 0 ? ${x} === -Infinity : !Number.isFinite(${x}))`,
+	NaN: () => "NaN",
+	Exp2: ([x]) => `Math.pow(2, ${x})`,
+	Signbit: ([x]) => `(${x} < 0 || Object.is(${x}, -0))`,
+	Copysign: ([x, y]) =>
+		`(Math.abs(${x}) * (${y} < 0 || Object.is(${y}, -0) ? -1 : 1))`,
+	Dim: ([x, y]) => `Math.max(${x} - ${y}, 0)`,
+	Remainder: ([x, y]) => `(${x} - Math.round(${x} / ${y}) * ${y})`,
+};
+
+export const mathMethods = {
+	_genMath(fn, a) {
+		const args = a();
+		const [x, y] = args;
+		if (MATH1[fn]) return `Math.${MATH1[fn]}(${x})`;
+		if (MATH2[fn]) return `Math.${MATH2[fn]}(${x}, ${y})`;
+		const gen = MATH_EXTRA[fn];
+		return gen ? gen(args) : undefined;
+	},
+};

package/src/codegen/stdlib/os.js

@@ -0,0 +1,10 @@
+// CodeGen for Go `os` package.
+
+export const osMethods = {
+	_genOs(fn, a) {
+		const args = a();
+		if (fn === "Exit") return `process.exit(${args[0]})`;
+		if (fn === "Getenv") return `(process.env[${args[0]}] ?? "")`;
+		return undefined;
+	},
+};

package/src/codegen/stdlib/path.js

@@ -0,0 +1,31 @@
+// CodeGen for Go `path` package.
+
+const PATH_DISPATCH = {
+	Base: (a) =>
+		`((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${a[0]})`,
+	Dir: (a) =>
+		`((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; if (i === 0) return "/"; return p.slice(0, i); })(${a[0]})`,
+	Ext: (a) =>
+		`((p) => { const b = p.slice(p.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); })(${a[0]})`,
+	IsAbs: (a) => `(${a[0]}).startsWith("/")`,
+	Split: (a) =>
+		`((p) => { const i = p.lastIndexOf("/"); return i < 0 ? ["", p] : [p.slice(0, i + 1), p.slice(i + 1)]; })(${a[0]})`,
+	Match: (a) =>
+		`((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"]; } })(${a[0]}, ${a[1]})`,
+};
+
+export const pathMethods = {
+	_genPath(fn, a, expr) {
+		if (fn === "Join") {
+			this._usesPathClean = true;
+			const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+			return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
+		}
+		if (fn === "Clean") {
+			this._usesPathClean = true;
+			return `__pathClean(${a()[0]})`;
+		}
+		const gen = PATH_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};