gofront 1.7.0 → 1.9.0

package/src/typechecker/stdlib/core.js

@@ -1,801 +0,0 @@
-// Core standard library type definitions — browser globals, fmt, strings, bytes,
-// strconv, sort, math, errors, time, unicode, os, slices, html, io.
-
-import {
-	ANY,
-	BOOL,
-	BROWSER_GLOBALS,
-	ERROR,
-	FLOAT32,
-	FLOAT64,
-	INT,
-	INT8,
-	INT16,
-	INT32,
-	INT64,
-	STRING,
-	UINT,
-	UINT8,
-	UINT16,
-	UINT32,
-	UINT64,
-	VOID,
-} from "../types.js";
-
-const DURATION_T = {
-	kind: "named",
-	name: "time.Duration",
-	underlying: INT64,
-	methods: new Map([
-		["Nanoseconds", { kind: "func", params: [], returns: [INT64] }],
-		["Microseconds", { kind: "func", params: [], returns: [INT64] }],
-		["Milliseconds", { kind: "func", params: [], returns: [INT64] }],
-		["Seconds", { kind: "func", params: [], returns: [FLOAT64] }],
-		["Minutes", { kind: "func", params: [], returns: [FLOAT64] }],
-		["Hours", { kind: "func", params: [], returns: [FLOAT64] }],
-		["String", { kind: "func", params: [], returns: [STRING] }],
-	]),
-};
-const TIME_T = {
-	kind: "named",
-	name: "time.Time",
-	underlying: {
-		kind: "struct",
-		fields: new Map(),
-		methods: new Map(),
-	},
-};
-TIME_T.underlying.fields.set("_unixNano", INT64);
-TIME_T.underlying.fields.set("_offset", INT32);
-TIME_T.underlying.methods = new Map([
-	["Format", { kind: "func", params: [STRING], returns: [STRING] }],
-	["String", { kind: "func", params: [], returns: [STRING] }],
-	["Year", { kind: "func", params: [], returns: [INT] }],
-	["Month", { kind: "func", params: [], returns: [INT] }],
-	["Day", { kind: "func", params: [], returns: [INT] }],
-	["Hour", { kind: "func", params: [], returns: [INT] }],
-	["Minute", { kind: "func", params: [], returns: [INT] }],
-	["Second", { kind: "func", params: [], returns: [INT] }],
-	["Weekday", { kind: "func", params: [], returns: [INT] }],
-	["Unix", { kind: "func", params: [], returns: [INT64] }],
-	["UnixMilli", { kind: "func", params: [], returns: [INT64] }],
-	["UnixNano", { kind: "func", params: [], returns: [INT64] }],
-	["Nanosecond", { kind: "func", params: [], returns: [INT] }],
-	["IsZero", { kind: "func", params: [], returns: [BOOL] }],
-	["UTC", { kind: "func", params: [], returns: [TIME_T] }],
-	["Local", { kind: "func", params: [], returns: [TIME_T] }],
-	["Add", { kind: "func", params: [DURATION_T], returns: [TIME_T] }],
-	["Sub", { kind: "func", params: [TIME_T], returns: [DURATION_T] }],
-	["Before", { kind: "func", params: [TIME_T], returns: [BOOL] }],
-	["After", { kind: "func", params: [TIME_T], returns: [BOOL] }],
-	["Equal", { kind: "func", params: [TIME_T], returns: [BOOL] }],
-	["AddDate", { kind: "func", params: [INT, INT, INT], returns: [TIME_T] }],
-	["Truncate", { kind: "func", params: [DURATION_T], returns: [TIME_T] }],
-	["Round", { kind: "func", params: [DURATION_T], returns: [TIME_T] }],
-	["Date", { kind: "func", params: [], returns: [INT, INT, INT] }],
-	["Clock", { kind: "func", params: [], returns: [INT, INT, INT] }],
-	["YearDay", { kind: "func", params: [], returns: [INT] }],
-	["ISOWeek", { kind: "func", params: [], returns: [INT, INT] }],
-	["Compare", { kind: "func", params: [TIME_T], returns: [INT] }],
-	["In", { kind: "func", params: [ANY], returns: [TIME_T] }],
-	["Location", { kind: "func", params: [], returns: [ANY] }],
-	["Zone", { kind: "func", params: [], returns: [STRING, INT] }],
-]);
-TIME_T.methods = TIME_T.underlying.methods;
-const REPLACER_T = {
-	kind: "pointer",
-	base: { kind: "named", name: "strings.Replacer" },
-};
-
-export function setupCoreGlobals(globals, types) {
-	for (const g of BROWSER_GLOBALS) globals.define(g, ANY);
-
-	const fmtVariadic = (ret) => ({
-		kind: "func",
-		params: [STRING, ANY],
-		returns: [ret],
-		variadic: true,
-	});
-	const fmtPrintVariadic = (ret) => ({
-		kind: "func",
-		params: [ANY],
-		returns: [ret],
-		variadic: true,
-	});
-	globals.define("fmt", {
-		kind: "namespace",
-		name: "fmt",
-		members: {
-			Sprintf: fmtVariadic(STRING),
-			Errorf: fmtVariadic(ERROR),
-			Printf: fmtVariadic(VOID),
-			Println: fmtPrintVariadic(VOID),
-			Print: fmtPrintVariadic(VOID),
-			Fprintf: {
-				kind: "func",
-				params: [ANY, STRING, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-			Fprintln: {
-				kind: "func",
-				params: [ANY, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-			Fprint: {
-				kind: "func",
-				params: [ANY, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-			Sscan: {
-				kind: "func",
-				params: [STRING, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-			Sscanln: {
-				kind: "func",
-				params: [STRING, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-			Sscanf: {
-				kind: "func",
-				params: [STRING, STRING, ANY],
-				returns: [INT, ERROR],
-				variadic: true,
-			},
-		},
-	});
-
-	const strFn1 = (ret) => ({ kind: "func", params: [STRING], returns: [ret] });
-	const strFn2 = (p2, ret) => ({
-		kind: "func",
-		params: [STRING, p2],
-		returns: [ret],
-	});
-	const strFn3 = (p2, p3, ret) => ({
-		kind: "func",
-		params: [STRING, p2, p3],
-		returns: [ret],
-	});
-	globals.define("strings", {
-		kind: "namespace",
-		name: "strings",
-		members: {
-			Contains: strFn2(STRING, BOOL),
-			HasPrefix: strFn2(STRING, BOOL),
-			HasSuffix: strFn2(STRING, BOOL),
-			Index: strFn2(STRING, INT),
-			LastIndex: strFn2(STRING, INT),
-			Count: strFn2(STRING, INT),
-			Repeat: strFn2(INT, STRING),
-			Replace: {
-				kind: "func",
-				params: [STRING, STRING, STRING, INT],
-				returns: [STRING],
-			},
-			ReplaceAll: strFn3(STRING, STRING, STRING),
-			ToUpper: strFn1(STRING),
-			ToLower: strFn1(STRING),
-			TrimSpace: strFn1(STRING),
-			Trim: strFn2(STRING, STRING),
-			TrimPrefix: strFn2(STRING, STRING),
-			TrimSuffix: strFn2(STRING, STRING),
-			TrimLeft: strFn2(STRING, STRING),
-			TrimRight: strFn2(STRING, STRING),
-			Split: strFn2(STRING, { kind: "slice", elem: STRING }),
-			Join: {
-				kind: "func",
-				params: [{ kind: "slice", elem: STRING }, STRING],
-				returns: [STRING],
-			},
-			EqualFold: strFn2(STRING, BOOL),
-			Fields: strFn1({ kind: "slice", elem: STRING }),
-			FieldsFunc: strFn2(ANY, { kind: "slice", elem: STRING }),
-			Cut: {
-				kind: "func",
-				params: [STRING, STRING],
-				returns: [STRING, STRING, BOOL],
-			},
-			CutPrefix: {
-				kind: "func",
-				params: [STRING, STRING],
-				returns: [STRING, BOOL],
-			},
-			CutSuffix: {
-				kind: "func",
-				params: [STRING, STRING],
-				returns: [STRING, BOOL],
-			},
-			SplitN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
-			SplitAfter: strFn2(STRING, { kind: "slice", elem: STRING }),
-			SplitAfterN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
-			IndexAny: strFn2(STRING, INT),
-			LastIndexAny: strFn2(STRING, INT),
-			ContainsAny: strFn2(STRING, BOOL),
-			ContainsRune: strFn2(INT, BOOL),
-			IndexRune: strFn2(INT, INT),
-			IndexByte: strFn2(INT, INT),
-			LastIndexByte: strFn2(INT, INT),
-			Map: {
-				kind: "func",
-				params: [ANY, STRING],
-				returns: [STRING],
-			},
-			Title: strFn1(STRING),
-			ToTitle: strFn1(STRING),
-			TrimFunc: { kind: "func", params: [STRING, ANY], returns: [STRING] },
-			TrimLeftFunc: { kind: "func", params: [STRING, ANY], returns: [STRING] },
-			TrimRightFunc: { kind: "func", params: [STRING, ANY], returns: [STRING] },
-			IndexFunc: { kind: "func", params: [STRING, ANY], returns: [INT] },
-			LastIndexFunc: { kind: "func", params: [STRING, ANY], returns: [INT] },
-			NewReplacer: {
-				kind: "func",
-				params: [STRING],
-				returns: [REPLACER_T],
-				variadic: true,
-			},
-			NewReader: { kind: "func", params: [STRING], returns: [ANY] },
-			Builder: ANY,
-		},
-	});
-
-	const BYTE_SLICE = { kind: "slice", elem: UINT8 };
-	const byFn1 = (ret) => ({
-		kind: "func",
-		params: [BYTE_SLICE],
-		returns: [ret],
-	});
-	const byFn2 = (p2, ret) => ({
-		kind: "func",
-		params: [BYTE_SLICE, p2],
-		returns: [ret],
-	});
-	globals.define("bytes", {
-		kind: "namespace",
-		name: "bytes",
-		members: {
-			Contains: byFn2(BYTE_SLICE, BOOL),
-			HasPrefix: byFn2(BYTE_SLICE, BOOL),
-			HasSuffix: byFn2(BYTE_SLICE, BOOL),
-			Index: byFn2(BYTE_SLICE, INT),
-			Count: byFn2(BYTE_SLICE, INT),
-			Repeat: byFn2(INT, BYTE_SLICE),
-			Replace: {
-				kind: "func",
-				params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE, INT],
-				returns: [BYTE_SLICE],
-			},
-			ToUpper: byFn1(BYTE_SLICE),
-			ToLower: byFn1(BYTE_SLICE),
-			ToTitle: byFn1(BYTE_SLICE),
-			TrimSpace: byFn1(BYTE_SLICE),
-			Trim: byFn2(STRING, BYTE_SLICE),
-			Equal: byFn2(BYTE_SLICE, BOOL),
-			Split: byFn2(BYTE_SLICE, { kind: "slice", elem: BYTE_SLICE }),
-			Join: {
-				kind: "func",
-				params: [{ kind: "slice", elem: BYTE_SLICE }, BYTE_SLICE],
-				returns: [BYTE_SLICE],
-			},
-			ReplaceAll: {
-				kind: "func",
-				params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE],
-				returns: [BYTE_SLICE],
-			},
-			TrimPrefix: byFn2(BYTE_SLICE, BYTE_SLICE),
-			TrimSuffix: byFn2(BYTE_SLICE, BYTE_SLICE),
-			TrimLeft: byFn2(STRING, BYTE_SLICE),
-			TrimRight: byFn2(STRING, BYTE_SLICE),
-			TrimFunc: {
-				kind: "func",
-				params: [BYTE_SLICE, ANY],
-				returns: [BYTE_SLICE],
-			},
-			IndexByte: byFn2(INT, INT),
-			LastIndex: byFn2(BYTE_SLICE, INT),
-			LastIndexByte: byFn2(INT, INT),
-			Fields: byFn1({ kind: "slice", elem: BYTE_SLICE }),
-			FieldsFunc: byFn2(ANY, { kind: "slice", elem: BYTE_SLICE }),
-			Clone: byFn1(BYTE_SLICE),
-			Cut: {
-				kind: "func",
-				params: [BYTE_SLICE, BYTE_SLICE],
-				returns: [BYTE_SLICE, BYTE_SLICE, BOOL],
-			},
-			ContainsAny: byFn2(STRING, BOOL),
-			ContainsRune: byFn2(INT, BOOL),
-			Map: { kind: "func", params: [ANY, BYTE_SLICE], returns: [BYTE_SLICE] },
-			SplitN: {
-				kind: "func",
-				params: [BYTE_SLICE, BYTE_SLICE, INT],
-				returns: [{ kind: "slice", elem: BYTE_SLICE }],
-			},
-			NewReader: { kind: "func", params: [BYTE_SLICE], returns: [ANY] },
-			Buffer: ANY,
-		},
-	});
-
-	globals.define("strconv", {
-		kind: "namespace",
-		name: "strconv",
-		members: {
-			Itoa: { kind: "func", params: [INT], returns: [STRING] },
-			Atoi: { kind: "func", params: [STRING], returns: [INT, ERROR] },
-			FormatFloat: {
-				kind: "func",
-				params: [FLOAT64, INT, INT, INT],
-				returns: [STRING],
-			},
-			FormatBool: { kind: "func", params: [BOOL], returns: [STRING] },
-			FormatInt: { kind: "func", params: [INT64, INT], returns: [STRING] },
-			FormatUint: { kind: "func", params: [UINT64, INT], returns: [STRING] },
-			ParseFloat: {
-				kind: "func",
-				params: [STRING, INT],
-				returns: [FLOAT64, ERROR],
-			},
-			ParseInt: {
-				kind: "func",
-				params: [STRING, INT, INT],
-				returns: [INT, ERROR],
-			},
-			ParseUint: {
-				kind: "func",
-				params: [STRING, INT, INT],
-				returns: [UINT64, ERROR],
-			},
-			ParseBool: { kind: "func", params: [STRING], returns: [BOOL, ERROR] },
-			Quote: { kind: "func", params: [STRING], returns: [STRING] },
-			Unquote: { kind: "func", params: [STRING], returns: [STRING, ERROR] },
-			AppendInt: {
-				kind: "func",
-				params: [BYTE_SLICE, INT64, INT],
-				returns: [BYTE_SLICE],
-			},
-			AppendUint: {
-				kind: "func",
-				params: [BYTE_SLICE, UINT64, INT],
-				returns: [BYTE_SLICE],
-			},
-			AppendFloat: {
-				kind: "func",
-				params: [BYTE_SLICE, FLOAT64, INT, INT, INT],
-				returns: [BYTE_SLICE],
-			},
-			AppendBool: {
-				kind: "func",
-				params: [BYTE_SLICE, BOOL],
-				returns: [BYTE_SLICE],
-			},
-			ErrSyntax: ERROR,
-			ErrRange: ERROR,
-		},
-	});
-
-	globals.define("sort", {
-		kind: "namespace",
-		name: "sort",
-		members: {
-			Ints: {
-				kind: "func",
-				params: [{ kind: "slice", elem: INT }],
-				returns: [VOID],
-			},
-			Float64s: {
-				kind: "func",
-				params: [{ kind: "slice", elem: FLOAT64 }],
-				returns: [VOID],
-			},
-			Strings: {
-				kind: "func",
-				params: [{ kind: "slice", elem: STRING }],
-				returns: [VOID],
-			},
-			Slice: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-			SliceStable: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-			SliceIsSorted: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-			Search: { kind: "func", params: [INT, ANY], returns: [INT] },
-			IntsAreSorted: {
-				kind: "func",
-				params: [{ kind: "slice", elem: INT }],
-				returns: [BOOL],
-			},
-			Float64sAreSorted: {
-				kind: "func",
-				params: [{ kind: "slice", elem: FLOAT64 }],
-				returns: [BOOL],
-			},
-			StringsAreSorted: {
-				kind: "func",
-				params: [{ kind: "slice", elem: STRING }],
-				returns: [BOOL],
-			},
-		},
-	});
-
-	globals.define("math", {
-		kind: "namespace",
-		name: "math",
-		members: {
-			Abs: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Floor: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Ceil: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Round: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Sqrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Cbrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Pow: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Log: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Log2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Log10: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Sin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Cos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Tan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Min: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Max: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Mod: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Inf: { kind: "func", params: [INT], returns: [FLOAT64] },
-			IsNaN: { kind: "func", params: [FLOAT64], returns: [BOOL] },
-			IsInf: { kind: "func", params: [FLOAT64, INT], returns: [BOOL] },
-			NaN: { kind: "func", params: [], returns: [FLOAT64] },
-			Atan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Atan2: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Asin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Acos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Exp: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Exp2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Trunc: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Hypot: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Signbit: { kind: "func", params: [FLOAT64], returns: [BOOL] },
-			Copysign: {
-				kind: "func",
-				params: [FLOAT64, FLOAT64],
-				returns: [FLOAT64],
-			},
-			Dim: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
-			Remainder: {
-				kind: "func",
-				params: [FLOAT64, FLOAT64],
-				returns: [FLOAT64],
-			},
-			Float64bits: { kind: "func", params: [FLOAT64], returns: [UINT64] },
-			Float64frombits: { kind: "func", params: [UINT64], returns: [FLOAT64] },
-			Float32bits: { kind: "func", params: [FLOAT32], returns: [UINT32] },
-			Float32frombits: { kind: "func", params: [UINT32], returns: [FLOAT32] },
-			Sinh: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Cosh: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Tanh: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-			Pi: FLOAT64,
-			E: FLOAT64,
-			Phi: FLOAT64,
-			Sqrt2: FLOAT64,
-			SqrtE: FLOAT64,
-			SqrtPi: FLOAT64,
-			SqrtPhi: FLOAT64,
-			Ln2: FLOAT64,
-			Log2E: FLOAT64,
-			Ln10: FLOAT64,
-			Log10E: FLOAT64,
-			MaxFloat32: FLOAT32,
-			SmallestNonzeroFloat32: FLOAT32,
-			MaxFloat64: FLOAT64,
-			SmallestNonzeroFloat64: FLOAT64,
-			MaxInt: INT,
-			MinInt: INT,
-			MaxInt8: INT8,
-			MinInt8: INT8,
-			MaxInt16: INT16,
-			MinInt16: INT16,
-			MaxInt32: INT32,
-			MinInt32: INT32,
-			MaxInt64: INT64,
-			MinInt64: INT64,
-			MaxUint8: UINT8,
-			MaxUint16: UINT16,
-			MaxUint32: UINT32,
-			MaxUint: UINT,
-			MaxUint64: UINT64,
-		},
-	});
-
-	globals.define("bits", {
-		kind: "namespace",
-		name: "bits",
-		members: {
-			LeadingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
-			TrailingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
-			OnesCount32: { kind: "func", params: [UINT32], returns: [INT] },
-			RotateLeft32: { kind: "func", params: [UINT32, INT], returns: [UINT32] },
-			LeadingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
-			TrailingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
-			OnesCount64: { kind: "func", params: [UINT64], returns: [INT] },
-			RotateLeft64: { kind: "func", params: [UINT64, INT], returns: [UINT64] },
-			ReverseBytes16: { kind: "func", params: [UINT16], returns: [UINT16] },
-			ReverseBytes32: { kind: "func", params: [UINT32], returns: [UINT32] },
-			ReverseBytes64: { kind: "func", params: [UINT64], returns: [UINT64] },
-			Len32: { kind: "func", params: [UINT32], returns: [INT] },
-			Len64: { kind: "func", params: [UINT64], returns: [INT] },
-			Reverse32: { kind: "func", params: [UINT32], returns: [UINT32] },
-			Reverse64: { kind: "func", params: [UINT64], returns: [UINT64] },
-		},
-	});
-
-	globals.define("errors", {
-		kind: "namespace",
-		name: "errors",
-		members: {
-			New: { kind: "func", params: [STRING], returns: [ERROR] },
-			Is: { kind: "func", params: [ERROR, ERROR], returns: [BOOL] },
-			Unwrap: { kind: "func", params: [ERROR], returns: [ERROR] },
-			As: { kind: "func", params: [ERROR, ANY], returns: [BOOL] },
-			Join: {
-				kind: "func",
-				params: [ERROR],
-				returns: [ERROR],
-				variadic: true,
-			},
-		},
-	});
-
-	globals.define("time", {
-		kind: "namespace",
-		name: "time",
-		members: {
-			Now: { kind: "func", params: [], returns: [TIME_T] },
-			Since: { kind: "func", params: [TIME_T], returns: [DURATION_T] },
-			Sleep: { kind: "func", params: [ANY], returns: [VOID], async: true },
-			Parse: {
-				kind: "func",
-				params: [STRING, STRING],
-				returns: [TIME_T, ERROR],
-			},
-			Unix: { kind: "func", params: [INT64, INT64], returns: [TIME_T] },
-			UnixMicro: { kind: "func", params: [INT64], returns: [TIME_T] },
-			UnixMilli: { kind: "func", params: [INT64], returns: [TIME_T] },
-			Date: {
-				kind: "func",
-				params: [INT, INT, INT, INT, INT, INT, INT, ANY],
-				returns: [TIME_T],
-			},
-			Duration: DURATION_T,
-			Nanosecond: DURATION_T,
-			Microsecond: DURATION_T,
-			Millisecond: DURATION_T,
-			Second: DURATION_T,
-			Minute: DURATION_T,
-			Hour: DURATION_T,
-			Time: TIME_T,
-			RFC3339: STRING,
-			RFC3339Nano: STRING,
-			DateOnly: STRING,
-			TimeOnly: STRING,
-			DateTime: STRING,
-			UTC: ANY,
-			Local: ANY,
-			January: INT,
-			February: INT,
-			March: INT,
-			April: INT,
-			May: INT,
-			June: INT,
-			July: INT,
-			August: INT,
-			September: INT,
-			October: INT,
-			November: INT,
-			December: INT,
-			Sunday: INT,
-			Monday: INT,
-			Tuesday: INT,
-			Wednesday: INT,
-			Thursday: INT,
-			Friday: INT,
-			Saturday: INT,
-		},
-	});
-	types.set("time.Duration", DURATION_T);
-	types.set("time.Time", TIME_T);
-
-	const runeToStr = { kind: "func", params: [INT], returns: [BOOL] };
-	const runeTrans = { kind: "func", params: [INT], returns: [INT] };
-	globals.define("unicode", {
-		kind: "namespace",
-		name: "unicode",
-		members: {
-			IsLetter: runeToStr,
-			IsDigit: runeToStr,
-			IsSpace: runeToStr,
-			IsUpper: runeToStr,
-			IsLower: runeToStr,
-			IsPunct: runeToStr,
-			IsControl: runeToStr,
-			IsPrint: runeToStr,
-			IsGraphic: runeToStr,
-			ToUpper: runeTrans,
-			ToLower: runeTrans,
-		},
-	});
-
-	globals.define("os", {
-		kind: "namespace",
-		name: "os",
-		members: {
-			Exit: { kind: "func", params: [INT], returns: [VOID] },
-			Args: { kind: "slice", elem: STRING },
-			Getenv: { kind: "func", params: [STRING], returns: [STRING] },
-			Stdout: ANY,
-			Stderr: ANY,
-			Stdin: ANY,
-		},
-	});
-
-	// Slice helpers that return a slice of the same type as their first argument.
-	const sameSlice = (params, extra = {}) => ({
-		kind: "func",
-		params,
-		returns: [ANY],
-		_derivedReturn: "arg0",
-		...extra,
-	});
-	globals.define("slices", {
-		kind: "namespace",
-		name: "slices",
-		members: {
-			Contains: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-			ContainsFunc: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-			Index: { kind: "func", params: [ANY, ANY], returns: [INT] },
-			IndexFunc: { kind: "func", params: [ANY, ANY], returns: [INT] },
-			BinarySearch: { kind: "func", params: [ANY, ANY], returns: [INT, BOOL] },
-			BinarySearchFunc: {
-				kind: "func",
-				params: [ANY, ANY, ANY],
-				returns: [INT, BOOL],
-			},
-			Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-			Compare: { kind: "func", params: [ANY, ANY], returns: [INT] },
-			Sort: { kind: "func", params: [ANY], returns: [VOID] },
-			SortFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-			SortStableFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-			IsSorted: { kind: "func", params: [ANY], returns: [BOOL] },
-			IsSortedFunc: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-			Reverse: { kind: "func", params: [ANY], returns: [VOID] },
-			Max: {
-				kind: "func",
-				params: [ANY],
-				returns: [ANY],
-				_derivedReturn: "elemOfArg0",
-			},
-			Min: {
-				kind: "func",
-				params: [ANY],
-				returns: [ANY],
-				_derivedReturn: "elemOfArg0",
-			},
-			MaxFunc: {
-				kind: "func",
-				params: [ANY, ANY],
-				returns: [ANY],
-				_derivedReturn: "elemOfArg0",
-			},
-			MinFunc: {
-				kind: "func",
-				params: [ANY, ANY],
-				returns: [ANY],
-				_derivedReturn: "elemOfArg0",
-			},
-			Clone: sameSlice([ANY]),
-			Compact: sameSlice([ANY]),
-			CompactFunc: sameSlice([ANY, ANY]),
-			Concat: sameSlice([ANY], { variadic: true }),
-			Delete: sameSlice([ANY, INT, INT]),
-			DeleteFunc: sameSlice([ANY, ANY]),
-			Insert: sameSlice([ANY, INT, ANY], { variadic: true }),
-			Replace: sameSlice([ANY, INT, INT, ANY], { variadic: true }),
-			Grow: sameSlice([ANY, INT]),
-			Clip: sameSlice([ANY]),
-		},
-	});
-
-	globals.define("html", {
-		kind: "namespace",
-		name: "html",
-		members: {
-			EscapeString: { kind: "func", params: [STRING], returns: [STRING] },
-			UnescapeString: { kind: "func", params: [STRING], returns: [STRING] },
-		},
-	});
-
-	const BYTE_SLICE_IO = { kind: "slice", elem: UINT8 };
-	const IO_WRITER = {
-		kind: "interface",
-		name: "io.Writer",
-		methods: new Map([
-			[
-				"Write",
-				{ kind: "func", params: [BYTE_SLICE_IO], returns: [INT, ERROR] },
-			],
-		]),
-	};
-	const IO_READER = {
-		kind: "interface",
-		name: "io.Reader",
-		methods: new Map([
-			[
-				"Read",
-				{ kind: "func", params: [BYTE_SLICE_IO], returns: [INT, ERROR] },
-			],
-		]),
-	};
-	const IO_CLOSER = {
-		kind: "interface",
-		name: "io.Closer",
-		methods: new Map([
-			["Close", { kind: "func", params: [], returns: [ERROR] }],
-		]),
-	};
-	const IO_READWRITER = {
-		kind: "interface",
-		name: "io.ReadWriter",
-		methods: new Map([
-			[
-				"Read",
-				{ kind: "func", params: [BYTE_SLICE_IO], returns: [INT, ERROR] },
-			],
-			[
-				"Write",
-				{ kind: "func", params: [BYTE_SLICE_IO], returns: [INT, ERROR] },
-			],
-		]),
-	};
-	globals.define("io", {
-		kind: "namespace",
-		name: "io",
-		members: {
-			Writer: IO_WRITER,
-			Reader: IO_READER,
-			Closer: IO_CLOSER,
-			ReadWriter: IO_READWRITER,
-			EOF: ERROR,
-			ErrUnexpectedEOF: ERROR,
-			ErrShortWrite: ERROR,
-			WriteString: {
-				kind: "func",
-				params: [IO_WRITER, STRING],
-				returns: [INT, ERROR],
-			},
-			ReadFull: {
-				kind: "func",
-				params: [IO_READER, BYTE_SLICE_IO],
-				returns: [INT, ERROR],
-			},
-			ReadAll: {
-				kind: "func",
-				params: [IO_READER],
-				returns: [BYTE_SLICE_IO, ERROR],
-			},
-			LimitReader: {
-				kind: "func",
-				params: [IO_READER, INT64],
-				returns: [IO_READER],
-			},
-			Copy: {
-				kind: "func",
-				params: [IO_WRITER, IO_READER],
-				returns: [INT64, ERROR],
-			},
-			CopyN: {
-				kind: "func",
-				params: [IO_WRITER, IO_READER, INT64],
-				returns: [INT64, ERROR],
-			},
-			Discard: IO_WRITER,
-		},
-	});
-	types.set("io.Writer", IO_WRITER);
-	types.set("io.Reader", IO_READER);
-	types.set("io.Closer", IO_CLOSER);
-	types.set("io.ReadWriter", IO_READWRITER);
-}