goscript 0.2.5 → 0.2.7

package/gs/io/io.ts

@@ -59,7 +59,7 @@ export interface Closer {
 
 // Seeker is the interface that wraps the basic Seek method
 export interface Seeker {
-  Seek(offset: number, whence: number): [number, $.GoError]
+  Seek(offset: bigint, whence: number): [bigint, $.GoError]
 }
 
 // Combined interfaces
@@ -222,12 +222,12 @@ export function Pipe(): [PipeReader, PipeWriter] {
 
 // ReaderAt is the interface that wraps the basic ReadAt method
 export interface ReaderAt {
-  ReadAt(p: $.Bytes, off: number): [number, $.GoError]
+  ReadAt(p: $.Bytes, off: bigint): [number, $.GoError]
 }
 
 // WriterAt is the interface that wraps the basic WriteAt method
 export interface WriterAt {
-  WriteAt(p: $.Bytes, off: number): [number, $.GoError]
+  WriteAt(p: $.Bytes, off: bigint): [number, $.GoError]
 }
 
 // ByteReader is the interface that wraps the ReadByte method
@@ -262,12 +262,12 @@ export interface StringWriter {
 
 // WriterTo is the interface that wraps the WriteTo method
 export interface WriterTo {
-  WriteTo(w: Writer): [number, $.GoError]
+  WriteTo(w: Writer): [bigint, $.GoError]
 }
 
 // ReaderFrom is the interface that wraps the ReadFrom method
 export interface ReaderFrom {
-  ReadFrom(r: Reader): [number, $.GoError]
+  ReadFrom(r: Reader): [bigint, $.GoError]
 }
 
 // Discard is a Writer on which all Write calls succeed without doing anything
@@ -297,25 +297,25 @@ export async function WriteString(
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
 export class LimitedReader implements Reader {
   public R: Reader | null
-  public N: number
+  public N: bigint
 
   constructor(
-    r?: Reader | { R?: Reader | null; N?: number } | null,
-    n?: number,
+    r?: Reader | { R?: Reader | null; N?: bigint } | null,
+    n?: bigint,
   ) {
     if (r != null && typeof (r as { Read?: unknown }).Read !== 'function') {
-      const init = r as { R?: Reader | null; N?: number }
+      const init = r as { R?: Reader | null; N?: bigint }
       this.R = init.R ?? null
-      this.N = init.N ?? 0
+      this.N = init.N ?? 0n
       return
     }
     this.R = (r as Reader | null | undefined) ?? null
-    this.N = n ?? 0
+    this.N = n ?? 0n
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
     return (async (): Promise<[number, $.GoError]> => {
-      if (this.N <= 0) {
+      if (this.N <= 0n) {
         return [0, EOF]
       }
       if (this.R == null) {
@@ -323,19 +323,19 @@ export class LimitedReader implements Reader {
       }
 
       let readBuf = p
-      if ($.len(p) > this.N) {
-        readBuf = $.goSlice(p, 0, this.N)
+      if ($.len(p) > Number(this.N)) {
+        readBuf = $.goSlice(p, 0, Number(this.N))
       }
 
       const [n, err] = await (this.R.Read(readBuf) as any)
-      this.N -= n
+      this.N -= BigInt(n)
       return [n, err]
     })() as any
   }
 }
 
 // LimitReader returns a Reader that reads from r but stops with EOF after n bytes
-export function LimitReader(r: Reader, n: number): Reader {
+export function LimitReader(r: Reader, n: bigint): Reader {
   return new LimitedReader(r, n)
 }
 
@@ -346,11 +346,11 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
   private off: number
   private limit: number
 
-  constructor(r: ReaderAt, off: number, n: number) {
+  constructor(r: ReaderAt, off: bigint, n: bigint) {
     this.r = r
-    this.base = off
-    this.off = off
-    this.limit = off + n
+    this.base = Number(off)
+    this.off = Number(off)
+    this.limit = Number(off) + Number(n)
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
@@ -363,7 +363,7 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
       p = $.goSlice(p, 0, max)
     }
 
-    const res = this.r.ReadAt(p, this.off) as any
+    const res = this.r.ReadAt(p, BigInt(this.off)) as any
     if (res instanceof Promise) {
       return res.then(([n, err]: [number, $.GoError]) => {
         this.off += n
@@ -376,39 +376,41 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
     return [n, err]
   }
 
-  Seek(offset: number, whence: number): [number, $.GoError] {
+  Seek(offset: bigint, whence: number): [bigint, $.GoError] {
+    const offNum = Number(offset)
     let abs: number
     switch (whence) {
       case SeekStart:
-        abs = this.base + offset
+        abs = this.base + offNum
         break
       case SeekCurrent:
-        abs = this.off + offset
+        abs = this.off + offNum
         break
       case SeekEnd:
-        abs = this.limit + offset
+        abs = this.limit + offNum
         break
       default:
-        return [0, newError('io.SectionReader.Seek: invalid whence')]
+        return [0n, newError('io.SectionReader.Seek: invalid whence')]
     }
 
     if (abs < this.base) {
-      return [0, newError('io.SectionReader.Seek: negative position')]
+      return [0n, newError('io.SectionReader.Seek: negative position')]
     }
 
     this.off = abs
-    return [abs - this.base, null]
+    return [BigInt(abs - this.base), null]
   }
 
-  ReadAt(p: $.Bytes, off: number): [number, $.GoError] {
-    if (off < 0 || off >= this.limit - this.base) {
+  ReadAt(p: $.Bytes, off: bigint): [number, $.GoError] {
+    let offNum = Number(off)
+    if (offNum < 0 || offNum >= this.limit - this.base) {
       return [0, EOF]
     }
 
-    off += this.base
-    if (off + $.len(p) > this.limit) {
-      p = $.goSlice(p, 0, this.limit - off)
-      const res = this.r.ReadAt(p, off) as any
+    offNum += this.base
+    if (offNum + $.len(p) > this.limit) {
+      p = $.goSlice(p, 0, this.limit - offNum)
+      const res = this.r.ReadAt(p, BigInt(offNum)) as any
       if (res instanceof Promise) {
         return res.then(([n, err]: [number, $.GoError]) => {
           if (err === null) {
@@ -424,19 +426,19 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
       return [n, err]
     }
 
-    return this.r.ReadAt(p, off)
+    return this.r.ReadAt(p, BigInt(offNum))
   }
 
-  Size(): number {
-    return this.limit - this.base
+  Size(): bigint {
+    return BigInt(this.limit - this.base)
   }
 }
 
 // NewSectionReader returns a SectionReader that reads from r starting at offset off and stops with EOF after n bytes
 export function NewSectionReader(
   r: ReaderAt,
-  off: number,
-  n: number,
+  off: bigint,
+  n: bigint,
 ): SectionReader {
   return new SectionReader(r, off, n)
 }
@@ -447,49 +449,51 @@ export class OffsetWriter implements Writer, WriterAt {
   private base: number
   private off: number
 
-  constructor(w: WriterAt, off: number) {
+  constructor(w: WriterAt, off: bigint) {
     this.w = w
-    this.base = off
+    this.base = Number(off)
     this.off = 0
   }
 
   Write(p: $.Bytes): [number, $.GoError] {
-    const [n, err] = this.w.WriteAt(p, this.base + this.off)
+    const [n, err] = this.w.WriteAt(p, BigInt(this.base + this.off))
     this.off += n
     return [n, err]
   }
 
-  WriteAt(p: $.Bytes, off: number): [number, $.GoError] {
-    if (off < 0) {
+  WriteAt(p: $.Bytes, off: bigint): [number, $.GoError] {
+    const offNum = Number(off)
+    if (offNum < 0) {
       return [0, newError('io.OffsetWriter.WriteAt: negative offset')]
     }
-    return this.w.WriteAt(p, this.base + off)
+    return this.w.WriteAt(p, BigInt(this.base + offNum))
   }
 
-  Seek(offset: number, whence: number): [number, $.GoError] {
+  Seek(offset: bigint, whence: number): [bigint, $.GoError] {
+    const offNum = Number(offset)
     let abs: number
     switch (whence) {
       case SeekStart:
-        abs = offset
+        abs = offNum
         break
       case SeekCurrent:
-        abs = this.off + offset
+        abs = this.off + offNum
         break
       default:
-        return [0, newError('io.OffsetWriter.Seek: invalid whence')]
+        return [0n, newError('io.OffsetWriter.Seek: invalid whence')]
     }
 
     if (abs < 0) {
-      return [0, newError('io.OffsetWriter.Seek: negative position')]
+      return [0n, newError('io.OffsetWriter.Seek: negative position')]
     }
 
     this.off = abs
-    return [abs, null]
+    return [BigInt(abs), null]
   }
 }
 
 // NewOffsetWriter returns an OffsetWriter that writes to w starting at offset off
-export function NewOffsetWriter(w: WriterAt, off: number): OffsetWriter {
+export function NewOffsetWriter(w: WriterAt, off: bigint): OffsetWriter {
   return new OffsetWriter(w, off)
 }
 
@@ -497,7 +501,7 @@ export function NewOffsetWriter(w: WriterAt, off: number): OffsetWriter {
 export async function Copy(
   dst: WriterLike,
   src: ReaderLike,
-): Promise<[number, $.GoError]> {
+): Promise<[bigint, $.GoError]> {
   return await CopyBuffer(dst, src, null)
 }
 
@@ -506,11 +510,11 @@ export async function CopyBuffer(
   dst: WriterLike,
   src: ReaderLike,
   buf: $.Bytes | null,
-): Promise<[number, $.GoError]> {
+): Promise<[bigint, $.GoError]> {
   dst = unwrapWriter(dst)
   src = unwrapReader(src)
   if (dst === null || src === null) {
-    return [0, newError('io: copy with nil reader or writer')]
+    return [0n, newError('io: copy with nil reader or writer')]
   }
 
   // If src implements WriterTo, use it
@@ -527,7 +531,7 @@ export async function CopyBuffer(
     buf = $.makeSlice<number>(32 * 1024, undefined, 'byte') // 32KB default buffer
   }
 
-  let written = 0
+  let written = 0n
   while (true) {
     const [nr, er] = await (src.Read(buf) as any)
     if (nr > 0) {
@@ -538,7 +542,7 @@ export async function CopyBuffer(
         }
         return [written, ew]
       }
-      written += nw
+      written += BigInt(nw)
       if (ew !== null) {
         return [written, ew]
       }
@@ -580,8 +584,8 @@ function unwrapWriter(dst: WriterLike): Writer | null {
 export async function CopyN(
   dst: Writer,
   src: Reader,
-  n: number,
-): Promise<[number, $.GoError]> {
+  n: bigint,
+): Promise<[bigint, $.GoError]> {
   const [written, err] = await Copy(dst, LimitReader(src, n))
   if (written === n) {
     return [written, null]
@@ -636,6 +640,7 @@ export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
   const chunks: $.Bytes[] = []
   let totalLength = 0
   const buf = $.makeSlice<number>(512, undefined, 'byte')
+  let readErr: $.GoError = null
 
   while (true) {
     const [n, err] = await (r.Read(buf) as any)
@@ -646,30 +651,25 @@ export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
       totalLength += n
     }
     if (err !== null) {
-      if (err === EOF) {
-        break
+      // EOF is the normal terminator and is reported as a nil error. Any other
+      // error is returned together with the bytes already read, matching Go.
+      if (err !== EOF) {
+        readErr = err
       }
-      return [$.makeSlice<number>(0, undefined, 'byte'), err]
+      break
     }
   }
 
-  // Combine all chunks
+  // Combine all chunks.
   const result = $.makeSlice<number>(totalLength, undefined, 'byte')
   let offset = 0
   for (const chunk of chunks) {
-    if (chunk instanceof Uint8Array) {
-      // Handle Uint8Array chunks
-      const resultSlice = $.goSlice(result, offset, offset + chunk.length)
-      $.copy(resultSlice, chunk)
-    } else {
-      // Handle Slice<number> chunks
-      const resultSlice = $.goSlice(result, offset, offset + $.len(chunk))
-      $.copy(resultSlice, chunk)
-    }
+    const resultSlice = $.goSlice(result, offset, offset + $.len(chunk))
+    $.copy(resultSlice, chunk)
     offset += $.len(chunk)
   }
 
-  return [result, null]
+  return [result, readErr]
 }
 
 // NopCloser returns a ReadCloser with a no-op Close method wrapping the provided Reader r

package/gs/io/limit.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  EOF,
+  ErrShortBuffer,
+  ErrUnexpectedEOF,
+  LimitReader,
+  NewOffsetWriter,
+  ReadAtLeast,
+} from './index.js'
+
+// A Reader that hands out its data and returns the EOF sentinel once drained,
+// matching Go's convention that a Read may return n>0 with a nil error.
+class chunkReader {
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    if (this.data.length === 0) {
+      return [0, EOF]
+    }
+    const n = Math.min($.len(p), this.data.length)
+    p!.set(this.data.subarray(0, n), 0)
+    this.data = this.data.subarray(n)
+    return [n, null]
+  }
+}
+
+// A WriterAt that records bytes at their absolute offset.
+class bufferWriterAt {
+  public buf: number[] = []
+
+  WriteAt(p: $.Bytes, off: bigint): [number, $.GoError] {
+    const base = Number(off)
+    const bytes = p ?? new Uint8Array(0)
+    for (let i = 0; i < bytes.length; i++) {
+      this.buf[base + i] = bytes[i]
+    }
+    return [$.len(p), null]
+  }
+}
+
+describe('io coverage (Go semantics)', () => {
+  test('LimitReader stops with EOF after n bytes', async () => {
+    const lr = LimitReader(new chunkReader($.stringToBytes('hello world')), 5n)
+    const buf = new Uint8Array(32)
+    const [n, err] = await (lr.Read(buf) as any)
+    expect(n).toBe(5)
+    expect(err).toBeNull()
+    expect($.bytesToString($.goSlice(buf, 0, n))).toBe('hello')
+    const [n2, err2] = await (lr.Read(buf) as any)
+    expect(n2).toBe(0)
+    expect(err2).toBe(EOF)
+  })
+
+  test('NewOffsetWriter writes at the base offset', () => {
+    const w = new bufferWriterAt()
+    const ow = NewOffsetWriter(w, 3n)
+    const [n, err] = ow.Write($.stringToBytes('abc'))
+    expect(n).toBe(3)
+    expect(err).toBeNull()
+    expect(String.fromCharCode(w.buf[3], w.buf[4], w.buf[5])).toBe('abc')
+    expect(w.buf[0]).toBeUndefined()
+  })
+
+  test('ReadAtLeast reads until min and reports short reads', async () => {
+    const buf4 = new Uint8Array(4)
+    const [n, err] = await ReadAtLeast(
+      new chunkReader($.stringToBytes('abcdef')),
+      buf4,
+      4,
+    )
+    expect(n).toBe(4)
+    expect(err).toBeNull()
+    expect($.bytesToString(buf4)).toBe('abcd')
+
+    const buf5 = new Uint8Array(5)
+    const [n2, err2] = await ReadAtLeast(
+      new chunkReader($.stringToBytes('ab')),
+      buf5,
+      4,
+    )
+    expect(n2).toBe(2)
+    expect(err2).toBe(ErrUnexpectedEOF)
+
+    const [n3, err3] = await ReadAtLeast(
+      new chunkReader(new Uint8Array(0)),
+      new Uint8Array(4),
+      4,
+    )
+    expect(n3).toBe(0)
+    expect(err3).toBe(EOF)
+
+    const [n4, err4] = await ReadAtLeast(
+      new chunkReader($.stringToBytes('abcdef')),
+      new Uint8Array(3),
+      5,
+    )
+    expect(n4).toBe(0)
+    expect(err4).toBe(ErrShortBuffer)
+  })
+})

package/gs/math/bits/index.test.ts

@@ -1,14 +1,53 @@
 import { describe, expect, it } from 'vitest'
 
 import {
+  Add,
+  Add32,
+  Add64,
+  Div,
+  Div32,
+  Div64,
+  LeadingZeros16,
+  LeadingZeros32,
+  LeadingZeros64,
+  LeadingZeros8,
+  Len16,
+  Len32,
+  Len64,
+  Len8,
+  Mul,
+  Mul32,
   Mul64,
+  OnesCount,
+  OnesCount16,
+  OnesCount32,
+  OnesCount64,
+  OnesCount8,
   Rem,
   Rem32,
   Rem64,
+  Reverse,
+  Reverse16,
+  Reverse32,
+  Reverse64,
+  Reverse8,
+  ReverseBytes,
+  ReverseBytes16,
+  ReverseBytes32,
+  ReverseBytes64,
+  RotateLeft,
   RotateLeft16,
   RotateLeft32,
   RotateLeft64,
   RotateLeft8,
+  Sub,
+  Sub32,
+  Sub64,
+  TrailingZeros,
+  TrailingZeros16,
+  TrailingZeros32,
+  TrailingZeros64,
+  TrailingZeros8,
 } from './index.js'
 
 describe('math/bits override', () => {
@@ -27,6 +66,20 @@ describe('math/bits override', () => {
     ])
   })
 
+  it('counts leading zeros over the 8/16-bit width, not 32', () => {
+    // Zero must yield the full width, and Len of zero is 0 (Go len8tab[0]).
+    expect(LeadingZeros8(0)).toBe(8)
+    expect(LeadingZeros16(0)).toBe(16)
+    expect(Len8(0)).toBe(0)
+    expect(Len16(0)).toBe(0)
+    // Non-zero values keep their width-relative counts.
+    expect(LeadingZeros8(1)).toBe(7)
+    expect(LeadingZeros8(0xff)).toBe(0)
+    expect(Len8(0xff)).toBe(8)
+    expect(LeadingZeros16(1)).toBe(15)
+    expect(Len16(0x8000)).toBe(16)
+  })
+
   it('returns remainders from double-word division helpers', () => {
     expect(Rem32(1, 0, 3)).toBe(1)
     expect(Rem(1n, 0n, 3n)).toBe(1n)
@@ -34,9 +87,84 @@ describe('math/bits override', () => {
   })
 
   it('rotates right for negative counts', () => {
+    expect(RotateLeft(1n, -1)).toBe(0x8000000000000000n)
     expect(RotateLeft8(1, -1)).toBe(0x80)
     expect(RotateLeft16(1, -1)).toBe(0x8000)
     expect(RotateLeft32(1, -1)).toBe(0x80000000)
     expect(RotateLeft64(1n, -1)).toBe(0x8000000000000000n)
   })
+
+  // Reference values below are produced by Go's math/bits for the same inputs.
+  it('Add carries out of the high bit (Go Add/Add32/Add64)', () => {
+    expect(Add32(0xffffffff, 2, 0)).toEqual([1, 1])
+    expect(Add64(0xffffffffffffffffn, 2n, 0n)).toEqual([1n, 1n])
+    // The width-agnostic dispatcher routes to the 64-bit path.
+    expect(Add(0xffffffffffffffffn, 2n, 0n)).toEqual([1n, 1n])
+  })
+
+  it('Sub borrows below zero (Go Sub/Sub32/Sub64)', () => {
+    expect(Sub32(0, 1, 0)).toEqual([4294967295, 1])
+    expect(Sub64(0n, 1n, 0n)).toEqual([18446744073709551615n, 1n])
+    expect(Sub(0n, 1n, 0n)).toEqual([18446744073709551615n, 1n])
+  })
+
+  it('Mul returns the full double-word product (Go Mul/Mul32/Mul64)', () => {
+    expect(Mul32(0xffffffff, 0xffffffff)).toEqual([4294967294, 1])
+    expect(Mul(0xffffffffffffffffn, 0xffffffffffffffffn)).toEqual([
+      0xfffffffffffffffen,
+      1n,
+    ])
+  })
+
+  it('Div splits a double-word dividend (Go Div/Div32/Div64)', () => {
+    expect(Div32(1, 0, 3)).toEqual([1431655765, 1])
+    expect(Div64(1n, 0n, 3n)).toEqual([6148914691236517205n, 1n])
+    expect(Div(1n, 0n, 3n)).toEqual([6148914691236517205n, 1n])
+  })
+
+  it('OnesCount counts set bits over each width (Go OnesCount*)', () => {
+    expect(OnesCount(0xff)).toBe(8)
+    expect(OnesCount8(0xff)).toBe(8)
+    expect(OnesCount16(0xf0f0)).toBe(8)
+    expect(OnesCount32(0xffffffff)).toBe(32)
+    expect(OnesCount64(0xffffffffffffffffn)).toBe(64)
+  })
+
+  it('TrailingZeros counts low zero bits, full width for zero (Go TrailingZeros*)', () => {
+    expect(TrailingZeros(8)).toBe(3)
+    expect(TrailingZeros8(0x80)).toBe(7)
+    expect(TrailingZeros16(0x8000)).toBe(15)
+    expect(TrailingZeros32(0x10)).toBe(4)
+    expect(TrailingZeros64(0x100000000n)).toBe(32)
+    expect(TrailingZeros8(0)).toBe(8)
+    expect(TrailingZeros16(0)).toBe(16)
+    expect(TrailingZeros32(0)).toBe(32)
+    expect(TrailingZeros64(0n)).toBe(64)
+  })
+
+  it('LeadingZeros32/64 and Len32/64 use the right width (Go)', () => {
+    expect(LeadingZeros32(1)).toBe(31)
+    expect(LeadingZeros32(0)).toBe(32)
+    expect(LeadingZeros64(1n)).toBe(63)
+    expect(LeadingZeros64(0n)).toBe(64)
+    expect(Len32(0x8000)).toBe(16)
+    expect(Len32(0)).toBe(0)
+    expect(Len64(0x100000000n)).toBe(33)
+    expect(Len64(0n)).toBe(0)
+  })
+
+  it('Reverse flips bit order over each width (Go Reverse*)', () => {
+    expect(Reverse8(1)).toBe(128)
+    expect(Reverse16(1)).toBe(32768)
+    expect(Reverse32(1)).toBe(2147483648)
+    expect(Reverse64(1n)).toBe(9223372036854775808n)
+    expect(Reverse(1n)).toBe(9223372036854775808n)
+  })
+
+  it('ReverseBytes flips byte order over each width (Go ReverseBytes*)', () => {
+    expect(ReverseBytes16(0x0102)).toBe(513)
+    expect(ReverseBytes32(0x01020304)).toBe(67305985)
+    expect(ReverseBytes64(0x0102030405060708n)).toBe(578437695752307201n)
+    expect(ReverseBytes(0x0102030405060708n)).toBe(578437695752307201n)
+  })
 })

package/gs/math/bits/index.ts

@@ -31,12 +31,15 @@ export function LeadingZeros(x: Word64): number {
   return LeadingZeros64(x)
 }
 
+// LeadingZeros8 derives from Len8 so that zero yields the full width (8), as in
+// Go. Math.clz32 counts over 32 bits and returns 32 for zero, which would be
+// wrong for the 8-bit width.
 export function LeadingZeros8(x: number): number {
-  return Math.clz32((x & 0xff) << 24)
+  return 8 - Len8(x)
 }
 
 export function LeadingZeros16(x: number): number {
-  return Math.clz32((x & 0xffff) << 16)
+  return 16 - Len16(x)
 }
 
 export function LeadingZeros32(x: number): number {
@@ -285,12 +288,26 @@ export function Len(x: Word64): number {
   return Len64(x)
 }
 
+// Len8 is the bit-length primitive (Go uses a len8tab lookup): the minimum
+// number of bits to represent the low 8 bits of x, and 0 for x == 0.
 export function Len8(x: number): number {
-  return 8 - LeadingZeros8(x)
+  x &= 0xff
+  let n = 0
+  while (x > 0) {
+    x >>= 1
+    n++
+  }
+  return n
 }
 
 export function Len16(x: number): number {
-  return 16 - LeadingZeros16(x)
+  x &= 0xffff
+  let n = 0
+  while (x > 0) {
+    x >>= 1
+    n++
+  }
+  return n
 }
 
 export function Len32(x: number): number {
@@ -310,10 +327,11 @@ export function Mul(x: Word64, y: Word64): [Word64, Word64] {
 }
 
 export function Mul32(x: number, y: number): [number, number] {
-  // For 32-bit multiplication, we can use JavaScript's number precision
-  const result = (x >>> 0) * (y >>> 0)
-  const hi = Math.floor(result / 0x100000000) >>> 0
-  const lo = result >>> 0
+  // The product of two uint32 needs 64 bits, beyond the 53-bit mantissa of a
+  // JS number, so multiply exactly via bigint before splitting hi/lo.
+  const product = BigInt(x >>> 0) * BigInt(y >>> 0)
+  const hi = Number((product >> 32n) & 0xffffffffn)
+  const lo = Number(product & 0xffffffffn)
   return [hi, lo]
 }
 

package/gs/math/copysign.gs.test.ts

@@ -30,7 +30,9 @@ describe('Copysign', () => {
   it('should handle NaN values', () => {
     expect(Number.isNaN(Copysign(Number.NaN, 1))).toBe(true)
     expect(Number.isNaN(Copysign(Number.NaN, -1))).toBe(true)
-    expect(Copysign(5, Number.NaN)).toBe(5) // NaN is positive
+    expect(Copysign(5, Number.NaN)).toBe(5) // quiet NaN sign bit is 0
+    // A negative NaN sign bit is honored, matching Go.
+    expect(Copysign(1, -Number.NaN)).toBe(-1)
   })
 
   it('should handle fractional values', () => {