gofront 1.7.0 → 1.8.0

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

@@ -4,25 +4,28 @@
 
 // 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], r[1].includes("invalid syntax") ? __strconv_err_syntax : r[1].includes("value out of range") ? __strconv_err_range : null)])(${call})`;
+const parsed = (fnName, numArg, call, toValue = "r[0]") =>
+	`((r, s) => [${toValue}, r[1] === null ? null : (typeof NumError$$strconv !== "undefined" ? ((o) => { o.__p = true; return o; })(new NumError$$strconv("${fnName}", String(s), r[1].includes("value out of range") ? __strconv_err_range : __strconv_err_syntax)) : __error(r[1], r[1].includes("invalid syntax") ? __strconv_err_syntax : r[1].includes("value out of range") ? __strconv_err_range : null))])(${call}, ${numArg})`;
 
 const STRCONV_DISPATCH = {
 	Itoa: (a) => `String(${a[0]})`,
-	Atoi: (a) => parsed(`__strconv_atoi(${a[0]})`, "Number(r[0])"),
+	Atoi: (a) => parsed("Atoi", a[0], `__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]})`),
+	ParseFloat: (a) =>
+		parsed("ParseFloat", a[0], `__strconv_parse_float(${a[0]})`),
 	ParseInt: (a) =>
 		parsed(
+			"ParseInt",
+			a[0],
 			`__strconv_parse_int(${a[0]}, ${a[1]}, ${a[2] ?? 64})`,
 			"Number(r[0])",
 		),
-	ParseBool: (a) => parsed(`__strconv_parse_bool(${a[0]})`),
+	ParseBool: (a) => parsed("ParseBool", a[0], `__strconv_parse_bool(${a[0]})`),
 	Quote: (a) => `JSON.stringify(${a[0]})`,
 	Unquote: (a) =>
 		`((s) => { if (typeof s === "string" && s.startsWith("\`") && s.endsWith("\`") && s.length >= 2) { if (s.slice(1, -1).includes("\`")) return ["", __strconv_err_syntax]; return [s.slice(1, -1), null]; } try { const v = JSON.parse(s); if (typeof v !== "string") throw 0; return [v, null]; } catch(e) { return ["", __strconv_err_syntax]; } })(${a[0]})`,
@@ -37,6 +40,8 @@ const STRCONV_DISPATCH = {
 	FormatUint: (a) => `(BigInt.asUintN(64, BigInt(${a[0]}))).toString(${a[1]})`,
 	ParseUint: (a) =>
 		parsed(
+			"ParseUint",
+			a[0],
 			`__strconv_parse_uint(${a[0]}, ${a[1]}, ${a[2] ?? 64})`,
 			"Number(r[0])",
 		),

package/src/backend/js/stdlib/strings.js

@@ -16,9 +16,9 @@ const STRINGS_M2 = {
 	LastIndex: "lastIndexOf",
 	Repeat: "repeat",
 	Split: "split",
-	Join: "join",
 };
 const STRINGS_DISPATCH = {
+	Join: ([a, sep]) => `(${a} ?? []).join(${sep})`,
 	Count: ([s, s2]) =>
 		`((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${s}, ${s2})`,
 	Replace: ([s, s2, s3, n]) =>
@@ -37,7 +37,8 @@ const STRINGS_DISPATCH = {
 	TrimRight: ([s, s2]) =>
 		`((str, cut) => { const cs = new Set(cut); let j = str.length; while (j > 0 && cs.has(str[j - 1])) j--; return str.slice(0, j); })(${s}, ${s2})`,
 	EqualFold: ([s, s2]) => `${s}.toLowerCase() === ${s2}.toLowerCase()`,
-	Fields: ([s]) => `(${s}).trim() === '' ? [] : (${s}).trim().split(/\\s+/)`,
+	Fields: ([s]) =>
+		`(${s}).split(/[ \\t\\n\\v\\f\\r\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]+/).filter(p => p !== "")`,
 	FieldsFunc: ([s, f]) =>
 		`((s, fn) => { const res = []; const runes = Array.from(s ?? ""); let cur = ""; for (const ch of runes) { const cp = ch.codePointAt(0); if (fn(cp)) { if (cur.length > 0) { res.push(cur); cur = ""; } } else { cur += ch; } } if (cur.length > 0) res.push(cur); return res; })(${s}, ${f})`,
 	Cut: ([s, s2]) =>
@@ -169,8 +170,83 @@ const STRINGS_DISPATCH = {
 		`((s, f) => { for (let i = 0; i < s.length; i++) { const cp = s.codePointAt(i); if (f(cp)) return i; if (cp > 0xFFFF) i++; } return -1; })(${s}, ${s2})`,
 	LastIndexFunc: ([s, s2]) =>
 		`((s, f) => { for (let i = s.length - 1; i >= 0; i--) { let cp = s.codePointAt(i); if (i > 0 && s.charCodeAt(i) >= 0xDC00 && s.charCodeAt(i) <= 0xDFFF && s.charCodeAt(i - 1) >= 0xD800 && s.charCodeAt(i - 1) <= 0xDBFF) { cp = s.codePointAt(i - 1); i--; } if (f(cp)) return i; } return -1; })(${s}, ${s2})`,
+	ToValidUTF8: ([s, repl]) =>
+		`(${s} ? ${s}.replace(/(?:[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF])+/g, ${repl} ?? "") : (${s} ?? ""))`,
 	NewReader: ([s]) =>
-		`((s) => ({ _bytes: new TextEncoder().encode(s), _pos: 0, Read(p) { if (this._pos >= this._bytes.length) return [0, __io_eof]; const n = Math.min(p.length, this._bytes.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._bytes[this._pos + i]; this._pos += n; return [n, null]; }, Len() { return Math.max(0, this._bytes.length - this._pos); }, Reset(s2) { this._bytes = new TextEncoder().encode(s2); this._pos = 0; } }))(${s})`,
+		`((s) => ({
+			_bytes: new TextEncoder().encode(s ?? ""),
+			_pos: 0,
+			_prevRune: -1,
+			Read(p) {
+				if (this._pos >= this._bytes.length) return [0, __io_eof];
+				const n = Math.min(p.length, this._bytes.length - this._pos);
+				for (let i = 0; i < n; i++) p[i] = this._bytes[this._pos + i];
+				this._pos += n;
+				this._prevRune = -1;
+				return [n, null];
+			},
+			ReadAt(b, off) {
+				const o = Number(off);
+				if (o < 0) return [0, __error("strings.Reader.ReadAt: negative offset")];
+				if (o >= this._bytes.length) return [0, __io_eof];
+				const n = Math.min(b.length, this._bytes.length - o);
+				for (let i = 0; i < n; i++) b[i] = this._bytes[o + i];
+				return [n, n < b.length ? __io_eof : null];
+			},
+			ReadByte() {
+				if (this._pos >= this._bytes.length) return [0, __io_eof];
+				this._prevRune = -1;
+				return [this._bytes[this._pos++], null];
+			},
+			UnreadByte() {
+				if (this._pos <= 0) return __error("strings.Reader.UnreadByte: at beginning of string");
+				this._prevRune = -1;
+				this._pos--;
+				return null;
+			},
+			ReadRune() {
+				if (this._pos >= this._bytes.length) return [0, 0, __io_eof];
+				const rem = this._bytes.subarray(this._pos);
+				const str = new TextDecoder().decode(rem);
+				const cp = str.codePointAt(0);
+				const runeStr = str.slice(0, cp > 0xffff ? 2 : 1);
+				const sz = new TextEncoder().encode(runeStr).length;
+				this._prevRune = this._pos;
+				this._pos += sz;
+				return [cp, sz, null];
+			},
+			UnreadRune() {
+				if (this._prevRune === undefined || this._prevRune < 0 || this._prevRune >= this._pos) {
+					return __error("strings.Reader.UnreadRune: previous operation was not ReadRune");
+				}
+				this._pos = this._prevRune;
+				this._prevRune = -1;
+				return null;
+			},
+			Seek(offset, whence) {
+				const off = BigInt(offset);
+				const w = Number(whence);
+				let newPos;
+				if (w === 0) newPos = off;
+				else if (w === 1) newPos = BigInt(this._pos) + off;
+				else if (w === 2) newPos = BigInt(this._bytes.length) + off;
+				else return [0n, __error("strings.Reader.Seek: invalid whence")];
+				if (newPos < 0n) return [0n, __error("strings.Reader.Seek: negative position")];
+				this._pos = Number(newPos);
+				this._prevRune = -1;
+				return [newPos, null];
+			},
+			Size() { return BigInt(this._bytes.length); },
+			WriteTo(w) {
+				if (this._pos >= this._bytes.length) return [0, null];
+				const rem = this._bytes.subarray(this._pos);
+				const [n, err] = w.Write(rem);
+				this._pos += n;
+				return [n, err];
+			},
+			Len() { return Math.max(0, this._bytes.length - this._pos); },
+			Reset(s2) { this._bytes = new TextEncoder().encode(s2 ?? ""); this._pos = 0; this._prevRune = -1; }
+		}))(${s})`,
 	NewReplacer: (args) =>
 		`((...pairs) => {
 			const p = [];
@@ -211,7 +287,10 @@ const STRINGS_DISPATCH = {
 /** @type {ThisType<CodeGen>} */
 export const stringsMethods = {
 	_genStrings(fn, a) {
-		if (fn === "NewReader") this.useHelper("ioEOF");
+		if (fn === "NewReader") {
+			this.useHelper("ioEOF");
+			this.useHelper("error");
+		}
 		const args = a();
 		const [s, s2] = args;
 		if (STRINGS_M1[fn]) return `${s}.${STRINGS_M1[fn]}()`;

package/src/backend/js/stdlib/testing.js

@@ -10,6 +10,13 @@ export const testingMethods = {
 				return "false";
 			case "Verbose":
 				return "Boolean(globalThis.__gofront_verbose)";
+			case "Testing":
+				return "true";
+			case "Init":
+				return "/* testing.Init */";
+			case "Benchmark":
+				this.useHelper("testing");
+				return `__testing_Benchmark(${_a()[0]})`;
 		}
 		return undefined;
 	},

package/src/backend/js/stdlib/time.js

@@ -3,53 +3,52 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const TIME_METHOD_DISPATCH = {
-	Year: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCFullYear() : ${r}._d.getFullYear())`,
-	Month: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCMonth() + 1 : ${r}._d.getMonth() + 1)`,
-	Day: (r) => `(${r}._offset === 0 ? ${r}._d.getUTCDate() : ${r}._d.getDate())`,
-	Hour: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCHours() : ${r}._d.getHours())`,
-	Minute: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCMinutes() : ${r}._d.getMinutes())`,
-	Second: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCSeconds() : ${r}._d.getSeconds())`,
-	Weekday: (r) =>
-		`(${r}._offset === 0 ? ${r}._d.getUTCDay() : ${r}._d.getDay())`,
+	Year: (r) => `__timeYear(${r})`,
+	Month: (r) => `__timeMonth(${r})`,
+	Day: (r) => `__timeDay(${r})`,
+	Hour: (r) => `__timeHour(${r})`,
+	Minute: (r) => `__timeMinute(${r})`,
+	Second: (r) => `__timeSecond(${r})`,
+	Weekday: (r) => `__timeWeekday(${r})`,
 	Unix: (r) => `Math.floor(${r}._d.getTime() / 1000)`,
 	UnixMilli: (r) => `${r}._d.getTime()`,
 	Add: (r, a) =>
-		`{_d: new Date(${r}._d.getTime() + Math.round(Number(${a[0]}) / 1000000))}`,
+		`{_d: new Date(${r}._d.getTime() + Math.round(Number(${a[0]}) / 1000000)), _offset: ${r}._offset, _loc: ${r}._loc, _ns: ${r}._ns}`,
 	Sub: (r, a) =>
 		`Math.round((${r}._d.getTime() - (${a[0]})._d.getTime()) * 1000000)`,
 	Before: (r, a) => `(${r}._d < (${a[0]})._d)`,
 	After: (r, a) => `(${r}._d > (${a[0]})._d)`,
-	Equal: (r, a) => `(${r}._d.getTime() === (${a[0]})._d.getTime())`,
+	Equal: (r, a) =>
+		`(${r}._d.getTime() === (${a[0]})._d.getTime() && (${r}._ns || 0) === ((${a[0]})._ns || 0))`,
 	IsZero: (r) =>
 		`(!${r} || !${r}._d || ${r}._isZero === true || ${r}._d.getTime() === -62135596800000 || (${r}._d.getUTCFullYear() <= 1 && ${r}._d.getUTCMonth() === 0 && ${r}._d.getUTCDate() === 1 && ${r}._d.getUTCHours() === 0 && ${r}._d.getUTCMinutes() === 0 && ${r}._d.getUTCSeconds() === 0 && ${r}._d.getUTCMilliseconds() === 0))`,
-	UnixNano: (r) => `(${r}?._d ? Math.round(${r}._d.getTime() * 1000000) : 0)`,
+	UnixNano: (r) =>
+		`(${r}?._d ? Math.round(${r}._d.getTime() * 1000000) + (${r}._ns || 0) : 0)`,
 	Nanosecond: (r) =>
-		`(${r}?._d ? (${r}._offset === 0 ? ${r}._d.getUTCMilliseconds() : ${r}._d.getMilliseconds()) * 1000000 : 0)`,
-	UTC: (r) => `({_d: ${r}?._d ?? new Date(0), _offset: 0})`,
-	Local: (r) => `({_d: ${r}?._d ?? new Date(0)})`,
-	AddDate: (r, a) =>
-		`({_d: new Date(${r}._d.getFullYear() + Number(${a[0]}), ${r}._d.getMonth() + Number(${a[1]}), ${r}._d.getDate() + Number(${a[2]}))})`,
-	Truncate: (r, a) =>
-		`({_d: new Date(Math.floor(${r}._d.getTime() / (Number(${a[0]}) / 1000000)) * (Number(${a[0]}) / 1000000))})`,
-	Round: (r, a) =>
-		`({_d: new Date(Math.round(${r}._d.getTime() / (Number(${a[0]}) / 1000000)) * (Number(${a[0]}) / 1000000))})`,
-	Date: (r) =>
-		`[${r}._offset === 0 ? ${r}._d.getUTCFullYear() : ${r}._d.getFullYear(), ${r}._offset === 0 ? ${r}._d.getUTCMonth() + 1 : ${r}._d.getMonth() + 1, ${r}._offset === 0 ? ${r}._d.getUTCDate() : ${r}._d.getDate()]`,
-	Clock: (r) =>
-		`[${r}._offset === 0 ? ${r}._d.getUTCHours() : ${r}._d.getHours(), ${r}._offset === 0 ? ${r}._d.getUTCMinutes() : ${r}._d.getMinutes(), ${r}._offset === 0 ? ${r}._d.getUTCSeconds() : ${r}._d.getSeconds()]`,
-	YearDay: (r) =>
-		`Math.floor((${r}._d - new Date(${r}._d.getFullYear(), 0, 0)) / 86400000)`,
+		`(${r}?._d ? (typeof ${r}._offset === "number" ? ${r}._d.getUTCMilliseconds() : ${r}._d.getMilliseconds()) * 1000000 + (${r}._ns || 0) : 0)`,
+	UTC: (r) =>
+		`({_d: ${r}?._d ?? new Date(0), _offset: 0, _loc: null, _ns: ${r}?._ns || 0})`,
+	Local: (r) =>
+		`({_d: ${r}?._d ?? new Date(0), _offset: undefined, _loc: null, _ns: ${r}?._ns || 0})`,
+	AddDate: (r, a) => `__timeAddDate(${r}, ${a[0]}, ${a[1]}, ${a[2]})`,
+	Truncate: (r, a) => `__timeTruncate(${r}, ${a[0]})`,
+	Round: (r, a) => `__timeRound(${r}, ${a[0]})`,
+	Date: (r) => `__timeDate(${r})`,
+	Clock: (r) => `__timeClock(${r})`,
+	YearDay: (r) => `__timeYearDay(${r})`,
 	Compare: (r, a) =>
-		`(${r}._d.getTime() < (${a[0]})._d.getTime() ? -1 : (${r}._d.getTime() > (${a[0]})._d.getTime() ? 1 : 0))`,
-	In: (r) => `${r}`,
-	Location: () => `null`,
+		`(${r}._d.getTime() < (${a[0]})._d.getTime() ? -1 : (${r}._d.getTime() > (${a[0]})._d.getTime() ? 1 : ((${r}._ns || 0) < ((${a[0]})._ns || 0) ? -1 : ((${r}._ns || 0) > ((${a[0]})._ns || 0) ? 1 : 0))))`,
+	ISOWeek: (r) => `__timeISOWeek(${r})`,
+	In: (r, a) =>
+		`((() => { const _loc = ${a[0]}; const _off = _loc && typeof _loc._offset === "number" ? _loc._offset : 0; return { _d: ${r}._d, _offset: _off, _loc, _ns: ${r}._ns }; })())`,
+	Location: (r) =>
+		`(${r}._loc ?? (${r}._offset === 0 ? { _name: "UTC", _offset: 0, String() { return "UTC"; } } : { _name: "Local", _offset: -${r}._d.getTimezoneOffset() * 60, String() { return "Local"; } }))`,
 	Zone: (r) =>
-		`[${r}._offset === 0 ? "UTC" : "LOCAL", ${r}._offset === 0 ? 0 : -${r}._d.getTimezoneOffset() * 60]`,
+		`[${r}._loc ? ${r}._loc._name : (${r}._offset === 0 ? "UTC" : "LOCAL"), ${r}._loc ? ${r}._loc._offset : (${r}._offset === 0 ? 0 : -${r}._d.getTimezoneOffset() * 60)]`,
+	MarshalJSON: (r) => `__timeMarshalJSON(${r})`,
+	UnmarshalJSON: (r, a) => `__timeUnmarshalJSON(${r}, ${a[0]})`,
+	MarshalText: (r) => `__timeMarshalText(${r})`,
+	UnmarshalText: (r, a) => `__timeUnmarshalText(${r}, ${a[0]})`,
 };
 
 const DURATION_METHOD_DISPATCH = {
@@ -60,6 +59,9 @@ const DURATION_METHOD_DISPATCH = {
 	Minutes: (r) => `(Number(${r}) / 60000000000)`,
 	Hours: (r) => `(Number(${r}) / 3600000000000)`,
 	String: (r) => `__durationString(${r})`,
+	Truncate: (r, a) => `(${a[0]} <= 0 ? ${r} : ${r} - (${r} % ${a[0]}))`,
+	Round: (r, a) => `__durationRound(${r}, ${a[0]})`,
+	Abs: (r) => `(${r} >= 0 ? ${r} : -(${r}))`,
 };
 
 const TIME_DISPATCH = {
@@ -69,11 +71,16 @@ const TIME_DISPATCH = {
 		`(Math.round(((typeof globalThis.__GOFRONT_CLOCK === "function" ? globalThis.__GOFRONT_CLOCK() : Date.now()) - (${a[0]})._d.getTime()) * 1000000))`,
 	Sleep: (a) => `await new Promise(r => setTimeout(r, ${a[0]} / 1000000))`,
 	Unix: (a) =>
-		`{_d: new Date(Number(${a[0]}) * 1000 + Math.round(Number(${a[1] || 0}) / 1000000))}`,
-	UnixMicro: (a) => `{_d: new Date(Math.round(Number(${a[0]}) / 1000))}`,
+		`{_d: new Date(Number(${a[0]}) * 1000 + Math.round(Number(${a[1] || 0}) / 1000000)), _ns: Math.round(Number(${a[1] || 0}) % 1000000)}`,
+	UnixMicro: (a) =>
+		`{_d: new Date(Math.round(Number(${a[0]}) / 1000)), _ns: Math.round((Number(${a[0]}) % 1000) * 1000)}`,
 	UnixMilli: (a) => `{_d: new Date(Number(${a[0]}))}`,
 	Date: (a) =>
-		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, Math.round(Number(${a[6] || 0}) / 1000000))}`,
+		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, Math.round(Number(${a[6] || 0}) / 1000000)), _ns: Math.round(Number(${a[6] || 0}) % 1000000)}`,
+	ParseDuration: (a) => `__timeParseDuration(${a[0]})`,
+	FixedZone: (a) =>
+		`({ _name: ${a[0]}, _offset: ${a[1]}, String() { return this._name; } })`,
+	AfterFunc: (a) => `__timeAfterFunc(${a[0]}, ${a[1]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
@@ -82,12 +89,13 @@ export const timeMethods = {
 		const recv = expr.func.expr;
 		const recvJs = this.genExpr(recv);
 		const args = expr.args.map((a) => this.genExpr(a));
+		this.useHelper("timeFmt");
+		this.useHelper("duration");
+		this.useHelper("timeParse");
 		if (method === "Format") {
-			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}, ${args[0]})`;
 		}
 		if (method === "String") {
-			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}, "2006-01-02 15:04:05.999999999 -0700 MST")`;
 		}
 		const gen = TIME_METHOD_DISPATCH[method];
@@ -97,30 +105,46 @@ export const timeMethods = {
 	_genDurationMethodCall(method, expr) {
 		const recv = expr.func.expr;
 		const recvJs = this.genExpr(recv);
-		if (method === "String") {
-			this.useHelper("duration");
-		}
+		const args = expr.args.map((a) => this.genExpr(a));
+		this.useHelper("duration");
 		const gen = DURATION_METHOD_DISPATCH[method];
-		return gen ? gen(recvJs) : undefined;
+		return gen ? gen(recvJs, args) : undefined;
+	},
+
+	_genTimeDate(args, expr) {
+		this.useHelper("timeFmt");
+		const locArg = expr?.args?.[7];
+		const isUtc =
+			(locArg?.kind === "SelectorExpr" &&
+				(locArg.sel?.name === "UTC" || locArg.field === "UTC")) ||
+			(locArg?.kind === "Ident" && locArg.name === "UTC") ||
+			args[7] === '"UTC"';
+		if (isUtc) {
+			return `{_d: new Date(Date.UTC(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]}, Math.floor(Number(${args[6] || 0}) / 1000000))), _offset: 0, _loc: null, _ns: Math.floor(Number(${args[6] || 0}) % 1000000)}`;
+		}
+		return `((() => { const _loc = ${args[7]}; const _off = _loc && typeof _loc._offset === "number" ? _loc._offset : undefined; const _ms = Math.floor(Number(${args[6] || 0}) / 1000000); const _remNs = Math.floor(Number(${args[6] || 0}) % 1000000); if (_off !== undefined) { const _d = new Date(Date.UTC(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]}, _ms) - _off * 1000); return { _d, _offset: _off, _loc, _ns: _remNs }; } return { _d: new Date(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]}, _ms), _offset: undefined, _loc: null, _ns: _remNs }; })())`;
 	},
 
 	_genTime(fn, a, expr) {
+		if (fn === "Date") return this._genTimeDate(a(), expr);
 		if (fn === "Parse") {
 			this.useHelper("timeParse");
+			this.useHelper("timeFmt");
 			return `__timeParse(${a()[0]}, ${a()[1]})`;
 		}
-		if (fn === "Date") {
+		if (fn === "ParseDuration") {
+			this.useHelper("duration");
+			return `__timeParseDuration(${a()[0]})`;
+		}
+		if (fn === "FixedZone") {
+			this.useHelper("timeFmt");
+			const args = a();
+			return `({ _name: ${args[0]}, _offset: ${args[1]}, String() { return this._name; } })`;
+		}
+		if (fn === "AfterFunc") {
+			this.useHelper("timeFmt");
 			const args = a();
-			const locArg = expr?.args?.[7];
-			const isUtc =
-				(locArg?.kind === "SelectorExpr" &&
-					(locArg.sel?.name === "UTC" || locArg.field === "UTC")) ||
-				(locArg?.kind === "Ident" && locArg.name === "UTC") ||
-				args[7] === '"UTC"';
-			if (isUtc) {
-				return `{_d: new Date(Date.UTC(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]}, Math.round(Number(${args[6] || 0}) / 1000000))), _offset: 0}`;
-			}
-			return `{_d: new Date(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]}, Math.round(Number(${args[6] || 0}) / 1000000))}`;
+			return `__timeAfterFunc(${args[0]}, ${args[1]})`;
 		}
 		const gen = TIME_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;

package/src/backend/js/stdlib/unicode.js

@@ -10,7 +10,7 @@ export const unicodeMethods = {
 		const UNICODE_TEST = {
 			IsLetter: `/\\p{L}/u.test(${cp})`,
 			IsDigit: `/\\p{Nd}/u.test(${cp})`,
-			IsSpace: `/\\s/.test(${cp})`,
+			IsSpace: `/[ \\t\\n\\v\\f\\r\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/.test(${cp})`,
 			IsUpper: `/\\p{Lu}/u.test(${cp})`,
 			IsLower: `/\\p{Ll}/u.test(${cp})`,
 			IsPunct: `/\\p{P}/u.test(${cp})`,

package/src/backend/js/stdlib/utf8.js

@@ -9,7 +9,7 @@ const UTF8_DISPATCH = {
 	ValidString: (a) =>
 		`/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/.test(${a[0]}) === false`,
 	ValidRune: (a) =>
-		`(${a[0]}) >= 0 && (${a[0]}) <= 0x10FFFF && !((${a[0]}) >= 0xD800 && (${a[0]}) <= 0xDFFF)`,
+		`((${a[0]}) >= 0 && (${a[0]}) <= 0x10FFFF && !((${a[0]}) >= 0xD800 && (${a[0]}) <= 0xDFFF))`,
 	DecodeRuneInString: (a) =>
 		`((s) => { if (!s) return [0xFFFD, 0]; const cp = s.codePointAt(0); return [cp, cp > 0xFFFF ? 2 : 1]; })(${a[0]})`,
 	DecodeLastRuneInString: (a) =>

package/src/backend/js/templ.js

@@ -2,9 +2,6 @@
 // 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";
-
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
 /** @type {ThisType<CodeGen>} */
@@ -17,6 +14,12 @@ export const templGenMethods = {
 			.join(", ");
 		this.line(`function ${decl.name}(${params}) {`);
 		this.indented(() => {
+			// `@W(xs...)` passes `{ __sp: xs }` like any Go variadic call.
+			const last = decl.params[decl.params.length - 1];
+			if (last?.variadic && last.name && last.name !== "_") {
+				this.useHelper("va");
+				this.line(`${last.name} = __va(${last.name});`);
+			}
 			this.line(`return {Mount(___p, ___refs) {`);
 			this.indented(() => {
 				this._genTemplNodes(decl.body, "___p");
@@ -79,7 +82,7 @@ export const templGenMethods = {
 				);
 			case "TemplExpr":
 				return this.line(
-					`${p}.appendChild(document.createTextNode(String(${this._genTemplTokenExpr(node.tokens)})));`,
+					`${p}.appendChild(document.createTextNode(String(${this._genTemplExpr(node, '""')})));`,
 				);
 			case "TemplComponent":
 				return this._genTemplComponentMount(node, p);
@@ -101,20 +104,12 @@ export const templGenMethods = {
 
 	_genTemplComponentMount(node, p) {
 		// Special case: @templ.Raw(expr) → insertAdjacentHTML
-		const toks = node.tokens;
-		if (
-			toks.length >= 4 &&
-			toks[0]?.value === "templ" &&
-			toks[1]?.type === T.DOT &&
-			toks[2]?.value === "Raw" &&
-			toks[3]?.type === T.LPAREN
-		) {
-			const argTokens = toks.slice(4, toks.length - 1);
-			const argJs = this._genTemplTokenExpr(argTokens);
+		if (node.raw) {
+			const argJs = this._genTemplExpr(node, '""');
 			return this.line(`${p}.insertAdjacentHTML("beforeend", ${argJs});`);
 		}
 		return this.line(
-			`(${this._genTemplTokenCallExpr(node.tokens)}).Mount(${p}, ___refs);`,
+			`(${this._genTemplExpr(node, "null")}).Mount(${p}, ___refs);`,
 		);
 	},
 
@@ -160,7 +155,7 @@ export const templGenMethods = {
 				);
 			}
 		} else if (attr.kind === "expr") {
-			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			const exprJs = this._genTemplExpr(attr, '""');
 			if (name === "class") {
 				this.line(setClass(exprJs));
 			} else {
@@ -171,7 +166,7 @@ export const templGenMethods = {
 		} else if (attr.kind === "bool") {
 			this.line(`${el}.setAttribute(${JSON.stringify(name)}, "");`);
 		} else if (attr.kind === "cond-bool") {
-			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			const exprJs = this._genTemplExpr(attr, '""');
 			this.line(
 				`if(${exprJs})${el}.setAttribute(${JSON.stringify(name)}, "");`,
 			);
@@ -179,7 +174,7 @@ export const templGenMethods = {
 	},
 
 	_genTemplIf(node, p) {
-		const condJs = this._genTemplCondTokens(node.condTokens);
+		const condJs = this._genTemplExpr(node, "false");
 		this.line(`if (${condJs}) {`);
 		this.indented(() => this._genTemplNodes(node.then, p));
 		this._genTemplIfElse(node.else_, p);
@@ -192,7 +187,7 @@ export const templGenMethods = {
 		}
 		if (else_.length === 1 && else_[0].kind === "TemplIf") {
 			const elseIf = else_[0];
-			this.line(`} else if (${this._genTemplCondTokens(elseIf.condTokens)}) {`);
+			this.line(`} else if (${this._genTemplExpr(elseIf, "false")}) {`);
 			this.indented(() => this._genTemplNodes(elseIf.then, p));
 			this._genTemplIfElse(elseIf.else_, p);
 		} else {
@@ -203,16 +198,16 @@ export const templGenMethods = {
 	},
 
 	_genTemplSwitch(node, p) {
-		const { exprTokens, cases } = node;
+		const { cases } = node;
 		if (cases.length === 0) return;
-		const exprJs = this._genTemplTokenExpr(exprTokens);
+		const exprJs = this._genTemplExpr(node, '""');
 		this.line(`switch (${exprJs}) {`);
 		this.indented(() => {
 			for (const c of cases) {
 				const label =
 					c.caseTokens === null
 						? "default"
-						: `case ${this._genTemplTokenExpr(c.caseTokens)}`;
+						: `case ${this._genTemplExpr(c, '""')}`;
 				this.line(`${label}: {`);
 				this.indented(() => this._genTemplNodes(c.body, p));
 				this.line(`break; }`);
@@ -222,35 +217,10 @@ export const templGenMethods = {
 	},
 
 	_genTemplFor(node, p) {
-		// stmtTokens include the `for` keyword plus the range clause (no body).
-		// Strip any trailing semicolons (inserted by the Go lexer on newlines),
-		// then add a fake empty body `{ }` so the parser can complete the ForStmt.
-		let tokens = node.stmtTokens;
-		while (tokens.length > 0 && tokens[tokens.length - 1].type === T.SEMICOLON)
-			tokens = tokens.slice(0, -1);
-		const eofTok = new Token(T.EOF, "", 1, 1);
-		const lbrace = new Token(T.LBRACE, "{", 1, 1);
-		const rbrace = new Token(T.RBRACE, "}", 1, 1);
-		const semi = new Token(T.SEMICOLON, ";", 1, 1);
-		const withFor =
-			tokens[0]?.type === T.FOR
-				? [...tokens, lbrace, rbrace, semi, eofTok]
-				: [
-						new Token(T.FOR, "for", 1, 1),
-						...tokens,
-						lbrace,
-						rbrace,
-						semi,
-						eofTok,
-					];
-		try {
-			const p2 = new Parser(withFor);
-			const forStmt = p2.parseFor();
-			this._genTemplRangeFor(forStmt, node.body, p);
-		} catch {
-			// Fallback for non-range loops: emit a comment + skip
-			this.line(`/* templ for: ${this._tokensToSource(tokens)} */`);
-		}
+		if (node.forError) throw node.forError;
+		if (!node.forStmt)
+			throw new Error("templ for header was not parsed by TemplParser");
+		this._genTemplRangeFor(node.forStmt, node.body, p);
 	},
 
 	_genTemplRangeFor(forStmt, templBody, mountParent) {
@@ -290,37 +260,29 @@ export const templGenMethods = {
 		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
 	},
 
-	// Parse a token array as a Go expression and emit JS.
-	_genTemplTokenExpr(tokens) {
-		if (!tokens || tokens.length === 0) return '""';
-		const eofTok = new Token(T.EOF, "", 1, 1);
-		const p = new Parser([...tokens, eofTok]);
-		const ast = p.parseExpr();
-		return this.genExpr(ast);
+	// Emit JS for the Go expression TemplParser parsed onto `node`. `emptyJs` is
+	// the value when the node holds no tokens. A parse error is raised here,
+	// not in the parser, so it surfaces at the same point as it always did.
+	_genTemplExpr(node, emptyJs) {
+		if (node.exprError) throw node.exprError;
+		if (node.expr === undefined)
+			throw new Error("templ expression was not parsed by TemplParser");
+		return node.expr ? this.genExpr(node.expr) : emptyJs;
 	},
 
-	// Parse a token array as a Go call expression and emit JS.
-	_genTemplTokenCallExpr(tokens) {
-		if (!tokens || tokens.length === 0) return "null";
-		const eofTok = new Token(T.EOF, "", 1, 1);
-		const p = new Parser([...tokens, eofTok]);
-		const ast = p.parseExpr();
-		return this.genExpr(ast);
+	// Rename handlers for `_renameReservedIdents`: templ bodies keep their Go
+	// expressions in non-enumerable props (see parser/templ.js), which its
+	// generic walk does not visit, so `class` in `{ class }` would stay unsafe.
+	_renameTemplExprNode(node) {
+		this._renameReservedIdents(node.expr);
 	},
 
-	// Extract condition JS from condTokens (which may start with `if`).
-	_genTemplCondTokens(tokens) {
-		if (!tokens || tokens.length === 0) return "false";
-		let toks = tokens;
-		if (toks[0]?.type === T.IF) toks = toks.slice(1); // skip `if` keyword
-		const eofTok = new Token(T.EOF, "", 1, 1);
-		const p = new Parser([...toks, eofTok]);
-		const ast = p.parseExpr();
-		return this.genExpr(ast);
+	_renameTemplForNode(node) {
+		this._renameReservedIdents(node.forStmt);
 	},
 
-	_tokensToSource(tokens) {
-		return tokens.map((t) => t.value).join(" ");
+	_renameTemplElementNode(node) {
+		for (const attr of node.attrs ?? []) this._renameReservedIdents(attr.expr);
 	},
 
 	// Fresh variable name counter