gofront 0.0.9 → 1.0.1

package/src/codegen/stdlib/path.js

@@ -0,0 +1,34 @@
+// CodeGen for Go `path` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const PATH_DISPATCH = {
+	Base: (a) =>
+		`((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${a[0]})`,
+	Dir: (a) =>
+		`((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; if (i === 0) return "/"; return p.slice(0, i); })(${a[0]})`,
+	Ext: (a) =>
+		`((p) => { const b = p.slice(p.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); })(${a[0]})`,
+	IsAbs: (a) => `(${a[0]}).startsWith("/")`,
+	Split: (a) =>
+		`((p) => { const i = p.lastIndexOf("/"); return i < 0 ? ["", p] : [p.slice(0, i + 1), p.slice(i + 1)]; })(${a[0]})`,
+	Match: (a) =>
+		`((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${a[0]}, ${a[1]})`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const pathMethods = {
+	_genPath(fn, a, expr) {
+		if (fn === "Join") {
+			this._usesPathClean = true;
+			const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+			return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
+		}
+		if (fn === "Clean") {
+			this._usesPathClean = true;
+			return `__pathClean(${a()[0]})`;
+		}
+		const gen = PATH_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/rand.js

@@ -0,0 +1,27 @@
+// CodeGen for Go `math/rand` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const RAND_DISPATCH = {
+	Intn: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Int63n: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Int31n: (a) => `Math.floor(Math.random() * ${a[0]})`,
+	Float64: () => "Math.random()",
+	Float32: () => "Math.random()",
+	Int: () => "Math.floor(Math.random() * 2147483647)",
+	Int31: () => "Math.floor(Math.random() * 2147483647)",
+	Int63: () => "Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)",
+	Seed: () => "(void 0)",
+	Shuffle: (a) =>
+		`((n, f) => { for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${a[0]}, ${a[1]})`,
+	Perm: (a) =>
+		`((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const randMethods = {
+	_genRand(fn, a) {
+		const gen = RAND_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/regexp.js

@@ -0,0 +1,54 @@
+// CodeGen for Go `regexp` package and `*Regexp` methods.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const REGEXP_METHOD = {
+	MatchString: (re, a) => `${re}.test(${a[0]})`,
+	FindString: (re, a) => `(${re}.exec(${a[0]})?.[0] ?? "")`,
+	FindStringIndex: (re, a) =>
+		`((m => m ? [m.index, m.index + m[0].length] : null)(${re}.exec(${a[0]})))`,
+	FindAllString: (re, a) =>
+		`[...${a[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${a[1]} < 0 ? undefined : ${a[1]}).map(m => m[0])`,
+	FindStringSubmatch: (re, a) => `[...(${re}.exec(${a[0]}) ?? [])]`,
+	FindAllStringSubmatch: (re, a) =>
+		`[...${a[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${a[1]} < 0 ? undefined : ${a[1]}).map(m => [...m])`,
+	ReplaceAllString: (re, a) =>
+		`${a[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${a[1]})`,
+	ReplaceAllLiteralString: (re, a) =>
+		`${a[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${a[1]}.replace(/\\$/g, '$$$$'))`,
+	Split: (re, a) =>
+		`${a[0]}.split(${re}).slice(0, ${a[1]} < 0 ? undefined : ${a[1]})`,
+	String: (re) => `${re}.source`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const regexpMethods = {
+	_genRegexp(fn, a) {
+		// Converts a Go regexp pattern string (which may contain inline flags like (?i))
+		// into a JS RegExp, extracting the flags into the second constructor argument.
+		const makeRegExp = (pat) =>
+			`((p) => { const m = /^\\(\\?([gimsuy]+)\\)/.exec(p); return m ? new RegExp(p.slice(m[0].length), m[1]) : new RegExp(p); })(${pat})`;
+		switch (fn) {
+			case "MustCompile":
+				return makeRegExp(a()[0]);
+			case "Compile":
+				return `[${makeRegExp(a()[0])}, null]`;
+			case "MatchString": {
+				const [pat, s] = a();
+				return `[new RegExp(${pat}).test(${s}), null]`;
+			}
+			case "QuoteMeta":
+				return `${a()[0]}.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&')`;
+		}
+		return undefined;
+	},
+
+	_genRegexpMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		// *Regexp is a plain JS RegExp — no .value boxing needed
+		const re = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+		const gen = REGEXP_METHOD[method];
+		return gen ? gen(re, args) : undefined;
+	},
+};

package/src/codegen/stdlib/slices.js

@@ -0,0 +1,51 @@
+// CodeGen for Go `slices` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const SLICES_DISPATCH = {
+	Contains: (a) => `${a[0]}.includes(${a[1]})`,
+	Index: (a) => `${a[0]}.indexOf(${a[1]})`,
+	Compare: (a) =>
+		`((a, b) => { for (let i = 0; i < a.length && i < b.length; i++) { if (a[i] < b[i]) return -1; if (a[i] > b[i]) return 1; } return a.length - b.length; })(${a[0]}, ${a[1]})`,
+	Sort: (a) => `${a[0]}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`,
+	SortFunc: (a) => `${a[0]}.sort(${a[1]})`,
+	SortStableFunc: (a) => `${a[0]}.sort(${a[1]})`,
+	IsSorted: (a) =>
+		`((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${a[0]})`,
+	IsSortedFunc: (a) =>
+		`((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${a[0]}, ${a[1]})`,
+	Reverse: (a) => `${a[0]}.reverse()`,
+	Max: (a) => `Math.max(...${a[0]})`,
+	Min: (a) => `Math.min(...${a[0]})`,
+	MaxFunc: (a) =>
+		`((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${a[0]}, ${a[1]})`,
+	MinFunc: (a) =>
+		`((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${a[0]}, ${a[1]})`,
+	Clone: (a) => `${a[0]}.slice()`,
+	Compact: (a) =>
+		`((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${a[0]})`,
+	CompactFunc: (a) =>
+		`((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${a[0]}, ${a[1]})`,
+	Concat: (a) => `[].concat(${a.join(", ")})`,
+	Delete: (a) => `[...${a[0]}.slice(0, ${a[1]}), ...${a[0]}.slice(${a[2]})]`,
+	DeleteFunc: (a) => `${a[0]}.filter((v) => !${a[1]}(v))`,
+	Insert: (a) =>
+		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(2).join(", ")}, ...${a[0]}.slice(${a[1]})]`,
+	Replace: (a) =>
+		`[...${a[0]}.slice(0, ${a[1]}), ${a.slice(3).join(", ")}, ...${a[0]}.slice(${a[2]})]`,
+	Grow: (a) => `${a[0]}.slice()`,
+	Clip: (a) => `${a[0]}.slice()`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const slicesMethods = {
+	_genSlices(fn, a) {
+		if (fn === "Equal") {
+			this._usesEqual = true;
+			const [a1, b1] = a();
+			return `__equal(${a1}, ${b1})`;
+		}
+		const gen = SLICES_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/sort.js

@@ -0,0 +1,31 @@
+// CodeGen for Go `sort` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const SORT_DISPATCH = {
+	Ints: (a) => `${a[0]}.sort((a, b) => a - b)`,
+	Float64s: (a) => `${a[0]}.sort((a, b) => a - b)`,
+	Strings: (a) => `${a[0]}.sort()`,
+	Slice: (a) =>
+		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
+	SliceStable: (a) =>
+		`${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`,
+	SliceIsSorted: (a) =>
+		`${a[0]}.every((v, i, a) => i === 0 || ${a[1]}(a[i - 1], v))`,
+	Search: (a) =>
+		`((n, f) => { let lo = 0, hi = n; while (lo < hi) { const mid = (lo + hi) >>> 1; if (f(mid)) hi = mid; else lo = mid + 1; } return lo; })(${a[0]}, ${a[1]})`,
+	IntsAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+	Float64sAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+	StringsAreSorted: (a) =>
+		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const sortMethods = {
+	_genSort(fn, a) {
+		const gen = SORT_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/strconv.js

@@ -0,0 +1,33 @@
+// CodeGen for Go `strconv` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const STRCONV_DISPATCH = {
+	Itoa: (a) => `String(${a[0]})`,
+	Atoi: (a) =>
+		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}) | 0, null])`,
+	FormatBool: (a) => `String(${a[0]})`,
+	FormatInt: (a) => `(${a[0]}).toString(${a[1]})`,
+	FormatFloat: (a) => `String(${a[0]})`,
+	ParseFloat: (a) =>
+		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}), null])`,
+	ParseInt: (a) =>
+		`(Number.isNaN(parseInt(${a[0]}, ${a[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${a[0]}, ${a[1]} || 10), null])`,
+	ParseBool: (a) =>
+		`(${a[0]} === "true" || ${a[0]} === "1" ? [true, null] : ${a[0]} === "false" || ${a[0]} === "0" ? [false, null] : [false, "invalid syntax"])`,
+	Quote: (a) => `JSON.stringify(${a[0]})`,
+	Unquote: (a) =>
+		`((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", "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]}))]`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const strconvMethods = {
+	_genStrconv(fn, a) {
+		const gen = STRCONV_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/strings.js

@@ -0,0 +1,86 @@
+// CodeGen for Go `strings` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const STRINGS_M1 = {
+	ToUpper: "toUpperCase",
+	ToLower: "toLowerCase",
+	TrimSpace: "trim",
+	ToTitle: "toUpperCase",
+};
+const STRINGS_M2 = {
+	Contains: "includes",
+	HasPrefix: "startsWith",
+	HasSuffix: "endsWith",
+	Index: "indexOf",
+	LastIndex: "lastIndexOf",
+	Repeat: "repeat",
+	Split: "split",
+	Join: "join",
+};
+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})`,
+	ReplaceAll: ([s, s2, s3]) => `${s}.replaceAll(${s2}, ${s3})`,
+	Trim: ([s, s2]) =>
+		`${s}.replace(new RegExp(\`^[\${${s2}}]+|[\${${s2}}]+$\`, "g"), "")`,
+	TrimPrefix: ([s, s2]) =>
+		`((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${s}, ${s2})`,
+	TrimSuffix: ([s, s2]) =>
+		`((s, suf) => !suf.length || !s.endsWith(suf) ? s : s.slice(0, -suf.length))(${s}, ${s2})`,
+	TrimLeft: ([s, s2]) => `${s}.replace(new RegExp(\`^[\${${s2}}]+\`), "")`,
+	TrimRight: ([s, s2]) => `${s}.replace(new RegExp(\`[\${${s2}}]+$\`), "")`,
+	EqualFold: ([s, s2]) => `${s}.toLowerCase() === ${s2}.toLowerCase()`,
+	Fields: ([s]) => `(${s}).trim() === '' ? [] : (${s}).trim().split(/\\s+/)`,
+	Cut: ([s, s2]) =>
+		`((s, sep) => { const i = s.indexOf(sep); return i < 0 ? [s, "", false] : [s.slice(0, i), s.slice(i + sep.length), true]; })(${s}, ${s2})`,
+	CutPrefix: ([s, s2]) =>
+		`(${s}).startsWith(${s2}) ? [(${s}).slice((${s2}).length), true] : [${s}, false]`,
+	CutSuffix: ([s, s2]) =>
+		`(${s}).endsWith(${s2}) ? [(${s}).slice(0, -(${s2}).length), true] : [${s}, false]`,
+	SplitN: ([s, s2, s3]) =>
+		`((s, sep, n) => { if (n === 0) return []; if (n < 0) return s.split(sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${s}, ${s2}, ${s3})`,
+	SplitAfter: ([s, s2]) =>
+		`((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(${s}, ${s2})`,
+	SplitAfterN: ([s, s2, s3]) =>
+		`((s, sep, n) => { if (n === 0) return []; if (n < 0 || sep === "") return ((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(s, sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${s}, ${s2}, ${s3})`,
+	IndexAny: ([s, s2]) =>
+		`((s, chars) => { let m = -1; for (const c of chars) { const i = s.indexOf(c); if (i >= 0 && (m < 0 || i < m)) m = i; } return m; })(${s}, ${s2})`,
+	LastIndexAny: ([s, s2]) =>
+		`((s, chars) => { let m = -1; for (const c of chars) { const i = s.lastIndexOf(c); if (i > m) m = i; } return m; })(${s}, ${s2})`,
+	ContainsAny: ([s, s2]) => `[...(${s2})].some(c => (${s}).includes(c))`,
+	ContainsRune: ([s, s2]) => `(${s}).includes(String.fromCodePoint(${s2}))`,
+	IndexRune: ([s, s2]) => `(${s}).indexOf(String.fromCodePoint(${s2}))`,
+	IndexByte: ([s, s2]) => `(${s}).indexOf(String.fromCharCode(${s2}))`,
+	LastIndexByte: ([s, s2]) => `(${s}).lastIndexOf(String.fromCharCode(${s2}))`,
+	Map: ([s, s2]) =>
+		`[...(${s2})].map(c => String.fromCodePoint((${s})(c.codePointAt(0)))).join("")`,
+	Title: ([s]) => `(${s}).replace(/\\b\\w/g, c => c.toUpperCase())`,
+	TrimFunc: ([s, s2]) =>
+		`((s, f) => { let l = 0, r = s.length; while (l < r && f(s.codePointAt(l))) l++; while (r > l && f(s.codePointAt(r - 1))) r--; return s.slice(l, r); })(${s}, ${s2})`,
+	TrimLeftFunc: ([s, s2]) =>
+		`((s, f) => { let l = 0; while (l < s.length && f(s.codePointAt(l))) l++; return s.slice(l); })(${s}, ${s2})`,
+	TrimRightFunc: ([s, s2]) =>
+		`((s, f) => { let r = s.length; while (r > 0 && f(s.codePointAt(r - 1))) r--; return s.slice(0, r); })(${s}, ${s2})`,
+	IndexFunc: ([s, s2]) =>
+		`((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--) { const cp = s.codePointAt(i); if (f(cp)) return i; } return -1; })(${s}, ${s2})`,
+	NewReader: ([s]) =>
+		`{_src: ${s}, _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.charCodeAt(this._pos + i); this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(s) { this._src = s; this._pos = 0; }}`,
+	NewReplacer: (args) =>
+		`((...pairs) => { const p = []; for (let i = 0; i < pairs.length; i += 2) p.push([pairs[i], pairs[i+1]]); return { _p: p, Replace(s) { let r = s; for (const [o, n] of this._p) r = r.split(o).join(n); return r; } }; })(${args.join(", ")})`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const stringsMethods = {
+	_genStrings(fn, a) {
+		const args = a();
+		const [s, s2] = args;
+		if (STRINGS_M1[fn]) return `${s}.${STRINGS_M1[fn]}()`;
+		if (STRINGS_M2[fn]) return `${s}.${STRINGS_M2[fn]}(${s2})`;
+		const gen = STRINGS_DISPATCH[fn];
+		return gen ? gen(args) : undefined;
+	},
+};

package/src/codegen/stdlib/time.js

@@ -0,0 +1,57 @@
+// CodeGen for Go `time` package — `time.Now`, `time.Since`, etc., plus `*Time` methods.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const TIME_METHOD_DISPATCH = {
+	Year: (r) => `${r}._d.getFullYear()`,
+	Month: (r) => `${r}._d.getMonth() + 1`,
+	Day: (r) => `${r}._d.getDate()`,
+	Hour: (r) => `${r}._d.getHours()`,
+	Minute: (r) => `${r}._d.getMinutes()`,
+	Second: (r) => `${r}._d.getSeconds()`,
+	Weekday: (r) => `${r}._d.getDay()`,
+	Unix: (r) => `Math.floor(${r}._d.getTime() / 1000)`,
+	UnixMilli: (r) => `${r}._d.getTime()`,
+	Add: (r, a) => `{_d: new Date(${r}._d.getTime() + (${a[0]}))}`,
+	Sub: (r, a) => `${r}._d.getTime() - (${a[0]})._d.getTime()`,
+	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()`,
+};
+
+const TIME_DISPATCH = {
+	Now: () => "{_d: new Date()}",
+	Since: (a) => `(Date.now() - (${a[0]})._d.getTime())`,
+	Sleep: (a) => `await new Promise(r => setTimeout(r, ${a[0]} / 1000000))`,
+	Unix: (a) => `{_d: new Date((${a[0]}) * 1000)}`,
+	Date: (a) =>
+		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]})}`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const timeMethods = {
+	_genTimeMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		const recvJs = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+		if (method === "Format") {
+			this._usesTimeFmt = true;
+			return `__timeFmt(${recvJs}._d, ${args[0]})`;
+		}
+		if (method === "String") {
+			this._usesTimeFmt = true;
+			return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
+		}
+		const gen = TIME_METHOD_DISPATCH[method];
+		return gen ? gen(recvJs, args) : undefined;
+	},
+
+	_genTime(fn, a) {
+		if (fn === "Parse") {
+			this._usesTimeParse = true;
+			return `__timeParse(${a()[0]}, ${a()[1]})`;
+		}
+		const gen = TIME_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};

package/src/codegen/stdlib/unicode.js

@@ -0,0 +1,25 @@
+// CodeGen for Go `unicode` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const unicodeMethods = {
+	_genUnicode(fn, a) {
+		const [arg] = a();
+		const cp = `String.fromCodePoint(${arg})`;
+		const UNICODE_TEST = {
+			IsLetter: `/\\p{L}/u.test(${cp})`,
+			IsDigit: `/\\p{Nd}/u.test(${cp})`,
+			IsSpace: `/\\s/.test(${cp})`,
+			IsUpper: `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(${cp})`,
+			IsLower: `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(${cp})`,
+			IsPunct: `/\\p{P}/u.test(${cp})`,
+			IsControl: `/\\p{Cc}/u.test(${cp})`,
+			IsPrint: `!/\\p{Cc}/u.test(${cp})`,
+			IsGraphic: `!/\\p{Cc}/u.test(${cp})`,
+			ToUpper: `${cp}.toUpperCase().codePointAt(0)`,
+			ToLower: `${cp}.toLowerCase().codePointAt(0)`,
+		};
+		return UNICODE_TEST[fn] ?? undefined;
+	},
+};

package/src/codegen/stdlib/utf8.js

@@ -0,0 +1,26 @@
+// CodeGen for Go `unicode/utf8` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const UTF8_DISPATCH = {
+	RuneCountInString: (a) => `[...(${a[0]})].length`,
+	RuneLen: (a) =>
+		`((r) => r < 0 ? -1 : r <= 0x7F ? 1 : r <= 0x7FF ? 2 : r <= 0xFFFF ? (r >= 0xD800 && r <= 0xDFFF ? -1 : 3) : r <= 0x10FFFF ? 4 : -1)(${a[0]})`,
+	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)`,
+	DecodeRuneInString: (a) =>
+		`((s) => { if (!s) return [0xFFFD, 0]; const cp = s.codePointAt(0); return [cp, cp > 0xFFFF ? 2 : 1]; })(${a[0]})`,
+	DecodeLastRuneInString: (a) =>
+		`((s) => { if (!s) return [0xFFFD, 0]; const i = s.length > 1 && s.charCodeAt(s.length - 1) >= 0xDC00 && s.charCodeAt(s.length - 1) <= 0xDFFF ? s.length - 2 : s.length - 1; const cp = s.codePointAt(i); return [cp, cp > 0xFFFF ? 2 : 1]; })(${a[0]})`,
+	FullRuneInString: (a) => `(${a[0]}).length > 0`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const utf8Methods = {
+	_genUtf8(fn, a) {
+		const gen = UTF8_DISPATCH[fn];
+		return gen ? gen(a()) : undefined;
+	},
+};