goscript 0.2.6 → 0.2.7

package/gs/strings/reader.ts

@@ -161,30 +161,30 @@ export class Reader {
     return null
   }
 
-  // Seek implements the [io.Seeker] interface.
-  public Seek(offset: number, whence: number): [number, $.GoError] {
+  // Seek implements the [io.Seeker] interface. offset is a Go int64 (bigint);
+  // the internal read index stays a number for string slicing.
+  public Seek(offset: bigint, whence: number): [bigint, $.GoError] {
     const r = this
     r!.prevRune = -1
     let abs: number
     switch (whence) {
       case io.SeekStart:
-        abs = offset
+        abs = Number(offset)
         break
       case io.SeekCurrent:
-        abs = r!.i + offset
+        abs = r!.i + Number(offset)
         break
       case io.SeekEnd:
-        abs = ($.len(r!.s) as number) + offset
+        abs = ($.len(r!.s) as number) + Number(offset)
         break
       default:
-        return [0, $.newError('strings.Reader.Seek: invalid whence')]
-        break
+        return [0n, $.newError('strings.Reader.Seek: invalid whence')]
     }
     if (abs < 0) {
-      return [0, $.newError('strings.Reader.Seek: negative position')]
+      return [0n, $.newError('strings.Reader.Seek: negative position')]
     }
     r!.i = abs
-    return [abs, null]
+    return [BigInt(abs), null]
   }
 
   // WriteTo implements the [io.WriterTo] interface.

package/gs/strings/strings.test.ts

@@ -319,7 +319,17 @@ describe('strings', () => {
       )
       expect(Replace('hello world hello', 'hello', 'hi', 2)).toBe('hi world hi')
       expect(Replace('hello world', 'xyz', 'abc', 1)).toBe('hello world')
-      expect(Replace('hello', '', 'x', 1)).toBe('hello')
+    })
+
+    it('matches Go for empty old, negative n, and remainder', () => {
+      // Empty old inserts at the start and after each rune, then appends the
+      // untouched remainder once the insertion limit is reached.
+      expect(Replace('abc', '', '-', 2)).toBe('-a-bc')
+      expect(Replace('abc', '', '-', -1)).toBe('-a-b-c-')
+      expect(Replace('hello', '', 'x', 1)).toBe('xhello')
+      // n < 0 replaces every occurrence, not none.
+      expect(Replace('aaa', 'a', 'b', -1)).toBe('bbb')
+      expect(Replace('a,b,c', ',', ';', -1)).toBe('a;b;c')
     })
   })
 
@@ -380,7 +390,8 @@ describe('strings', () => {
   describe('Title', () => {
     it('should convert to title case', () => {
       expect(Title('hello world')).toBe('Hello World')
-      expect(Title('HELLO WORLD')).toBe('Hello World')
+      // Go's Title only title-cases word-initial letters; the rest is unchanged.
+      expect(Title('HELLO WORLD')).toBe('HELLO WORLD')
       expect(Title('')).toBe('')
     })
   })
@@ -411,9 +422,11 @@ describe('strings', () => {
 
   describe('special casing and UTF-8 cleanup', () => {
     it('should expose special-case string helpers', () => {
-      expect(ToUpperSpecial([], 'hello')).toBe('HELLO')
-      expect(ToLowerSpecial([], 'HELLO')).toBe('hello')
-      expect(ToTitleSpecial([], 'hello world')).toBe('HELLO WORLD')
+      expect(ToUpperSpecial(new unicode.SpecialCase(), 'hello')).toBe('HELLO')
+      expect(ToLowerSpecial(new unicode.SpecialCase(), 'HELLO')).toBe('hello')
+      expect(ToTitleSpecial(new unicode.SpecialCase(), 'hello world')).toBe(
+        'HELLO WORLD',
+      )
       expect(ToUpperSpecial(unicode.TurkishCase, 'iki')).toBe('İKİ')
       expect(ToLowerSpecial(unicode.TurkishCase, 'Iİ')).toBe('ıi')
       expect(ToTitleSpecial(unicode.TurkishCase, 'iki')).toBe('İKİ')

package/gs/strings/strings.ts

@@ -353,70 +353,32 @@ export function Repeat(s: string, count: number): string {
 
 // ToUpper returns s with all Unicode letters mapped to their upper case.
 export function ToUpper(s: string): string {
-  return s.toUpperCase()
+  return Map(unicode.ToUpper, s)
 }
 
+// ToUpperSpecial returns s with all Unicode letters mapped to their upper case using the case mapping specified by c.
 export function ToUpperSpecial(c: unicode.SpecialCase, s: string): string {
-  if (isTurkishCase(c)) {
-    return mapTurkishCase(s, 'upper')
-  }
-  return ToUpper(s)
+  return Map((r) => c.ToUpper(r), s)
 }
 
 // ToLower returns s with all Unicode letters mapped to their lower case.
 export function ToLower(s: string): string {
-  return s.toLowerCase()
+  return Map(unicode.ToLower, s)
 }
 
+// ToLowerSpecial returns s with all Unicode letters mapped to their lower case using the case mapping specified by c.
 export function ToLowerSpecial(c: unicode.SpecialCase, s: string): string {
-  if (isTurkishCase(c)) {
-    return mapTurkishCase(s, 'lower')
-  }
-  return ToLower(s)
+  return Map((r) => c.ToLower(r), s)
 }
 
 // ToTitle returns a copy of the string s with all Unicode letters mapped to their Unicode title case.
 export function ToTitle(s: string): string {
-  return s.toUpperCase()
+  return Map(unicode.ToTitle, s)
 }
 
+// ToTitleSpecial returns a copy of s with all Unicode letters mapped to their Unicode title case using the case mapping specified by c.
 export function ToTitleSpecial(c: unicode.SpecialCase, s: string): string {
-  if (isTurkishCase(c)) {
-    return mapTurkishCase(s, 'upper')
-  }
-  return ToTitle(s)
-}
-
-function isTurkishCase(c: unicode.SpecialCase): boolean {
-  return c === unicode.TurkishCase || c === unicode.AzeriCase
-}
-
-function mapTurkishCase(s: string, mode: 'upper' | 'lower'): string {
-  let out = ''
-  for (const char of s) {
-    if (mode === 'upper') {
-      if (char === 'i') {
-        out += 'İ'
-        continue
-      }
-      if (char === 'ı') {
-        out += 'I'
-        continue
-      }
-      out += char.toUpperCase()
-      continue
-    }
-    if (char === 'I') {
-      out += 'ı'
-      continue
-    }
-    if (char === 'İ') {
-      out += 'i'
-      continue
-    }
-    out += char.toLowerCase()
-  }
-  return out
+  return Map((r) => c.ToTitle(r), s)
 }
 
 export function ToValidUTF8(s: string, replacement: string): string {
@@ -424,16 +386,30 @@ export function ToValidUTF8(s: string, replacement: string): string {
   return s
 }
 
+// isSeparator reports whether the rune could mark a word boundary.
+function isSeparator(r: number): boolean {
+  if (r <= 0x7f) {
+    if (r >= 0x30 && r <= 0x39) return false
+    if (r >= 0x61 && r <= 0x7a) return false
+    if (r >= 0x41 && r <= 0x5a) return false
+    if (r === 0x5f) return false
+    return true
+  }
+  if (unicode.IsLetter(r) || unicode.IsDigit(r)) return false
+  return unicode.IsSpace(r)
+}
+
 // Title returns a copy of the string s with all Unicode letters that begin words mapped to their Unicode title case.
 export function Title(s: string): string {
-  return s
-    .split(' ')
-    .map((word) =>
-      word.length > 0 ?
-        word[0].toUpperCase() + word.slice(1).toLowerCase()
-      : word,
-    )
-    .join(' ')
+  let prev = 0x20
+  return Map((r) => {
+    if (isSeparator(prev)) {
+      prev = r
+      return unicode.ToTitle(r)
+    }
+    prev = r
+    return r
+  }, s)
 }
 
 // TrimSpace returns a slice of the string s, with all leading and trailing white space removed.
@@ -529,24 +505,35 @@ export function Replace(
   newStr: string,
   n: number,
 ): string {
-  if (n <= 0 || old === '') {
+  if (n === 0 || old === newStr) {
     return s
   }
 
-  let result = s
-  let count = 0
-  let pos = 0
+  if (old === '') {
+    // Empty old matches at the start and after each rune (code point),
+    // yielding up to runeCount+1 insertions; n < 0 means no limit.
+    const runes = globalThis.Array.from(s)
+    const limit = n < 0 ? runes.length + 1 : Math.min(n, runes.length + 1)
+    let result = newStr
+    let i = 0
+    for (; i < limit - 1; i++) {
+      result += runes[i] + newStr
+    }
+    return result + runes.slice(i).join('')
+  }
 
-  while (count < n) {
-    const index = result.indexOf(old, pos)
+  // Non-empty old: replace up to n occurrences; n < 0 means all.
+  let result = ''
+  let start = 0
+  let count = 0
+  while (n < 0 || count < n) {
+    const index = s.indexOf(old, start)
     if (index === -1) break
-
-    result = result.slice(0, index) + newStr + result.slice(index + old.length)
-    pos = index + newStr.length
+    result += s.slice(start, index) + newStr
+    start = index + old.length
     count++
   }
-
-  return result
+  return result + s.slice(start)
 }
 
 // ReplaceAll returns a copy of the string s with all non-overlapping instances of old replaced by new.
@@ -557,9 +544,35 @@ export function ReplaceAll(s: string, old: string, newStr: string): string {
   return s.split(old).join(newStr)
 }
 
-// EqualFold reports whether s and t, interpreted as UTF-8 strings, are equal under Unicode case-folding.
+// EqualFold reports whether s and t, interpreted as UTF-8 strings, are equal under simple Unicode case-folding.
 export function EqualFold(s: string, t: string): boolean {
-  return s.toLowerCase() === t.toLowerCase()
+  const sr = Array.from(s, (ch) => ch.codePointAt(0)!)
+  const tr = Array.from(t, (ch) => ch.codePointAt(0)!)
+  let i = 0
+  let j = 0
+  while (i < sr.length && j < tr.length) {
+    let a = sr[i++]
+    let b = tr[j++]
+    if (a === b) continue
+    if (b < a) {
+      const tmp = a
+      a = b
+      b = tmp
+    }
+    if (b < 0x80) {
+      // ASCII: a and b match only as the same letter in opposite case.
+      if (a >= 0x41 && a <= 0x5a && b === a + 0x20) continue
+      return false
+    }
+    // Walk the simple-fold orbit of the smaller rune toward the larger.
+    let r = unicode.SimpleFold(a)
+    while (r !== a && r < b) {
+      r = unicode.SimpleFold(r)
+    }
+    if (r === b) continue
+    return false
+  }
+  return i === sr.length && j === tr.length
 }
 
 // Compare returns an integer comparing two strings lexicographically.

package/gs/sync/atomic/doc_64.gs.ts

@@ -5,8 +5,8 @@ import * as $ from "@goscript/builtin/index.js";
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function SwapInt64(addr: $.VarRef<number> | null, _new: number): number {
-	if (!addr) return 0;
+export function SwapInt64(addr: $.VarRef<bigint> | null, _new: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = _new;
 	return old;
@@ -17,8 +17,8 @@ export function SwapInt64(addr: $.VarRef<number> | null, _new: number): number {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function SwapUint64(addr: $.VarRef<number> | null, _new: number): number {
-	if (!addr) return 0;
+export function SwapUint64(addr: $.VarRef<bigint> | null, _new: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = _new;
 	return old;
@@ -29,7 +29,7 @@ export function SwapUint64(addr: $.VarRef<number> | null, _new: number): number
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function CompareAndSwapInt64(addr: $.VarRef<number> | null, old: number, _new: number): boolean {
+export function CompareAndSwapInt64(addr: $.VarRef<bigint> | null, old: bigint, _new: bigint): boolean {
 	if (!addr) return false;
 	if (addr.value === old) {
 		addr.value = _new;
@@ -43,7 +43,7 @@ export function CompareAndSwapInt64(addr: $.VarRef<number> | null, old: number,
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function CompareAndSwapUint64(addr: $.VarRef<number> | null, old: number, _new: number): boolean {
+export function CompareAndSwapUint64(addr: $.VarRef<bigint> | null, old: bigint, _new: bigint): boolean {
 	if (!addr) return false;
 	if (addr.value === old) {
 		addr.value = _new;
@@ -57,8 +57,8 @@ export function CompareAndSwapUint64(addr: $.VarRef<number> | null, old: number,
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
-	if (!addr) return 0;
+export function AddInt64(addr: $.VarRef<bigint> | null, delta: bigint): bigint {
+	if (!addr) return 0n;
 	addr.value = $.int64Add(addr.value, delta);
 	return addr.value;
 }
@@ -70,8 +70,8 @@ export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function AddUint64(addr: $.VarRef<number> | null, delta: number): number {
-	if (!addr) return 0;
+export function AddUint64(addr: $.VarRef<bigint> | null, delta: bigint): bigint {
+	if (!addr) return 0n;
 	addr.value = $.uint64Add(addr.value, delta);
 	return addr.value;
 }
@@ -81,8 +81,8 @@ export function AddUint64(addr: $.VarRef<number> | null, delta: number): number
 // Consider using the more ergonomic and less error-prone [Int64.And] instead.
 //
 //go:noescape
-export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
-	if (!addr) return 0;
+export function AndInt64(addr: $.VarRef<bigint> | null, mask: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = $.int64And(addr.value, mask);
 	return old;
@@ -93,8 +93,8 @@ export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
 // Consider using the more ergonomic and less error-prone [Uint64.And] instead.
 //
 //go:noescape
-export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
-	if (!addr) return 0;
+export function AndUint64(addr: $.VarRef<bigint> | null, mask: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = $.uint64And(addr.value, mask);
 	return old;
@@ -105,8 +105,8 @@ export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
 // Consider using the more ergonomic and less error-prone [Int64.Or] instead.
 //
 //go:noescape
-export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
-	if (!addr) return 0;
+export function OrInt64(addr: $.VarRef<bigint> | null, mask: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = $.int64Or(addr.value, mask);
 	return old;
@@ -117,8 +117,8 @@ export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
 // Consider using the more ergonomic and less error-prone [Uint64.Or] instead.
 //
 //go:noescape
-export function OrUint64(addr: $.VarRef<number> | null, mask: number): number {
-	if (!addr) return 0;
+export function OrUint64(addr: $.VarRef<bigint> | null, mask: bigint): bigint {
+	if (!addr) return 0n;
 	let old = addr.value;
 	addr.value = $.uint64Or(addr.value, mask);
 	return old;
@@ -129,8 +129,8 @@ export function OrUint64(addr: $.VarRef<number> | null, mask: number): number {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function LoadInt64(addr: $.VarRef<number> | null): number {
-	if (!addr) return 0;
+export function LoadInt64(addr: $.VarRef<bigint> | null): bigint {
+	if (!addr) return 0n;
 	return addr.value;
 }
 
@@ -139,8 +139,8 @@ export function LoadInt64(addr: $.VarRef<number> | null): number {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function LoadUint64(addr: $.VarRef<number> | null): number {
-	if (!addr) return 0;
+export function LoadUint64(addr: $.VarRef<bigint> | null): bigint {
+	if (!addr) return 0n;
 	return addr.value;
 }
 
@@ -149,7 +149,7 @@ export function LoadUint64(addr: $.VarRef<number> | null): number {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function StoreInt64(addr: $.VarRef<number> | null, val: number): void {
+export function StoreInt64(addr: $.VarRef<bigint> | null, val: bigint): void {
 	if (addr) {
 		addr.value = val;
 	}
@@ -160,7 +160,7 @@ export function StoreInt64(addr: $.VarRef<number> | null, val: number): void {
 // (particularly if you target 32-bit platforms; see the bugs section).
 //
 //go:noescape
-export function StoreUint64(addr: $.VarRef<number> | null, val: number): void {
+export function StoreUint64(addr: $.VarRef<bigint> | null, val: bigint): void {
 	if (addr) {
 		addr.value = val;
 	}

package/gs/sync/atomic/doc_64.test.ts

@@ -11,8 +11,8 @@ describe('sync/atomic 64-bit operations', () => {
   test('adds uint64 values without mixing number and bigint arithmetic', () => {
     const value = $.varRef($.uint('18446744073709551614', 64))
 
-    expect(AddUint64(value, $.uint(2, 64))).toBe(0)
-    expect(value.value).toBe(0)
+    expect(AddUint64(value, $.uint(2, 64))).toBe(0n)
+    expect(value.value).toBe(0n)
   })
 
   test('preserves high uint64 bits for bitwise operations', () => {
@@ -28,9 +28,9 @@ describe('sync/atomic 64-bit operations', () => {
   })
 
   test('adds int64 values without number coercion', () => {
-    const value = $.varRef($.int('9223372036854775807', 64))
+    const value = $.varRef($.int64('9223372036854775807'))
 
-    expect(AddInt64(value, 1)).toBe(-9223372036854775808)
-    expect(value.value).toBe(-9223372036854775808)
+    expect(AddInt64(value, 1n)).toBe(-9223372036854775808n)
+    expect(value.value).toBe(-9223372036854775808n)
   })
 })

package/gs/sync/atomic/type.gs.ts

@@ -223,20 +223,20 @@ export class Int32 {
 }
 
 export class Int64 {
-	public get v(): number {
+	public get v(): bigint {
 		return this._fields.v.value
 	}
-	public set v(value: number) {
+	public set v(value: bigint) {
 		this._fields.v.value = value
 	}
 
 	public _fields: {
-		v: $.VarRef<number>;
+		v: $.VarRef<bigint>;
 	}
 
-	constructor(init?: Partial<{v?: number}>) {
+	constructor(init?: Partial<{v?: bigint}>) {
 		this._fields = {
-			v: $.varRef(init?.v ?? 0)
+			v: $.varRef(init?.v ?? 0n)
 		}
 	}
 
@@ -249,45 +249,45 @@ export class Int64 {
 	}
 
 	// Load atomically loads and returns the value stored in x.
-	public Load(): number {
+	public Load(): bigint {
 		const x = this
 		return LoadInt64(x._fields.v)
 	}
 
 	// Store atomically stores val into x.
-	public Store(val: number): void {
+	public Store(val: bigint): void {
 		const x = this
 		StoreInt64(x._fields.v, val)
 	}
 
 	// Swap atomically stores new into x and returns the previous value.
-	public Swap(_new: number): number {
+	public Swap(_new: bigint): bigint {
 		const x = this
 		return SwapInt64(x._fields.v, _new)
 	}
 
 	// CompareAndSwap executes the compare-and-swap operation for x.
-	public CompareAndSwap(old: number, _new: number): boolean {
+	public CompareAndSwap(old: bigint, _new: bigint): boolean {
 		const x = this
 		return CompareAndSwapInt64(x._fields.v, old, _new)
 	}
 
 	// Add atomically adds delta to x and returns the new value.
-	public Add(delta: number): number {
+	public Add(delta: bigint): bigint {
 		const x = this
 		return AddInt64(x._fields.v, delta)
 	}
 
 	// And atomically performs a bitwise AND operation on x using the bitmask
 	// provided as mask and returns the old value.
-	public And(mask: number): number {
+	public And(mask: bigint): bigint {
 		const x = this
 		return AndInt64(x._fields.v, mask)
 	}
 
 	// Or atomically performs a bitwise OR operation on x using the bitmask
 	// provided as mask and returns the old value.
-	public Or(mask: number): number {
+	public Or(mask: bigint): bigint {
 		const x = this
 		return OrInt64(x._fields.v, mask)
 	}
@@ -296,9 +296,9 @@ export class Int64 {
 	static __typeInfo = $.registerStructType(
 	  'Int64',
 	  new Int64(),
-	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
+	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "int64" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "int64" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "int64" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "int64" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "int64" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "int64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "int64" } }] }],
 	  Int64,
-	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "int64" } }]
 	);
 }
 
@@ -383,20 +383,20 @@ export class Uint32 {
 }
 
 export class Uint64 {
-	public get v(): number {
+	public get v(): bigint {
 		return this._fields.v.value
 	}
-	public set v(value: number) {
+	public set v(value: bigint) {
 		this._fields.v.value = value
 	}
 
 	public _fields: {
-		v: $.VarRef<number>;
+		v: $.VarRef<bigint>;
 	}
 
-	constructor(init?: Partial<{v?: number}>) {
+	constructor(init?: Partial<{v?: bigint}>) {
 		this._fields = {
-			v: $.varRef(init?.v ?? 0)
+			v: $.varRef(init?.v ?? 0n)
 		}
 	}
 
@@ -409,45 +409,45 @@ export class Uint64 {
 	}
 
 	// Load atomically loads and returns the value stored in x.
-	public Load(): number {
+	public Load(): bigint {
 		const x = this
 		return LoadUint64(x._fields.v)
 	}
 
 	// Store atomically stores val into x.
-	public Store(val: number): void {
+	public Store(val: bigint): void {
 		const x = this
 		StoreUint64(x._fields.v, val)
 	}
 
 	// Swap atomically stores new into x and returns the previous value.
-	public Swap(_new: number): number {
+	public Swap(_new: bigint): bigint {
 		const x = this
 		return SwapUint64(x._fields.v, _new)
 	}
 
 	// CompareAndSwap executes the compare-and-swap operation for x.
-	public CompareAndSwap(old: number, _new: number): boolean {
+	public CompareAndSwap(old: bigint, _new: bigint): boolean {
 		const x = this
 		return CompareAndSwapUint64(x._fields.v, old, _new)
 	}
 
 	// Add atomically adds delta to x and returns the new value.
-	public Add(delta: number): number {
+	public Add(delta: bigint): bigint {
 		const x = this
 		return AddUint64(x._fields.v, delta)
 	}
 
 	// And atomically performs a bitwise AND operation on x using the bitmask
 	// provided as mask and returns the old value.
-	public And(mask: number): number {
+	public And(mask: bigint): bigint {
 		const x = this
 		return AndUint64(x._fields.v, mask)
 	}
 
 	// Or atomically performs a bitwise OR operation on x using the bitmask
 	// provided as mask and returns the old value.
-	public Or(mask: number): number {
+	public Or(mask: bigint): bigint {
 		const x = this
 		return OrUint64(x._fields.v, mask)
 	}
@@ -456,9 +456,9 @@ export class Uint64 {
 	static __typeInfo = $.registerStructType(
 	  'Uint64',
 	  new Uint64(),
-	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
+	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "uint64" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uint64" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "uint64" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uint64" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uint64" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "uint64" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uint64" } }] }],
 	  Uint64,
-	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "uint64" } }]
 	);
 }