gofront 1.4.0 → 1.6.0

package/src/{codegen → backend/js}/statements.js

@@ -1,6 +1,13 @@
-// CodeGen statement methods — installed as a mixin on CodeGen.prototype.
-
-import { isComplex, isNumeric } from "../typechecker/types.js";
+import {
+	bodyRedeclares,
+	isIntRangeType,
+	isMapRangeType,
+	isRangeFor,
+	isSimpleIntRange,
+	isStringRangeType,
+	nodeAssigns,
+} from "../../lower/index.js";
+import { isComplex } from "../../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -24,27 +31,35 @@ export const statementGenMethods = {
 	},
 
 	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
-	// isDefine=true  → emit `let v = m[k]; let ok = k in m;`
-	// isDefine=false → emit `v = k in m ? m[k] : zero; ok = k in m;`
 	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
 		const mapExpr = this.genExpr(rhsNode.expr);
 		const keyExpr = this.genExpr(rhsNode.index);
 		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
 		const decl = isDefine ? "let " : "";
-		if (vName !== "_") {
-			if (isDefine) {
+		if (isDefine && !this.strict) {
+			if (vName !== "_") {
 				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
-			} else {
-				const zero = rhsNode._mapValueType
-					? this.zeroValueForType(rhsNode._mapValueType)
-					: "undefined";
-				this.line(
-					`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
-				);
 			}
+			if (okName !== "_") {
+				this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+			}
+			return;
+		}
+		const zero = rhsNode._mapValueType
+			? this.zeroValueForType(rhsNode._mapValueType)
+			: "undefined";
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const mTmp = `__m${this._tmpCounter}`;
+		const kTmp = `__k${this._tmpCounter}`;
+		this.line(`const ${mTmp} = ${mapExpr}, ${kTmp} = ${keyExpr};`);
+		if (vName !== "_") {
+			this.line(
+				`${decl}${vName} = (${mTmp} && (${kTmp} in ${mTmp})) ? ${mTmp}[${kTmp}] : ${zero};`,
+			);
+		}
+		if (okName !== "_") {
+			this.line(`${decl}${okName} = Boolean(${mTmp} && (${kTmp} in ${mTmp}));`);
 		}
-		if (okName !== "_")
-			this.line(`${decl}${okName} = (${keyExpr}) in ${mapExpr};`);
 	},
 
 	genStmt(stmt) {
@@ -55,9 +70,47 @@ export const statementGenMethods = {
 			case "TypeDecl":
 				this.genTypeDeclWithMethods(stmt, []);
 				break;
-			case "IncDecStmt":
-				this.line(`${this.genExpr(stmt.expr)}${stmt.op};`);
+			case "IncDecStmt": {
+				if (stmt.expr.kind === "IndexExpr" && stmt.expr._mapValueType) {
+					const zero = this.zeroValueForType(stmt.expr._mapValueType);
+					const wrapField = this._namedWrapperField(
+						stmt.expr.expr._type,
+						stmt.expr.expr,
+					);
+					const base = wrapField
+						? `${this.genExpr(stmt.expr.expr)}.${wrapField}`
+						: this.genExpr(stmt.expr.expr);
+					const idx = this.genExpr(stmt.expr.index);
+					const op = stmt.op === "++" ? "+" : "-";
+					if (
+						this._hasCallExpr(stmt.expr.expr) ||
+						this._hasCallExpr(stmt.expr.index)
+					) {
+						this.line(
+							`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${op} 1; })(${base}, ${idx});`,
+							srcLine,
+						);
+					} else {
+						this.line(
+							`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${op} 1;`,
+							srcLine,
+						);
+					}
+					break;
+				}
+				if (
+					this.strict &&
+					this._genStrictCompound(
+						stmt.expr,
+						stmt.op === "++" ? "+" : "-",
+						"1",
+						srcLine,
+					)
+				)
+					break;
+				this.line(`${this.genExpr(stmt.expr)}${stmt.op};`, srcLine);
 				break;
+			}
 			case "ExprStmt":
 				this.line(`${this.genExpr(stmt.expr)};`);
 				break;
@@ -248,6 +301,48 @@ export const statementGenMethods = {
 		if (active.length === 0) {
 			if (rhs.length > 0) this.line(`${rhs[0]};`);
 		} else if (lhs.length === 1) {
+			if (
+				stmt.op !== "=" &&
+				stmt.lhs[0].kind === "IndexExpr" &&
+				stmt.lhs[0]._mapValueType
+			) {
+				const zero = this.zeroValueForType(stmt.lhs[0]._mapValueType);
+				const wrapField = this._namedWrapperField(
+					stmt.lhs[0].expr._type,
+					stmt.lhs[0].expr,
+				);
+				const base = wrapField
+					? `${this.genExpr(stmt.lhs[0].expr)}.${wrapField}`
+					: this.genExpr(stmt.lhs[0].expr);
+				const idx = this.genExpr(stmt.lhs[0].index);
+				const binOp = stmt.op.slice(0, -1);
+				if (
+					this._hasCallExpr(stmt.lhs[0].expr) ||
+					this._hasCallExpr(stmt.lhs[0].index)
+				) {
+					this.line(
+						`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${binOp} (${active[0].r}); })(${base}, ${idx});`,
+					);
+				} else {
+					this.line(
+						`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${binOp} (${active[0].r});`,
+					);
+				}
+				return;
+			}
+			if (
+				this.strict &&
+				stmt.op !== "=" &&
+				this._genStrictCompound(
+					stmt.lhs[0],
+					stmt.op.slice(0, -1),
+					active[0].r,
+					null,
+					active[0].l,
+				)
+			) {
+				return;
+			}
 			this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
 		} else {
 			this._genAssignMulti(stmt, lhs, rhs, active, pairs);
@@ -302,11 +397,11 @@ export const statementGenMethods = {
 				result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
 				break;
 			case "*":
-				this._usesCmul = true;
+				this.useHelper("cmul");
 				result = `__cmul(${lhsStr}, ${rhsExpr})`;
 				break;
 			case "/":
-				this._usesCdiv = true;
+				this.useHelper("cdiv");
 				result = `__cdiv(${lhsStr}, ${rhsExpr})`;
 				break;
 			default:
@@ -348,6 +443,22 @@ export const statementGenMethods = {
 			} else {
 				this.line("return;");
 			}
+		} else if (this.namedReturnVars?.length > 0) {
+			const vars = this.namedReturnVars;
+			if (stmt.values.length === 1 && vars.length === 1) {
+				this.line(`${vars[0]} = ${this._genReturnValue(stmt.values[0])};`);
+			} else if (stmt.values.length === 1 && vars.length > 1) {
+				const val = this._genReturnValue(stmt.values[0]);
+				this.line(`[${vars.join(", ")}] = ${val};`);
+			} else if (stmt.values.length > 1 && stmt.values.length === vars.length) {
+				const temps = stmt.values.map((v) => this._genReturnValue(v));
+				this.line(`[${vars.join(", ")}] = [${temps.join(", ")}];`);
+			}
+			this.line(
+				vars.length === 1
+					? `return ${vars[0]};`
+					: `return [${vars.join(", ")}];`,
+			);
 		} else if (stmt.values.length === 1) {
 			this.line(`return ${this._genReturnValue(stmt.values[0])};`);
 		} else {
@@ -449,28 +560,19 @@ export const statementGenMethods = {
 	},
 
 	isRangeFor(stmt) {
-		if (!stmt.init) return false;
-		const init = stmt.init;
-		if (init.kind !== "DefineStmt" && init.kind !== "AssignStmt") return false;
-		return init.rhs?.[0]?.kind === "RangeExpr";
+		return isRangeFor(stmt);
 	},
 
 	_isIntRangeType(iterType) {
-		return isNumeric(iterType);
+		return isIntRangeType(iterType);
 	},
 
 	_isMapRangeType(iterType) {
-		return (
-			iterType?.kind === "map" ||
-			(iterType?.kind === "named" && iterType.underlying?.kind === "map")
-		);
+		return isMapRangeType(iterType);
 	},
 
 	_isStringRangeType(iterType) {
-		return (
-			(iterType?.kind === "basic" && iterType.name === "string") ||
-			(iterType?.kind === "untyped" && iterType.base === "string")
-		);
+		return isStringRangeType(iterType);
 	},
 
 	_rangeVarTarget(e, isAssign) {
@@ -498,17 +600,7 @@ export const statementGenMethods = {
 
 	// True when the body re-declares one of `names` at its top level (legal Go shadowing).
 	_bodyRedeclares(body, names) {
-		if (names.length === 0) return false;
-		for (const s of body.stmts ?? []) {
-			if (s.kind === "DefineStmt" && s.lhs.some((e) => names.includes(e.name)))
-				return true;
-			if (
-				(s.kind === "VarDecl" || s.kind === "ConstDecl") &&
-				s.decls?.some((d) => d.names?.some((n) => names.includes(n)))
-			)
-				return true;
-		}
-		return false;
+		return bodyRedeclares(body, names);
 	},
 
 	// Range value variable: aliases the element unless the body writes the variable or the collection.
@@ -565,9 +657,7 @@ export const statementGenMethods = {
 
 	// Whether `for i := range n` can be emitted as a plain `for (let i = 0; …)` without hidden registers.
 	_isSimpleIntRange(stmt, name, isAssign) {
-		if (isAssign) return false;
-		if (!name || name === "_") return true;
-		return !this._boxedVars.has(name) && !this._nodeAssigns(stmt.body, name);
+		return isSimpleIntRange(stmt, name, isAssign, this._boxedVars);
 	},
 
 	_genIntRangeBody(stmt, name, isAssign) {
@@ -603,22 +693,7 @@ export const statementGenMethods = {
 
 	// True when `node` contains an assignment or ++/-- targeting identifier `name`.
 	_nodeAssigns(node, name) {
-		if (!node || typeof node !== "object") return false;
-		if (Array.isArray(node))
-			return node.some((n) => this._nodeAssigns(n, name));
-		if (
-			(node.kind === "AssignStmt" &&
-				node.lhs.some((e) => e.kind === "Ident" && e.name === name)) ||
-			(node.kind === "IncDecStmt" &&
-				node.expr.kind === "Ident" &&
-				node.expr.name === name)
-		)
-			return true;
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			if (this._nodeAssigns(node[key], name)) return true;
-		}
-		return false;
+		return nodeAssigns(node, name);
 	},
 
 	_genIterFor(init, iterType, iteree, lhs, body) {
@@ -667,7 +742,7 @@ export const statementGenMethods = {
 			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
 			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
 		}
-		this._usesSliceGuard = true;
+		this.useHelper("sliceGuard");
 		if (lhs.length === 1) return `__s(${iteree}).keys()`;
 		return `__s(${iteree}).entries()`;
 	},

package/src/backend/js/stdlib/bits.js

@@ -0,0 +1,32 @@
+// src/backend/js/stdlib/bits.js
+// CodeGen for Go `math/bits` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const BITS_MAP = {
+	LeadingZeros32: ([x]) => `Math.clz32((${x}) >>> 0)`,
+	TrailingZeros32: ([x]) =>
+		`((() => { const v = (${x}) >>> 0; return v === 0 ? 32 : 31 - Math.clz32(v & -v); })())`,
+	OnesCount32: ([x]) =>
+		`((() => { let v = (${x}) >>> 0; v = v - ((v >>> 1) & 0x55555555); v = (v & 0x33333333) + ((v >>> 2) & 0x33333333); return (Math.imul((v + (v >>> 4)) & 0x0f0f0f0f, 0x01010101)) >>> 24; })())`,
+	RotateLeft32: ([x, k]) =>
+		`((() => { const s = (${k}) & 31; const v = (${x}) >>> 0; return ((v << s) | (v >>> ((32 - s) & 31))) >>> 0; })())`,
+
+	LeadingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 64; const hi = Number(v >> 32n); return hi !== 0 ? Math.clz32(hi) : 32 + Math.clz32(Number(v & 0xffffffffn)); })())`,
+	TrailingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 64; const lo = Number(v & 0xffffffffn); if (lo !== 0) return 31 - Math.clz32(lo & -lo); const hi = Number((v >> 32n) & 0xffffffffn); return 32 + (31 - Math.clz32(hi & -hi)); })())`,
+	OnesCount64: ([x]) =>
+		`((() => { let v = BigInt.asUintN(64, BigInt(${x})); let c = 0; while (v > 0n) { if (v & 1n) c++; v >>= 1n; } return c; })())`,
+	RotateLeft64: ([x, k]) =>
+		`((() => { const s = BigInt(${k}) & 63n; const v = BigInt.asUintN(64, BigInt(${x})); return BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n))); })())`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const bitsMethods = {
+	_genBits(fn, a) {
+		const args = a();
+		const gen = BITS_MAP[fn];
+		return gen ? gen(args) : undefined;
+	},
+};

package/src/{codegen → backend/js}/stdlib/errors.js

@@ -7,11 +7,11 @@ export const errorsMethods = {
 	_genErrors(fn, a) {
 		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)`;

package/src/{codegen → backend/js}/stdlib/fmt.js

@@ -15,11 +15,11 @@ export const fmtMethods = {
 		const fmtArgs = expr.args.map((e) => this.genExpr(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,12 +28,15 @@ 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":
@@ -69,7 +72,7 @@ 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(", ");
@@ -93,8 +96,23 @@ export const fmtMethods = {
 		return `${w}.WriteString(${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.genExpr(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/{codegen → backend/js}/stdlib/index.js

@@ -1,6 +1,7 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
 // One file per Go package under ./stdlib/. This index merges them.
 
+import { bitsMethods } from "./bits.js";
 import { builderMethods } from "./builder.js";
 import { bytesMethods } from "./bytes.js";
 import { errorsMethods } from "./errors.js";
@@ -14,6 +15,7 @@ import { osMethods } from "./os.js";
 import { pathMethods } from "./path.js";
 import { randMethods } from "./rand.js";
 import { regexpMethods } from "./regexp.js";
+import { sharedMethods } from "./shared.js";
 import { slicesMethods } from "./slices.js";
 import { sortMethods } from "./sort.js";
 import { strconvMethods } from "./strconv.js";
@@ -34,6 +36,7 @@ const STDLIB_METHOD_MAP = {
 	strconv: "_genStrconv",
 	sort: "_genSort",
 	math: "_genMath",
+	bits: "_genBits",
 	unicode: "_genUnicode",
 	os: "_genOs",
 	errors: "_genErrors",
@@ -47,6 +50,7 @@ const STDLIB_METHOD_MAP = {
 	utf8: "_genUtf8",
 	path: "_genPath",
 	testing: "_genTesting",
+	shared: "_genShared",
 };
 
 const dispatchMethods = {
@@ -76,6 +80,7 @@ const dispatchMethods = {
 
 /** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
+	...bitsMethods,
 	...builderMethods,
 	...bytesMethods,
 	...errorsMethods,
@@ -89,6 +94,7 @@ export const stdlibGenMethods = {
 	...pathMethods,
 	...randMethods,
 	...regexpMethods,
+	...sharedMethods,
 	...slicesMethods,
 	...sortMethods,
 	...strconvMethods,

package/src/{codegen → 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/{codegen → backend/js}/stdlib/path.js

@@ -20,12 +20,12 @@ const PATH_DISPATCH = {
 export const pathMethods = {
 	_genPath(fn, a, expr) {
 		if (fn === "Join") {
-			this._usesPathClean = true;
+			this.useHelper("pathClean");
 			const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
 			return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
 		}
 		if (fn === "Clean") {
-			this._usesPathClean = true;
+			this.useHelper("pathClean");
 			return `__pathClean(${a()[0]})`;
 		}
 		const gen = PATH_DISPATCH[fn];

package/src/backend/js/stdlib/shared.js

@@ -0,0 +1,17 @@
+// CodeGen for the `gofront/shared` package: in js packages a shared buffer is
+// just a TypedArray (no linear memory is involved); in wasm packages the facade
+// hands out zero-copy views onto the module memory.
+
+import { SHARED_KINDS } from "../../../typechecker/stdlib/shared.js";
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const sharedMethods = {
+	_genShared(fn, a) {
+		if (!fn.startsWith("New")) return undefined;
+		const info = SHARED_KINDS[fn.slice(3)];
+		if (!info) return undefined;
+		return `new ${info.ctor}(${a()[0]})`;
+	},
+};

package/src/{codegen → backend/js}/stdlib/slices.js

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

package/src/{codegen → backend/js}/stdlib/sort.js

@@ -23,7 +23,7 @@ const SORT_DISPATCH = {
 /** @type {ThisType<CodeGen>} */
 export const sortMethods = {
 	_genSort(fn, a) {
-		if (fn === "Slice" || fn === "SliceStable") this._usesSortSlice = true;
+		if (fn === "Slice" || fn === "SliceStable") this.useHelper("sortSlice");
 		const gen = SORT_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/backend/js/stdlib/strconv.js

@@ -0,0 +1,58 @@
+// CodeGen for Go `strconv` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+// Parsers return [value, msg|null] from the shared __strconv_* helpers
+// (runtime.js); the message becomes a Go error value.
+const parsed = (call, toValue = "r[0]") =>
+	`((r) => [${toValue}, r[1] === null ? null : __error(r[1])])(${call})`;
+
+const STRCONV_DISPATCH = {
+	Itoa: (a) => `String(${a[0]})`,
+	Atoi: (a) => parsed(`__strconv_atoi(${a[0]})`, "Number(r[0])"),
+	FormatBool: (a) => `String(${a[0]})`,
+	FormatInt: (a) => `(${a[0]}).toString(${a[1]})`,
+	FormatFloat: (a) =>
+		a.length < 3
+			? `String(${a[0]})`
+			: `__strconv_format_float(${a[0]}, ${a[1]}, ${a[2]})`,
+	ParseFloat: (a) => parsed(`__strconv_parse_float(${a[0]})`),
+	ParseInt: (a) =>
+		parsed(
+			`__strconv_parse_int(${a[0]}, ${a[1]}, ${a[2] ?? 64})`,
+			"Number(r[0])",
+		),
+	ParseBool: (a) => parsed(`__strconv_parse_bool(${a[0]})`),
+	Quote: (a) => `JSON.stringify(${a[0]})`,
+	Unquote: (a) =>
+		`((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", __error("invalid syntax")]; } })(${a[0]})`,
+	AppendInt: (a) =>
+		`[...(${a[0]}), ...new TextEncoder().encode((${a[1]}).toString(${a[2]}))]`,
+	AppendFloat: (a) =>
+		`[...(${a[0]}), ...new TextEncoder().encode(${a[1]}.toFixed(${a[3]} < 0 ? 6 : ${a[3]}))]`,
+};
+
+const USES_ERROR = new Set([
+	"Atoi",
+	"ParseFloat",
+	"ParseInt",
+	"ParseBool",
+	"Unquote",
+]);
+const USES_STRCONV = new Set([
+	"Atoi",
+	"ParseFloat",
+	"ParseInt",
+	"ParseBool",
+	"FormatFloat",
+]);
+
+/** @type {ThisType<CodeGen>} */
+export const strconvMethods = {
+	_genStrconv(fn, a) {
+		const gen = STRCONV_DISPATCH[fn];
+		if (gen && USES_ERROR.has(fn)) this.useHelper("error");
+		if (gen && USES_STRCONV.has(fn)) this.useHelper("strconv");
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/{codegen → backend/js}/stdlib/strings.js

@@ -21,7 +21,10 @@ const STRINGS_M2 = {
 const STRINGS_DISPATCH = {
 	Count: ([s, s2]) =>
 		`((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${s}, ${s2})`,
-	Replace: ([s, s2, s3]) => `${s}.replace(${s2}, ${s3})`,
+	Replace: ([s, s2, s3, n]) =>
+		n === undefined
+			? `${s}.replace(${s2}, ${s3})`
+			: `((str, o, nw, cnt) => { if (cnt < 0) return str.replaceAll(o, nw); let r = ""; let i = 0; for (; cnt > 0; cnt--) { const j = str.indexOf(o, i); if (j < 0) break; r += str.slice(i, j) + nw; i = j + o.length; if (o.length === 0) { if (i >= str.length) break; r += str[i]; i++; } } return r + str.slice(i); })(${s}, ${s2}, ${s3}, ${n})`,
 	ReplaceAll: ([s, s2, s3]) => `${s}.replaceAll(${s2}, ${s3})`,
 	Trim: ([s, s2]) =>
 		`${s}.replace(new RegExp(\`^[\${${s2}}]+|[\${${s2}}]+$\`, "g"), "")`,

package/src/{codegen → backend/js}/stdlib/testing.js

@@ -15,7 +15,7 @@ export const testingMethods = {
 	},
 
 	_genTestingMethodCall(method, expr) {
-		this._usesTesting = true;
+		this.useHelper("testing");
 		const recv = expr.func.expr;
 		const t = this.genExpr(recv);
 		const args = expr.args
@@ -27,7 +27,7 @@ export const testingMethods = {
 			method === "Logf" ||
 			method === "Skipf"
 		) {
-			this._usesSprintf = true;
+			this.useHelper("sprintf");
 		}
 		return `${t}.${method}(${args})`;
 	},

package/src/{codegen → backend/js}/stdlib/time.js

@@ -35,11 +35,11 @@ export const timeMethods = {
 		const recvJs = this.genExpr(recv);
 		const args = expr.args.map((a) => this.genExpr(a));
 		if (method === "Format") {
-			this._usesTimeFmt = true;
+			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}._d, ${args[0]})`;
 		}
 		if (method === "String") {
-			this._usesTimeFmt = true;
+			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
 		}
 		const gen = TIME_METHOD_DISPATCH[method];
@@ -48,7 +48,7 @@ export const timeMethods = {
 
 	_genTime(fn, a) {
 		if (fn === "Parse") {
-			this._usesTimeParse = true;
+			this.useHelper("timeParse");
 			return `__timeParse(${a()[0]}, ${a()[1]})`;
 		}
 		const gen = TIME_DISPATCH[fn];

package/src/{codegen → backend/js}/templ.js

@@ -2,8 +2,8 @@
 // Mounts an HTML/expression tree onto a parent DOM node by emitting plain
 // document.createElement / appendChild / setAttribute calls.
 
-import { Parser } from "../parser/index.js";
-import { T, Token } from "../tokens.js";
+import { Parser } from "../../parser/index.js";
+import { T, Token } from "../../tokens.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -286,7 +286,7 @@ export const templGenMethods = {
 		if (valName === "_")
 			return `for (const [${keyName}] of Object.entries(${iterJs})) {`;
 		// Default to .entries() for arrays, Object.entries for objects
-		this._usesSliceGuard = true;
+		this.useHelper("sliceGuard");
 		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
 	},