gofront 1.6.1 → 1.8.0

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

@@ -3,37 +3,110 @@
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
+function toBig64(x) {
+	const trimmed = String(x).trim();
+	if (/^-?(0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|\d+)n?$/.test(trimmed)) {
+		return trimmed.endsWith("n") ? trimmed : `${trimmed}n`;
+	}
+	return `BigInt(${x})`;
+}
+
 const BITS_MAP = {
+	Add32: ([x, y, c]) =>
+		`((() => { const s = BigInt((${x}) >>> 0) + BigInt((${y}) >>> 0) + BigInt((${c}) >>> 0); return [Number(s & 0xffffffffn), Number(s >> 32n)]; })())`,
+	Add64: ([x, y, c]) =>
+		`((() => { const s = BigInt.asUintN(64, ${toBig64(x)}) + BigInt.asUintN(64, ${toBig64(y)}) + BigInt.asUintN(64, ${toBig64(c)}); return [Number(BigInt.asUintN(64, s)), Number(s >> 64n)]; })())`,
+	Add: (args) => BITS_MAP.Add64(args),
+
+	Sub32: ([x, y, b]) =>
+		`((() => { const diff = BigInt((${x}) >>> 0) - BigInt((${y}) >>> 0) - BigInt((${b}) >>> 0); return [Number(BigInt.asUintN(32, diff)), diff < 0n ? 1 : 0]; })())`,
+	Sub64: ([x, y, b]) =>
+		`((() => { const diff = BigInt.asUintN(64, ${toBig64(x)}) - BigInt.asUintN(64, ${toBig64(y)}) - BigInt.asUintN(64, ${toBig64(b)}); return [Number(BigInt.asUintN(64, diff)), diff < 0n ? 1 : 0]; })())`,
+	Sub: (args) => BITS_MAP.Sub64(args),
+
+	Mul32: ([x, y]) =>
+		`((() => { const p = BigInt((${x}) >>> 0) * BigInt((${y}) >>> 0); return [Number(p >> 32n), Number(p & 0xffffffffn)]; })())`,
+	Mul64: ([x, y]) =>
+		`((() => { const xB = BigInt.asUintN(64, ${toBig64(x)}); const yB = BigInt.asUintN(64, ${toBig64(y)}); const mask32 = 0xffffffffn; const x0 = xB & mask32, x1 = xB >> 32n; const y0 = yB & mask32, y1 = yB >> 32n; const w0 = x0 * y0; const t = x1 * y0 + (w0 >> 32n); const w1 = (t & mask32) + x0 * y1; const hi = x1 * y1 + (t >> 32n) + (w1 >> 32n); const lo = BigInt.asUintN(64, xB * yB); return [Number(hi), Number(lo)]; })())`,
+	Mul: (args) => BITS_MAP.Mul64(args),
+
+	Div32: ([hi, lo, y]) =>
+		`((() => { const yu = (${y}) >>> 0; if (yu === 0) throw new Error("runtime error: integer divide by zero"); const hiu = (${hi}) >>> 0; if (hiu >= yu) throw new Error("runtime error: integer overflow"); const z = (BigInt(hiu) << 32n) | BigInt((${lo}) >>> 0); const yB = BigInt(yu); return [Number(z / yB), Number(z % yB)]; })())`,
+	Div64: ([hi, lo, y]) =>
+		`((() => { const yB = BigInt.asUintN(64, ${toBig64(y)}); if (yB === 0n) throw new Error("runtime error: integer divide by zero"); const hiB = BigInt.asUintN(64, ${toBig64(hi)}); if (hiB >= yB) throw new Error("runtime error: integer overflow"); const loB = BigInt.asUintN(64, ${toBig64(lo)}); const z = (hiB << 64n) | loB; return [Number(BigInt.asUintN(64, z / yB)), Number(BigInt.asUintN(64, z % yB))]; })())`,
+	Div: (args) => BITS_MAP.Div64(args),
+
+	Rem32: ([hi, lo, y]) =>
+		`((() => { const yu = (${y}) >>> 0; if (yu === 0) throw new Error("runtime error: integer divide by zero"); const z = (BigInt((${hi}) >>> 0) << 32n) | BigInt((${lo}) >>> 0); return Number(z % BigInt(yu)); })())`,
+	Rem64: ([hi, lo, y]) =>
+		`((() => { const yB = BigInt.asUintN(64, ${toBig64(y)}); if (yB === 0n) throw new Error("runtime error: integer divide by zero"); const z = ((BigInt.asUintN(64, ${toBig64(hi)}) % yB) << 64n) | BigInt.asUintN(64, ${toBig64(lo)}); return Number(BigInt.asUintN(64, z % yB)); })())`,
+	Rem: (args) => BITS_MAP.Rem64(args),
+
+	LeadingZeros8: ([x]) =>
+		`((() => { const v = (${x}) & 0xff; return v === 0 ? 8 : Math.clz32(v) - 24; })())`,
+	LeadingZeros16: ([x]) =>
+		`((() => { const v = (${x}) & 0xffff; return v === 0 ? 16 : Math.clz32(v) - 16; })())`,
 	LeadingZeros32: ([x]) => `Math.clz32((${x}) >>> 0)`,
+	LeadingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, ${toBig64(x)}); if (v === 0n) return 64; const hi = Number(v >> 32n); return hi !== 0 ? Math.clz32(hi) : 32 + Math.clz32(Number(v & 0xffffffffn)); })())`,
+	LeadingZeros: (args) => BITS_MAP.LeadingZeros64(args),
+
+	TrailingZeros8: ([x]) =>
+		`((() => { const v = (${x}) & 0xff; return v === 0 ? 8 : 31 - Math.clz32(v & -v); })())`,
+	TrailingZeros16: ([x]) =>
+		`((() => { const v = (${x}) & 0xffff; return v === 0 ? 16 : 31 - Math.clz32(v & -v); })())`,
 	TrailingZeros32: ([x]) =>
 		`((() => { const v = (${x}) >>> 0; return v === 0 ? 32 : 31 - Math.clz32(v & -v); })())`,
+	TrailingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, ${toBig64(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)); })())`,
+	TrailingZeros: (args) => BITS_MAP.TrailingZeros64(args),
+
+	OnesCount8: ([x]) =>
+		`((() => { let v = (${x}) & 0xff; v = v - ((v >>> 1) & 0x55); v = (v & 0x33) + ((v >>> 2) & 0x33); return (v + (v >>> 4)) & 0x0f; })())`,
+	OnesCount16: ([x]) =>
+		`((() => { let v = (${x}) & 0xffff; v = v - ((v >>> 1) & 0x5555); v = (v & 0x3333) + ((v >>> 2) & 0x3333); return ((Math.imul((v + (v >>> 4)) & 0x0f0f, 0x0101)) >>> 8) & 0xff; })())`,
 	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; })())`,
+	OnesCount64: ([x]) =>
+		`((() => { let v = BigInt.asUintN(64, ${toBig64(x)}); let c = 0; while (v > 0n) { if (v & 1n) c++; v >>= 1n; } return c; })())`,
+	OnesCount: (args) => BITS_MAP.OnesCount64(args),
+
+	RotateLeft8: ([x, k]) =>
+		`((() => { const s = (${k}) & 7; const v = (${x}) & 0xff; return ((v << s) | (v >>> ((8 - s) & 7))) & 0xff; })())`,
+	RotateLeft16: ([x, k]) =>
+		`((() => { const s = (${k}) & 15; const v = (${x}) & 0xffff; return ((v << s) | (v >>> ((16 - s) & 15))) & 0xffff; })())`,
 	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 Number(BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n)))); })())`,
+		`((() => { const s = ${toBig64(k)} & 63n; const v = BigInt.asUintN(64, ${toBig64(x)}); return Number(BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n)))); })())`,
+	RotateLeft: (args) => BITS_MAP.RotateLeft64(args),
 
+	Len8: ([x]) =>
+		`((() => { const v = (${x}) & 0xff; return v === 0 ? 0 : 32 - Math.clz32(v); })())`,
+	Len16: ([x]) =>
+		`((() => { const v = (${x}) & 0xffff; return v === 0 ? 0 : 32 - Math.clz32(v); })())`,
 	Len32: ([x]) => `((v => 32 - Math.clz32(v >>> 0))(${x}))`,
 	Len64: ([x]) =>
-		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 0; const hi = Number(v >> 32n); return hi !== 0 ? 64 - Math.clz32(hi) : 32 - Math.clz32(Number(v & 0xffffffffn)); })())`,
+		`((() => { const v = BigInt.asUintN(64, ${toBig64(x)}); if (v === 0n) return 0; const hi = Number(v >> 32n); return hi !== 0 ? 64 - Math.clz32(hi) : 32 - Math.clz32(Number(v & 0xffffffffn)); })())`,
+	Len: (args) => BITS_MAP.Len64(args),
+
+	Reverse8: ([x]) =>
+		`((() => { let v = (${x}) & 0xff; v = ((v >>> 1) & 0x55) | ((v & 0x55) << 1); v = ((v >>> 2) & 0x33) | ((v & 0x33) << 2); return (((v >>> 4) & 0x0f) | ((v & 0x0f) << 4)) & 0xff; })())`,
+	Reverse16: ([x]) =>
+		`((() => { let v = (${x}) & 0xffff; v = ((v >>> 1) & 0x5555) | ((v & 0x5555) << 1); v = ((v >>> 2) & 0x3333) | ((v & 0x3333) << 2); v = ((v >>> 4) & 0x0f0f) | ((v & 0x0f0f) << 4); return (((v >>> 8) & 0x00ff) | ((v & 0x00ff) << 8)) & 0xffff; })())`,
+	Reverse32: ([x]) =>
+		`((() => { let v = (${x}) >>> 0; v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; })())`,
+	Reverse64: ([x]) =>
+		`((() => { const rev32 = (v) => { v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; }; const v = BigInt.asUintN(64, ${toBig64(x)}); const lo = Number(v & 0xffffffffn); const hi = Number((v >> 32n) & 0xffffffffn); return Number((BigInt(rev32(lo)) << 32n) | BigInt(rev32(hi))); })())`,
+	Reverse: (args) => BITS_MAP.Reverse64(args),
+
 	ReverseBytes16: ([x]) =>
 		`((v => ((v & 0xff) << 8) | ((v >>> 8) & 0xff))((${x}) & 0xffff))`,
 	ReverseBytes32: ([x]) =>
 		`((v => (((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v >>> 8) & 0xff00) | ((v >>> 24) & 0xff)) >>> 0)((${x}) >>> 0))`,
 	ReverseBytes64: ([x]) =>
-		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); let r = 0n; for (let i = 0n; i < 8n; i++) r = (r << 8n) | ((v >> (i * 8n)) & 0xffn); return Number(r); })())`,
-	Reverse32: ([x]) =>
-		`((() => { let v = (${x}) >>> 0; v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; })())`,
-	Reverse64: ([x]) =>
-		`((() => { const rev32 = (v) => { v = ((v >>> 1) & 0x55555555) | ((v & 0x55555555) << 1); v = ((v >>> 2) & 0x33333333) | ((v & 0x33333333) << 2); v = ((v >>> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4); v = ((v >>> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8); return ((v >>> 16) | (v << 16)) >>> 0; }; const v = BigInt.asUintN(64, BigInt(${x})); const lo = Number(v & 0xffffffffn); const hi = Number((v >> 32n) & 0xffffffffn); return Number((BigInt(rev32(lo)) << 32n) | BigInt(rev32(hi))); })())`,
+		`((() => { const v = BigInt.asUintN(64, ${toBig64(x)}); let r = 0n; for (let i = 0n; i < 8n; i++) r = (r << 8n) | ((v >> (i * 8n)) & 0xffn); return Number(r); })())`,
+	ReverseBytes: (args) => BITS_MAP.ReverseBytes64(args),
 };
 
 /** @type {ThisType<CodeGen>} */

package/src/backend/js/stdlib/builder.js

@@ -20,16 +20,41 @@ const BUILDER_STR = {
 };
 const BUILDER_BYTES = {
 	WriteString: (b, a) =>
-		`((buf, s) => { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
-	WriteByte: (b, a) => `(${b}._buf.push(${a[0]}), null)`,
+		`((buf, s) => { buf._lastOp = 0; const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
+	WriteByte: (b, a) =>
+		`((buf, c) => { buf._lastOp = 0; buf._buf.push(c); return null; })(${b}, ${a[0]})`,
 	WriteRune: (b, a) =>
-		`((buf, cp) => { const r = (cp < 0 || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) ? 0xfffd : cp; const bytes = new TextEncoder().encode(String.fromCodePoint(r)); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
+		`((buf, cp) => { buf._lastOp = 0; const r = (cp < 0 || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) ? 0xfffd : cp; const bytes = new TextEncoder().encode(String.fromCodePoint(r)); for (let i = 0; i < bytes.length; i++) buf._buf.push(bytes[i]); return [bytes.length, null]; })(${b}, ${a[0]})`,
 	Write: (b, a) =>
-		`((buf, d) => { for (let i = 0; i < d.length; i++) buf._buf.push(d[i]); return [d.length, null]; })(${b}, ${a[0]})`,
+		`((buf, d) => { buf._lastOp = 0; for (let i = 0; i < d.length; i++) buf._buf.push(d[i]); return [d.length, null]; })(${b}, ${a[0]})`,
 	String: (b) => `new TextDecoder().decode(new Uint8Array(${b}._buf))`,
 	Reset: (b) => `(${b}._buf = [])`,
 	Read: (b, a) =>
-		`((buf, p) => { if (buf._buf.length === 0) return [0, __io_eof]; const n = Math.min(p.length, buf._buf.length); for (let i = 0; i < n; i++) p[i] = buf._buf.shift(); return [n, null]; })(${b}, ${a[0]})`,
+		`((buf, p) => { if (!buf._buf || buf._buf.length === 0) return [0, __io_eof]; const n = Math.min(p.length, buf._buf.length); for (let i = 0; i < n; i++) p[i] = buf._buf.shift(); if (n > 0) { buf._lastOp = 1; buf._lastByte = p[n - 1]; } else { buf._lastOp = 0; } return [n, null]; })(${b}, ${a[0]})`,
+	ReadByte: (b) =>
+		`((buf) => { if (!buf._buf || buf._buf.length === 0) return [0, __io_eof]; const c = buf._buf.shift(); buf._lastOp = 1; buf._lastByte = c; return [c, null]; })(${b})`,
+	UnreadByte: (b) =>
+		`((buf) => { if (buf._lastOp !== 1) return __error("bytes.Buffer: UnreadByte: previous operation was not a successful read"); buf._buf.unshift(buf._lastByte); buf._lastOp = 0; return null; })(${b})`,
+	ReadRune: (b) =>
+		`((buf) => { if (!buf._buf || buf._buf.length === 0) return [0, 0, __io_eof]; const u8 = new Uint8Array(buf._buf); const s = new TextDecoder().decode(u8); const cp = s.codePointAt(0); const runeStr = s.slice(0, cp > 0xffff ? 2 : 1); const sz = new TextEncoder().encode(runeStr).length; for (let i = 0; i < sz; i++) buf._buf.shift(); buf._lastOp = 2; buf._lastRune = runeStr; return [cp, sz, null]; })(${b})`,
+	UnreadRune: (b) =>
+		`((buf) => { if (buf._lastOp !== 2) return __error("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune"); const bts = new TextEncoder().encode(buf._lastRune); for (let i = bts.length - 1; i >= 0; i--) buf._buf.unshift(bts[i]); buf._lastOp = 0; return null; })(${b})`,
+	ReadBytes: (b, a) =>
+		`((buf, delim) => { const idx = buf._buf.indexOf(delim); if (idx < 0) { const rem = Uint8Array.from(buf._buf); buf._buf = []; return [rem, __io_eof]; } const line = Uint8Array.from(buf._buf.splice(0, idx + 1)); return [line, null]; })(${b}, ${a[0]})`,
+	ReadString: (b, a) =>
+		`((buf, delim) => { const idx = buf._buf.indexOf(delim); if (idx < 0) { const rem = new TextDecoder().decode(Uint8Array.from(buf._buf)); buf._buf = []; return [rem, __io_eof]; } const line = new TextDecoder().decode(Uint8Array.from(buf._buf.splice(0, idx + 1))); return [line, null]; })(${b}, ${a[0]})`,
+	ReadFrom: (b, a) =>
+		`((buf, r) => { let total = 0n; const tmp = new Uint8Array(4096); while (true) { const [n, err] = r.Read(tmp); if (n > 0) { for (let i = 0; i < n; i++) buf._buf.push(tmp[i]); total += BigInt(n); } if (err) { return [total, (err === __io_eof || err?.Error?.() === "EOF") ? null : err]; } } })(${b}, ${a[0]})`,
+	WriteTo: (b, a) =>
+		`((buf, w) => { if (!buf._buf || buf._buf.length === 0) return [0n, null]; const bytes = Uint8Array.from(buf._buf); const [n, err] = w.Write(bytes); if (n > 0) buf._buf.splice(0, n); return [BigInt(n), err]; })(${b}, ${a[0]})`,
+	Next: (b, a) =>
+		`((buf, n) => { const cnt = Math.min(Math.max(0, n), buf._buf.length); return Uint8Array.from(buf._buf.splice(0, cnt)); })(${b}, ${a[0]})`,
+	Truncate: (b, a) =>
+		`((buf, n) => { if (n < 0 || n > buf._buf.length) throw new Error("bytes.Buffer: truncation out of range"); buf._buf.length = n; })(${b}, ${a[0]})`,
+	Available: (b) => `Math.max(0, (${b}._cap ?? 0) - ${b}._buf.length)`,
+	AvailableBuffer: () => `new Uint8Array(0)`,
+	Peek: (b, a) =>
+		`((buf, n) => { if (n < 0) throw new Error("runtime error: slice bounds out of range"); if (n > buf._buf.length) return [Uint8Array.from(buf._buf), __io_eof]; return [Uint8Array.from(buf._buf.slice(0, n)), null]; })(${b}, ${a[0]})`,
 };
 const BUILDER_COMMON = {
 	Bytes: (b) => `new Uint8Array(${b}._buf)`,
@@ -45,7 +70,17 @@ export const builderMethods = {
 		const recv = expr.func.expr;
 		const base = this._unboxWriter(this.genExpr(recv));
 		const args = expr.args.map((a) => this.genExpr(a));
-		if (method === "Read") {
+		if (
+			method === "Read" ||
+			method === "ReadByte" ||
+			method === "ReadRune" ||
+			method === "ReadBytes" ||
+			method === "ReadString" ||
+			method === "ReadFrom" ||
+			method === "UnreadByte" ||
+			method === "UnreadRune" ||
+			method === "Peek"
+		) {
 			this.useHelper("ioEOF");
 			this.useHelper("error");
 		}

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

@@ -6,14 +6,100 @@ const __bs = `(b => typeof TextDecoder !== "undefined" ? new TextDecoder().decod
 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]}))`,
+	Contains: (a) =>
+		`((b, sep) => {
+			b = b || new Uint8Array(0);
+			sep = sep || new Uint8Array(0);
+			if (sep.length === 0) return true;
+			if (sep.length === 1) return (b.indexOf ? b.indexOf(sep[0]) : Array.prototype.indexOf.call(b, sep[0])) >= 0;
+			if (sep.length > b.length) return false;
+			const first = sep[0];
+			const last = sep[sep.length - 1];
+			let i = 0;
+			while (i <= b.length - sep.length) {
+				const idx = b.indexOf ? b.indexOf(first, i) : Array.prototype.indexOf.call(b, first, i);
+				if (idx < 0 || idx > b.length - sep.length) return false;
+				if (b[idx + sep.length - 1] === last) {
+					let match = true;
+					for (let j = 1; j < sep.length - 1; j++) {
+						if (b[idx + j] !== sep[j]) { match = false; break; }
+					}
+					if (match) return true;
+				}
+				i = idx + 1;
+			}
+			return false;
+		})(${a[0]}, ${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]}))`,
+	Index: (a) =>
+		`((b, sep) => {
+			b = b || new Uint8Array(0);
+			sep = sep || new Uint8Array(0);
+			const n = b.length;
+			const m = sep.length;
+			if (m === 0) return 0;
+			if (m === 1) return b.indexOf ? b.indexOf(sep[0]) : Array.prototype.indexOf.call(b, sep[0]);
+			if (m > n) return -1;
+			if (m === n) {
+				for (let k = 0; k < m; k++) if (b[k] !== sep[k]) return -1;
+				return 0;
+			}
+			const first = sep[0];
+			const last = sep[m - 1];
+			let i = 0;
+			while (i <= n - m) {
+				const idx = b.indexOf ? b.indexOf(first, i) : Array.prototype.indexOf.call(b, first, i);
+				if (idx < 0 || idx > n - m) return -1;
+				if (b[idx + m - 1] === last) {
+					let match = true;
+					for (let j = 1; j < m - 1; j++) {
+						if (b[idx + j] !== sep[j]) { match = false; break; }
+					}
+					if (match) return idx;
+				}
+				i = idx + 1;
+			}
+			return -1;
+		})(${a[0]}, ${a[1]})`,
 	Count: (a) =>
-		`((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${a[0]}, ${a[1]})`,
+		`((b, sep) => {
+			b = b || new Uint8Array(0);
+			sep = sep || new Uint8Array(0);
+			if (sep.length === 0) {
+				let runes = 0;
+				for (let i = 0; i < b.length; i++) if ((b[i] & 0xc0) !== 0x80) runes++;
+				return runes + 1;
+			}
+			let cnt = 0;
+			if (sep.length === 1) {
+				const c = sep[0];
+				for (let i = 0; i < b.length; i++) if (b[i] === c) cnt++;
+				return cnt;
+			}
+			let i = 0;
+			const first = sep[0];
+			const last = sep[sep.length - 1];
+			while (i <= b.length - sep.length) {
+				const idx = b.indexOf ? b.indexOf(first, i) : Array.prototype.indexOf.call(b, first, i);
+				if (idx < 0 || idx > b.length - sep.length) break;
+				if (b[idx + sep.length - 1] === last) {
+					let match = true;
+					for (let j = 1; j < sep.length - 1; j++) {
+						if (b[idx + j] !== sep[j]) { match = false; break; }
+					}
+					if (match) {
+						cnt++;
+						i = idx + sep.length;
+						continue;
+					}
+				}
+				i = idx + 1;
+			}
+			return cnt;
+		})(${a[0]}, ${a[1]})`,
 	Repeat: (a) => `${__sb}(${__bs}(${a[0]}).repeat(${a[1]}))`,
 	Replace: (a) =>
 		`((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]})`,
@@ -45,10 +131,38 @@ const BYTES_DISPATCH = {
 		`((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]})`,
+		`((b, sep) => {
+			b = b || new Uint8Array(0);
+			sep = sep || new Uint8Array(0);
+			const n = b.length;
+			const m = sep.length;
+			if (m === 0) return n;
+			if (m === 1) return b.lastIndexOf ? b.lastIndexOf(sep[0]) : Array.prototype.lastIndexOf.call(b, sep[0]);
+			if (m > n) return -1;
+			if (m === n) {
+				for (let k = 0; k < m; k++) if (b[k] !== sep[k]) return -1;
+				return 0;
+			}
+			const first = sep[0];
+			const last = sep[m - 1];
+			let i = n - m;
+			while (i >= 0) {
+				const idx = b.lastIndexOf ? b.lastIndexOf(first, i) : Array.prototype.lastIndexOf.call(b, first, i);
+				if (idx < 0) return -1;
+				if (b[idx + m - 1] === last) {
+					let match = true;
+					for (let j = 1; j < m - 1; j++) {
+						if (b[idx + j] !== sep[j]) { match = false; break; }
+					}
+					if (match) return idx;
+				}
+				i = idx - 1;
+			}
+			return -1;
+		})(${a[0]}, ${a[1]})`,
 	LastIndexByte: (a) => `(${a[0]}).lastIndexOf(${a[1]})`,
 	Fields: (a) =>
-		`((b) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => new TextEncoder().encode(w)); })(${a[0]})`,
+		`((b) => { const s = new TextDecoder().decode(new Uint8Array(b ?? [])); return s.split(/[ \\t\\n\\v\\f\\r\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]+/).filter(p => p !== "").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) =>
@@ -108,14 +222,146 @@ const BYTES_DISPATCH = {
 			r.push(b.slice(i));
 			return r;
 		})(${a[0]}, ${a[1]}, ${a[2]})`,
+	NewBuffer: (a) => `({ _buf: Array.from(${a[0]} ?? []) })`,
+	NewBufferString: (a) =>
+		`({ _buf: Array.from(new TextEncoder().encode(${a[0]} ?? "")) })`,
+	ToValidUTF8: (a) =>
+		`((b, repl) => {
+			if (!b) return new Uint8Array(0);
+			repl = repl || new Uint8Array(0);
+			const res = [];
+			let i = 0;
+			let inInvalid = false;
+			while (i < b.length) {
+				const b0 = b[i];
+				let sz = 0;
+				let valid = false;
+				if (b0 < 0x80) {
+					sz = 1;
+					valid = true;
+				} else if (b0 >= 0xC2 && b0 <= 0xDF) {
+					if (i + 1 < b.length && (b[i+1] & 0xC0) === 0x80) {
+						sz = 2;
+						valid = true;
+					}
+				} else if (b0 >= 0xE0 && b0 <= 0xEF) {
+					if (i + 2 < b.length && (b[i+1] & 0xC0) === 0x80 && (b[i+2] & 0xC0) === 0x80) {
+						const r = ((b0 & 0x0F) << 12) | ((b[i+1] & 0x3F) << 6) | (b[i+2] & 0x3F);
+						if (r >= 0x800 && (r < 0xD800 || r > 0xDFFF)) {
+							sz = 3;
+							valid = true;
+						}
+					}
+				} else if (b0 >= 0xF0 && b0 <= 0xF4) {
+					if (i + 3 < b.length && (b[i+1] & 0xC0) === 0x80 && (b[i+2] & 0xC0) === 0x80 && (b[i+3] & 0xC0) === 0x80) {
+						const r = ((b0 & 0x07) << 18) | ((b[i+1] & 0x3F) << 12) | ((b[i+2] & 0x3F) << 6) | (b[i+3] & 0x3F);
+						if (r >= 0x10000 && r <= 0x10FFFF) {
+							sz = 4;
+							valid = true;
+						}
+					}
+				}
+				if (valid) {
+					if (inInvalid) {
+						for (let k = 0; k < repl.length; k++) res.push(repl[k]);
+						inInvalid = false;
+					}
+					for (let k = 0; k < sz; k++) res.push(b[i + k]);
+					i += sz;
+				} else {
+					inInvalid = true;
+					i += 1;
+				}
+			}
+			if (inInvalid) {
+				for (let k = 0; k < repl.length; k++) res.push(repl[k]);
+			}
+			return new Uint8Array(res);
+		})(${a[0]}, ${a[1]})`,
 	NewReader: (a) =>
-		`((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]})`,
+		`((b) => ({
+			_src: b,
+			_pos: 0,
+			_prevRune: -1,
+			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;
+				this._prevRune = -1;
+				return [n, null];
+			},
+			ReadAt(p, off) {
+				const o = Number(off);
+				if (o < 0) return [0, __error("bytes.Reader.ReadAt: negative offset")];
+				if (o >= this._src.length) return [0, __io_eof];
+				const n = Math.min(p.length, this._src.length - o);
+				for (let i = 0; i < n; i++) p[i] = this._src[o + i];
+				return [n, n < p.length ? __io_eof : null];
+			},
+			ReadByte() {
+				if (this._pos >= this._src.length) return [0, __io_eof];
+				this._prevRune = -1;
+				return [this._src[this._pos++], null];
+			},
+			UnreadByte() {
+				if (this._pos <= 0) return __error("bytes.Reader.UnreadByte: at beginning of slice");
+				this._prevRune = -1;
+				this._pos--;
+				return null;
+			},
+			ReadRune() {
+				if (this._pos >= this._src.length) return [0, 0, __io_eof];
+				const rem = this._src.subarray ? this._src.subarray(this._pos) : new Uint8Array(this._src.slice(this._pos));
+				const s = new TextDecoder().decode(rem);
+				const cp = s.codePointAt(0);
+				const runeStr = s.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("bytes.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._src.length) + off;
+				else return [0n, __error("bytes.Reader.Seek: invalid whence")];
+				if (newPos < 0n) return [0n, __error("bytes.Reader.Seek: negative position")];
+				this._pos = Number(newPos);
+				this._prevRune = -1;
+				return [newPos, null];
+			},
+			Size() { return BigInt(this._src.length); },
+			WriteTo(w) {
+				if (this._pos >= this._src.length) return [0, null];
+				const rem = this._src.subarray ? this._src.subarray(this._pos) : new Uint8Array(this._src.slice(this._pos));
+				const [n, err] = w.Write(rem);
+				this._pos += n;
+				return [n, err];
+			},
+			Len() { return Math.max(0, this._src.length - this._pos); },
+			Reset(b2) { this._src = b2; this._pos = 0; this._prevRune = -1; }
+		}))(${a[0]})`,
 };
 
 /** @type {ThisType<CodeGen>} */
 export const bytesMethods = {
 	_genBytes(fn, a) {
-		if (fn === "NewReader") this.useHelper("ioEOF");
+		if (fn === "NewReader") {
+			this.useHelper("ioEOF");
+			this.useHelper("error");
+		}
 		const gen = BYTES_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

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

@@ -14,7 +14,8 @@ export const errorsMethods = {
 			this.useHelper("errorIs");
 			return `__errorIs(${args[0]}, ${args[1]})`;
 		}
-		if (fn === "Unwrap") return `(${args[0]}?._cause ?? null)`;
+		if (fn === "Unwrap")
+			return `((e) => typeof e?.Unwrap === "function" ? e.Unwrap() : (e?._cause ?? null))(${args[0]})`;
 		if (fn === "As") {
 			this.useHelper("errorAs");
 			const targetGoType = expr?.args?.[1]?._type;
@@ -24,6 +25,11 @@ export const errorsMethods = {
 			if (concreteGoType?.kind === "interface" || typeName === "error") {
 				return `__errorAs(${args[0]}, ${args[1]}, (x) => x !== null && (typeof x === "object" ? typeof x.Error === "function" : true))`;
 			}
+			// Named non-struct error types sit in interfaces as boxes; store the raw value.
+			const namedBox = this._namedBoxInfo(concreteGoType);
+			if (namedBox) {
+				return `__errorAs(${args[0]}, ${args[1]}, (x) => x instanceof ${namedBox.cls}, (x) => x.__gfUnbox())`;
+			}
 			if (typeName) {
 				return `__errorAs(${args[0]}, ${args[1]}, (x) => (typeof ${typeName} === "function" && x instanceof ${typeName}) || x?.constructor?.name === "${typeName}" || x?.__struct === "${typeName}")`;
 			}