gofront 1.5.1 → 1.6.1

package/src/backend/js/stdlib/bytes.js

@@ -2,8 +2,8 @@
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
-const __bs = `(b => String.fromCharCode(...b))`;
-const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
+const __bs = `(b => typeof TextDecoder !== "undefined" ? new TextDecoder().decode(b instanceof Uint8Array ? b : new Uint8Array(b)) : String.fromCharCode.apply(null, b))`;
+const __sb = `(s => typeof TextEncoder !== "undefined" ? new TextEncoder().encode(s) : new Uint8Array([...s].map(c => c.charCodeAt(0))))`;
 
 const BYTES_DISPATCH = {
 	Contains: (a) => `${__bs}(${a[0]}).includes(${__bs}(${a[1]}))`,
@@ -16,49 +16,106 @@ const BYTES_DISPATCH = {
 		`((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())`,
+		`((b, o, n, cnt) => { let str = ${__bs}(b), os = ${__bs}(o), nw = ${__bs}(n); if (cnt < 0) return ${__sb}(str.replaceAll(os, () => nw)); let r = ""; let i = 0; for (; cnt > 0; cnt--) { const j = str.indexOf(os, i); if (j < 0) break; r += str.slice(i, j) + nw; i = j + os.length; if (os.length === 0) { if (i >= str.length) break; r += str[i]; i++; } } return ${__sb}(r + str.slice(i)); })(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]})`,
+	ToUpper: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toUpperCase())`,
+	ToLower: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toLowerCase())`,
+	ToTitle: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).toUpperCase())`,
+	TrimSpace: (a) =>
+		`new TextEncoder().encode(new TextDecoder().decode(new Uint8Array(${a[0]})).trim())`,
 	Trim: (a) =>
-		`${__sb}(${__bs}(${a[0]}).replace(new RegExp(\`^[\${${a[1]}}]+|[\${${a[1]}}]+$\`, "g"), ""))`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && cs.has(chars[l])) l++; while (r > l && cs.has(chars[r - 1])) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${a[0]}, ${a[1]})`,
 	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.length > 0 && o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else { r.push(b[i++]); } } for (; i < b.length; i++) r.push(b[i]); return ArrayBuffer.isView(b) ? new Uint8Array(r) : r; })(${a[0]}, ${a[1]}, ${a[2]})`,
+		`((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.length > 0 && o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else { r.push(b[i++]); } } for (; i < b.length; i++) r.push(b[i]); return new Uint8Array(r); })(${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]})`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && cs.has(chars[l])) l++; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${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]})`,
+		`((b, c) => { const s = new TextDecoder().decode(new Uint8Array(b)); const cs = new Set(Array.from(c)); const chars = Array.from(s); let l = 0, r = chars.length; while (r > l && cs.has(chars[r - 1])) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${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]})`,
+		`((b, f) => { const s = new TextDecoder().decode(new Uint8Array(b)); const chars = Array.from(s); let l = 0, r = chars.length; while (l < r && f(chars[l].codePointAt(0))) l++; while (r > l && f(chars[r - 1].codePointAt(0))) r--; return new TextEncoder().encode(chars.slice(l, r).join("")); })(${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]})`,
+		`((b) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => new TextEncoder().encode(w)); })(${a[0]})`,
+	FieldsFunc: (a) =>
+		`((b, fn) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])); const res = []; let cur = ""; for (const ch of s) { const cp = ch.codePointAt(0); if (fn(cp)) { if (cur.length > 0) { res.push(new TextEncoder().encode(cur)); cur = ""; } } else { cur += ch; } } if (cur.length > 0) res.push(new TextEncoder().encode(cur)); return res; })(${a[0]}, ${a[1]})`,
+	Clone: (a) =>
+		`(${a[0]} ? (${a[0]}.slice ? ${a[0]}.slice() : Array.from(${a[0]})) : null)`,
 	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]})`,
+		`((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(), new Uint8Array(0), 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))`,
+		`((b, chars) => { const s = new TextDecoder().decode(new Uint8Array(b)); for (const c of chars) if (s.includes(c)) return true; return false; })(${a[0]}, ${a[1]})`,
+	ContainsRune: (a) =>
+		`((b, r) => { const s = new TextDecoder().decode(new Uint8Array(b)); return s.includes(String.fromCodePoint(r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff) ? 0xfffd : r)); })(${a[0]}, ${a[1]})`,
+	Map: (a) =>
+		`((f, b) => { const s = new TextDecoder().decode(new Uint8Array(b)); let res = ""; for (const c of s) { const r = f(c.codePointAt(0)); if (r >= 0) res += String.fromCodePoint(r); } return new TextEncoder().encode(res); })(${a[0]}, ${a[1]})`,
 	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]})`,
+		`((b, sep, n) => {
+			if (n === 0) return null;
+			if (sep.length === 0) {
+				if (n < 0 || b.length <= n) {
+					const r = [];
+					for (let k = 0; k < b.length; k++) r.push(b.slice(k, k + 1));
+					return r;
+				}
+				const r = [];
+				for (let k = 0; k < n - 1; k++) r.push(b.slice(k, k + 1));
+				r.push(b.slice(n - 1));
+				return r;
+			}
+			const findNext = (start) => {
+				for (let k = start; k <= b.length - sep.length; k++) {
+					let match = true;
+					for (let l = 0; l < sep.length; l++) {
+						if (b[k + l] !== sep[l]) { match = false; break; }
+					}
+					if (match) return k;
+				}
+				return -1;
+			};
+			if (n < 0) {
+				const r = [];
+				let i = 0;
+				while (i <= b.length) {
+					const j = findNext(i);
+					if (j < 0) break;
+					r.push(b.slice(i, j));
+					i = j + sep.length;
+				}
+				r.push(b.slice(i));
+				return r;
+			}
+			const r = [];
+			let i = 0;
+			for (let c = 1; c < n; c++) {
+				const j = findNext(i);
+				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; }}`,
+		`((b) => ({ _src: b, _pos: 0, Read(p) { if (this._pos >= this._src.length) return [0, __io_eof]; 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, null]; }, Len() { return Math.max(0, this._src.length - this._pos); }, Reset(b2) { this._src = b2; this._pos = 0; } }))(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const bytesMethods = {
 	_genBytes(fn, a) {
+		if (fn === "NewReader") this.useHelper("ioEOF");
 		const gen = BYTES_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/backend/js/stdlib/errors.js

@@ -4,17 +4,36 @@
 
 /** @type {ThisType<CodeGen>} */
 export const errorsMethods = {
-	_genErrors(fn, a) {
+	_genErrors(fn, a, expr) {
 		const args = a();
 		if (fn === "New") {
-			this._usesError = true;
+			this.useHelper("error");
 			return `__error(${args[0]})`;
 		}
 		if (fn === "Is") {
-			this._usesErrorIs = true;
+			this.useHelper("errorIs");
 			return `__errorIs(${args[0]}, ${args[1]})`;
 		}
 		if (fn === "Unwrap") return `(${args[0]}?._cause ?? null)`;
+		if (fn === "As") {
+			this.useHelper("errorAs");
+			const targetGoType = expr?.args?.[1]?._type;
+			const baseGoType = targetGoType?.base ?? targetGoType;
+			const concreteGoType = baseGoType?.base ?? baseGoType;
+			const typeName = concreteGoType?.name;
+			if (concreteGoType?.kind === "interface" || typeName === "error") {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => x !== null && (typeof x === "object" ? typeof x.Error === "function" : true))`;
+			}
+			if (typeName) {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => (typeof ${typeName} === "function" && x instanceof ${typeName}) || x?.constructor?.name === "${typeName}" || x?.__struct === "${typeName}")`;
+			}
+			return `__errorAs(${args[0]}, ${args[1]})`;
+		}
+		if (fn === "Join") {
+			this.useHelper("error");
+			this.useHelper("errorJoin");
+			return `__errorJoin(${args.join(", ")})`;
+		}
 		return undefined;
 	},
 };

package/src/backend/js/stdlib/fmt.js

@@ -3,23 +3,37 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 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"; ` +
+	`let n = 0, err = null; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
+	`const item = tokens[i]; const t = typeof item === "object" && item !== null ? item.t : item; const verb = item?.verb; const p = ptrs[i]; ` +
+	`if (verb === "%c") { p.value = t.codePointAt ? t.codePointAt(0) : t; } ` +
+	`else if (verb === "%x" || verb === "%X") { const clean = t.replace(/^0[xX]/, ""); const v = parseInt(clean, 16); if (isNaN(v)) { err = __error("expected hex number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0x" + clean) : v; } ` +
+	`else if (verb === "%o") { const clean = t.replace(/^0[oO]?/, ""); const v = parseInt(clean, 8); if (isNaN(v)) { err = __error("expected octal number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0o" + clean) : v; } ` +
+	`else if (verb === "%b") { const clean = t.replace(/^0[bB]/, ""); const v = parseInt(clean, 2); if (isNaN(v)) { err = __error("expected binary number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0b" + clean) : v; } ` +
+	`else if (typeof p.value === "number") { const v = Number(t); if (Number.isNaN(v) || !/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$/.test(t)) { err = __error("expected number"); break; } p.value = v; } ` +
+	`else if (typeof p.value === "bigint") { try { if (!/^[+-]?\\d+$/.test(t)) throw 1; p.value = BigInt(t); } catch { err = __error("expected integer"); break; } } ` +
+	`else if (typeof p.value === "boolean") { const tl = String(t).toLowerCase(); if (tl === "true" || tl === "1" || tl === "t") p.value = true; else if (tl === "false" || tl === "0" || tl === "f") p.value = false; else { err = __error("expected boolean"); break; } } ` +
 	`else p.value = t; n++; }`;
 
 /** @type {ThisType<CodeGen>} */
 export const fmtMethods = {
+	_fmtArgJs(e) {
+		const js = this.genExpr(e);
+		const base =
+			e?._type?.kind === "named" ? (e._type.underlying ?? e._type) : e?._type;
+		return base?.kind === "slice" ? `(${js} ?? [])` : js;
+	},
+
 	_genFmt(fn, _a, expr) {
-		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+		const fmtArgs = expr.args
+			.map((e, idx) => (idx === 0 ? this.genExpr(e) : this._fmtArgJs(e)))
+			.join(", ");
 		switch (fn) {
 			case "Sprintf":
-				this._usesSprintf = true;
+				this.useHelper("sprintf");
 				return `__sprintf(${fmtArgs})`;
 			case "Errorf": {
-				this._usesSprintf = true;
-				this._usesError = true;
+				this.useHelper("sprintf");
+				this.useHelper("error");
 				const fmtStr = expr.args[0];
 				if (fmtStr?.kind === "BasicLit" && fmtStr.value?.includes("%w")) {
 					const lastArg = this.genExpr(expr.args[expr.args.length - 1]);
@@ -28,40 +42,86 @@ export const fmtMethods = {
 				return `__error(__sprintf(${fmtArgs}))`;
 			}
 			case "Printf":
+				this.useHelper("sprintf");
+				return this._genStdoutWrite(`__sprintf(${fmtArgs})`);
 			case "Print":
-				this._usesSprintf = true;
-				return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
+				this.useHelper("sprintf");
+				return this._genStdoutWrite(this._genPrintOperands(expr, "", ""));
 			case "Println":
-				this._usesSprintf = true;
-				return `console.log(__sprintf(${fmtArgs}))`;
+				this.useHelper("sprintf");
+				// console.log supplies the trailing newline.
+				return `console.log(${this._genPrintOperands(expr, " ", "")})`;
 			case "Fprintf":
 			case "Fprintln":
 			case "Fprint":
 				return this._genFmtFprint(fn, expr);
 			case "Sscan": {
+				this.useHelper("error");
 				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})`;
+				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanln": {
+				this.useHelper("error");
 				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})`;
+				return `((str, ...ptrs) => { const tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanf": {
+				this.useHelper("error");
 				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})`;
+				return (
+					`((str, fmt, ...ptrs) => { ` +
+					`const s = String(str); const f = String(fmt); ` +
+					`let si = 0, fi = 0; const tokens = []; let parseErr = null; ` +
+					`while (fi < f.length) { ` +
+					`if (/\\s/.test(f[fi])) { ` +
+					`while (fi < f.length && /\\s/.test(f[fi])) fi++; ` +
+					`while (si < s.length && /\\s/.test(s[si])) si++; ` +
+					`continue; ` +
+					`} ` +
+					`if (f[fi] === "%") { ` +
+					`if (fi + 1 < f.length && f[fi + 1] === "%") { ` +
+					`if (s[si] !== "%") { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi += 2; continue; ` +
+					`} ` +
+					`const vm = f.slice(fi).match(/^%[vdsfqtxXbcoeEfFgG]/); ` +
+					`if (vm) { ` +
+					`const verb = vm[0]; fi += verb.length; ` +
+					`if (verb !== "%c") { while (si < s.length && /\\s/.test(s[si])) si++; } ` +
+					`if (si >= s.length) break; ` +
+					`let tokRe = /^\\S+/; ` +
+					`if (verb === "%d" || verb === "%i") tokRe = /^[+-]?\\d+/; ` +
+					`else if (verb === "%o") tokRe = /^[+-]?(?:0[oO])?[0-7]+/; ` +
+					`else if (verb === "%b") tokRe = /^[+-]?(?:0[bB])?[01]+/; ` +
+					`else if (verb === "%f" || verb === "%F" || verb === "%e" || verb === "%E" || verb === "%g" || verb === "%G") tokRe = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?/; ` +
+					`else if (verb === "%t") tokRe = /^(?:true|false|1|0|t|f|T|F|TRUE|FALSE)/; ` +
+					`else if (verb === "%x" || verb === "%X") tokRe = /^[+-]?(?:0x)?[0-9a-fA-F]+/; ` +
+					`else if (verb === "%c") tokRe = /^[\\s\\S]/; ` +
+					`const m = s.slice(si).match(tokRe); ` +
+					`if (!m) { parseErr = __error("input does not match format"); break; } ` +
+					`tokens.push({ t: m[0], verb }); si += m[0].length; continue; ` +
+					`} ` +
+					`} ` +
+					`if (si >= s.length) break; ` +
+					`if (s[si] !== f[fi]) { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi++; ` +
+					`} ` +
+					`${_SSCAN_LOOP} ` +
+					`return [n, parseErr || err || (n < ptrs.length ? __error("unexpected EOF") : null)]; ` +
+					`})(${strArg}, ${fmtArg}, ${restArgs})`
+				);
 			}
 			default:
 				return undefined;
@@ -69,10 +129,10 @@ export const fmtMethods = {
 	},
 
 	_genFmtFprint(fn, expr) {
-		this._usesSprintf = true;
+		this.useHelper("sprintf");
 		const writerArg = expr.args[0];
 		const rest = expr.args.slice(1);
-		const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+		const restJs = rest.map((e) => this._fmtArgJs(e)).join(", ");
 		const writerType = writerArg._type;
 		const targetTypeName =
 			writerType?.name ??
@@ -81,20 +141,35 @@ export const fmtMethods = {
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `(${base}._buf += ${sprintfCall})`;
+			return `((__b, __s) => { __b._buf += __s; return [__s.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
+			return `((__b, __s) => { const __bytes = new TextEncoder().encode(__s); for (let i = 0; i < __bytes.length; i++) __b._buf.push(__bytes[i]); return [__bytes.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available
 		const w = this.genExpr(writerArg);
-		return `${w}.WriteString(${sprintfCall})`;
+		return `((__w, __s) => typeof __w.WriteString === "function" ? __w.WriteString(__s) : __w.Write(new TextEncoder().encode(__s)))(${w}, ${sprintfCall})`;
+	},
+
+	_genStdoutWrite(strJs) {
+		return `((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))(${strJs})`;
+	},
+
+	// Formats Print/Println operands with %v so the first operand is never
+	// mistaken for a format string.
+	_genPrintOperands(expr, sep, suffix) {
+		const argc = expr.args.length;
+		if (argc === 0) return JSON.stringify(suffix);
+		const fmt = Array(argc).fill("%v").join(sep) + suffix;
+		const args = expr.args.map((e) => this._fmtArgJs(e)).join(", ");
+		return `__sprintf(${JSON.stringify(fmt)}, ${args})`;
 	},
 
 	_buildFprintSprintfCall(fn, argc, restJs) {
 		if (fn === "Fprintf") return `__sprintf(${restJs})`;
+		if (argc === 0) return fn === "Fprintln" ? '"\\n"' : '""';
 		const sep = fn === "Fprintln" ? " " : "";
 		const suffix = fn === "Fprintln" ? "\\n" : "";
 		const fmt = Array(argc).fill("%v").join(sep) + suffix;

package/src/backend/js/stdlib/hex.js

@@ -0,0 +1,17 @@
+// src/backend/js/stdlib/hex.js
+// CodeGen for Go encoding/hex package.
+
+export const hexMethods = {
+	_genHex(fn, a) {
+		this.useHelper("hex");
+		this.useHelper("error");
+		const args = a();
+		if (fn === "EncodeToString") return `__hex_encode_to_string(${args[0]})`;
+		if (fn === "DecodeString") return `__hex_decode_string(${args[0]})`;
+		if (fn === "Encode") return `__hex_encode(${args[0]}, ${args[1]})`;
+		if (fn === "Decode") return `__hex_decode(${args[0]}, ${args[1]})`;
+		if (fn === "EncodedLen") return `(${args[0]} * 2)`;
+		if (fn === "DecodedLen") return `Math.floor(${args[0]} / 2)`;
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/html.js

@@ -12,7 +12,7 @@ export const htmlMethods = {
 			}
 			case "UnescapeString": {
 				const [s] = a();
-				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
+				return `(${s}).replace(/&(?:quot|apos|#39|#34|gt|lt|amp|#(?:[0-9]+|[xX][0-9a-fA-F]+));/g, m => { switch (m) { case "&quot;": case "&#34;": return '"'; case "&apos;": case "&#39;": return "'"; case "&gt;": return ">"; case "&lt;": return "<"; case "&amp;": return "&"; default: { if (m.startsWith("&#")) { const raw = m.slice(2, -1); const cp = (raw.startsWith("x") || raw.startsWith("X")) ? parseInt(raw.slice(1), 16) : parseInt(raw, 10); return (cp >= 0 && cp <= 0x10FFFF && !(cp >= 0xD800 && cp <= 0xDFFF)) ? String.fromCodePoint(cp) : "\\uFFFD"; } return m; } } })`;
 			}
 		}
 		return undefined;

package/src/backend/js/stdlib/index.js

@@ -1,12 +1,15 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
 // One file per Go package under ./stdlib/. This index merges them.
 
+import { base64Methods } from "./base64.js";
+import { binaryMethods } from "./binary.js";
 import { bitsMethods } from "./bits.js";
 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 { hexMethods } from "./hex.js";
 import { htmlMethods } from "./html.js";
 import { ioMethods } from "./io.js";
 import { mapsMethods } from "./maps.js";
@@ -15,10 +18,13 @@ import { osMethods } from "./os.js";
 import { pathMethods } from "./path.js";
 import { randMethods } from "./rand.js";
 import { regexpMethods } from "./regexp.js";
+import { sha256Methods } from "./sha256.js";
+import { sharedMethods } from "./shared.js";
 import { slicesMethods } from "./slices.js";
 import { sortMethods } from "./sort.js";
 import { strconvMethods } from "./strconv.js";
 import { stringsMethods } from "./strings.js";
+import { syncMethods } from "./sync.js";
 import { testingMethods } from "./testing.js";
 import { timeMethods } from "./time.js";
 import { unicodeMethods } from "./unicode.js";
@@ -48,7 +54,14 @@ const STDLIB_METHOD_MAP = {
 	rand: "_genRand",
 	utf8: "_genUtf8",
 	path: "_genPath",
+	filepath: "_genPath",
 	testing: "_genTesting",
+	shared: "_genShared",
+	sync: "_genSync",
+	sha256: "_genSha256",
+	binary: "_genBinary",
+	hex: "_genHex",
+	base64: "_genBase64",
 };
 
 const dispatchMethods = {
@@ -92,6 +105,7 @@ export const stdlibGenMethods = {
 	...pathMethods,
 	...randMethods,
 	...regexpMethods,
+	...sharedMethods,
 	...slicesMethods,
 	...sortMethods,
 	...strconvMethods,
@@ -100,5 +114,10 @@ export const stdlibGenMethods = {
 	...unicodeMethods,
 	...utf8Methods,
 	...testingMethods,
+	...syncMethods,
+	...sha256Methods,
+	...binaryMethods,
+	...hexMethods,
+	...base64Methods,
 	...dispatchMethods,
 };

package/src/backend/js/stdlib/io.js

@@ -5,6 +5,7 @@
 /** @type {ThisType<CodeGen>} */
 export const ioMethods = {
 	_genIo(fn, _a, expr) {
+		if (fn === "ReadAll") this.useHelper("error");
 		switch (fn) {
 			case "WriteString": {
 				const writerArg = expr.args[0];
@@ -19,15 +20,116 @@ export const ioMethods = {
 					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})`;
+					return `((b,s) => { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) b._buf.push(bytes[i]); return [bytes.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 `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return w.WriteString(s); if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) w._buf.push(bytes[i]); return [bytes.length, null]; } if (typeof w.Write === "function") return w.Write(new TextEncoder().encode(s)); return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
 			}
 			case "ReadAll": {
+				this.useHelper("ioEOF");
 				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 `((r) => { const w = r?.value ?? r; const chunks = []; const buf = new Uint8Array(512); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) { for (let i = 0; i < n; i++) chunks.push(buf[i]); } if (n === 0 && !e) break; err = e; } return [new Uint8Array(chunks), (err === "EOF" || err === __io_eof || err?._msg === "EOF") ? null : err]; })(${r})`;
+			}
+			case "LimitReader": {
+				this.useHelper("ioEOF");
+				const r = this.genExpr(expr.args[0]);
+				const n = this.genExpr(expr.args[1]);
+				return `((r, n) => {
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					const reader = r?.value ?? r;
+					return {
+						Read(buf) {
+							if (rem <= 0) return [0, __io_eof];
+							const max = buf.length > rem ? rem : buf.length;
+							const slice = buf.subarray ? buf.subarray(0, max) : buf.slice(0, max);
+							const [readN, err] = reader.Read(slice);
+							if (readN > 0) {
+								if (buf.set && slice !== buf) buf.set(slice.subarray(0, readN), 0);
+								rem -= readN;
+							}
+							return [readN, err];
+						}
+					};
+				})(${r}, ${n})`;
+			}
+			case "Copy": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				return `((dst, src) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					const buf = new Uint8Array(32 * 1024);
+					let total = 0;
+					while (true) {
+						const [n, rerr] = r.Read(buf);
+						if (n > 0) {
+							const chunk = buf.subarray(0, n);
+							const [wn, werr] = writeChunk(chunk);
+							total += wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if (rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") return [total, null];
+							return [total, rerr];
+						}
+					}
+				})(${dst}, ${src})`;
+			}
+			case "CopyN": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				const n = this.genExpr(expr.args[2]);
+				return `((dst, src, n) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					let total = 0;
+					const buf = new Uint8Array(32 * 1024);
+					while (rem > 0) {
+						const toRead = rem < buf.length ? rem : buf.length;
+						const [rn, rerr] = r.Read(buf.subarray(0, toRead));
+						if (rn > 0) {
+							const [wn, werr] = writeChunk(buf.subarray(0, rn));
+							total += wn;
+							rem -= wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if ((rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") && rem === 0) {
+								return [total, null];
+							}
+							return [total, rerr];
+						}
+					}
+					return [total, null];
+				})(${dst}, ${src}, ${n})`;
 			}
 		}
 		return undefined;

package/src/backend/js/stdlib/maps.js

@@ -6,7 +6,7 @@
 export const mapsMethods = {
 	_genMaps(fn, a) {
 		if (fn === "Equal") {
-			this._usesEqual = true;
+			this.useHelper("equal");
 			const [a1, b1] = a();
 			return `__equal(${a1}, ${b1})`;
 		}

package/src/backend/js/stdlib/math.js

@@ -19,6 +19,9 @@ const MATH1 = {
 	Acos: "acos",
 	Exp: "exp",
 	Trunc: "trunc",
+	Sinh: "sinh",
+	Cosh: "cosh",
+	Tanh: "tanh",
 };
 const MATH2 = {
 	Pow: "pow",
@@ -41,7 +44,16 @@ const MATH_EXTRA = {
 	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})`,
+	Remainder: ([x, y]) =>
+		`((x, y) => { if (isNaN(x) || isNaN(y) || y === 0 || !isFinite(x)) return NaN; if (!isFinite(y)) return x; const q = x / y; const r = Math.round(q); const diff = Math.abs(q - r); const n = (diff === 0.5 && (r % 2 !== 0)) ? (r < q ? r + 1 : r - 1) : r; return x - n * y; })(${x}, ${y})`,
+	Float64bits: ([x]) =>
+		`((f) => { const b = new ArrayBuffer(8); new Float64Array(b)[0] = f; return Number(new BigUint64Array(b)[0]); })(${x})`,
+	Float64frombits: ([b]) =>
+		`((u) => { const buf = new ArrayBuffer(8); new BigUint64Array(buf)[0] = BigInt(u); return new Float64Array(buf)[0]; })(${b})`,
+	Float32bits: ([x]) =>
+		`((f) => { const b = new ArrayBuffer(4); new Float32Array(b)[0] = f; return new Uint32Array(b)[0]; })(${x})`,
+	Float32frombits: ([b]) =>
+		`((u) => { const buf = new ArrayBuffer(4); new Uint32Array(buf)[0] = Number(u) >>> 0; return new Float32Array(buf)[0]; })(${b})`,
 };
 
 /** @type {ThisType<CodeGen>} */