goscript 0.1.2 → 0.1.4

package/gs/io/io.test.ts

@@ -0,0 +1,135 @@
+import * as $ from '@goscript/builtin/index.js'
+import { LimitedReader, MultiWriter, NopCloser, Pipe, TeeReader } from './index.js'
+import { describe, expect, test } from 'vitest'
+
+class sliceReader {
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    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, n === 0 ? (new Error('EOF') as $.GoError) : null]
+  }
+}
+
+class captureWriter {
+  public chunks: number[] = []
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    this.chunks.push(...Array.from(p ?? []))
+    return [$.len(p), null]
+  }
+}
+
+describe('io override', () => {
+  test('LimitedReader accepts generated struct-literal construction', async () => {
+    const reader = new LimitedReader({
+      R: new sliceReader($.stringToBytes('abcdef')),
+      N: 3,
+    })
+    const buf = new Uint8Array(8)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('abc')
+  })
+
+  test('TeeReader accepts nullable generated interface values', async () => {
+    const writer = new captureWriter()
+    const reader = TeeReader(new sliceReader($.stringToBytes('abc')), writer)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(writer.chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('NopCloser accepts nullable generated interface values', () => {
+    const reader: sliceReader | null = new sliceReader($.stringToBytes('abc'))
+    const body = NopCloser(reader)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = body.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(body.Close()).toBeNull()
+  })
+
+  test('TeeReader awaits async readers and writers', async () => {
+    const chunks: number[] = []
+    const reader = TeeReader(
+      {
+        async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          p!.set($.stringToBytes('abc'), 0)
+          return [3, null]
+        },
+      } as any,
+      {
+        async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          chunks.push(...Array.from(p ?? []))
+          return [$.len(p), null]
+        },
+      } as any,
+    )
+    const buf = new Uint8Array(4)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('MultiWriter accepts nullable generated interface values', async () => {
+    const first = new captureWriter()
+    const second = new captureWriter()
+    const writer = MultiWriter(first, second)
+
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(first.chunks).toString('utf8')).toBe('abc')
+    expect(Buffer.from(second.chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('MultiWriter awaits async generated writers', async () => {
+    const chunks: number[] = []
+    const writer = MultiWriter({
+      async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        chunks.push(...Array.from(p ?? []))
+        return [$.len(p), null]
+      },
+    })
+
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('PipeReader waits for a later write', async () => {
+    const [reader, writer] = Pipe()
+    const buf = new Uint8Array(5)
+
+    const read = reader.Read(buf)
+    const [written, writeErr] = await writer.Write($.stringToBytes('later'))
+    const [readBytes, readErr] = await read
+
+    expect(writeErr).toBeNull()
+    expect(written).toBe(5)
+    expect(readErr).toBeNull()
+    expect(readBytes).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('later')
+  })
+})

package/gs/io/io.ts

@@ -72,67 +72,111 @@ export interface WriteSeeker extends Writer, Seeker {}
 export interface ReadWriteSeeker extends Reader, Writer, Seeker {}
 
 class pipeState {
-  private chunks: Uint8Array[] = []
-  private readOffset = 0
   private readerClosed = false
   private writerClosed = false
   private readerErr: $.GoError = null
   private writerErr: $.GoError = null
-
-  Read(p: $.Bytes): [number, $.GoError] {
-    if (this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    if ($.len(p) === 0) {
-      return [0, null]
-    }
-    if (this.chunks.length === 0) {
+  private pendingReads: Array<{
+    data: $.Bytes
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+  private pendingWrites: Array<{
+    data: Uint8Array
+    offset: number
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+
+  Read(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      if (this.pendingWrites.length > 0) {
+        return this.consumeNextWrite(p)
+      }
       if (this.writerClosed) {
         return [0, this.writerErr ?? EOF]
       }
-      return [0, EOF]
-    }
-
-    let copied = 0
-    while (copied < $.len(p) && this.chunks.length > 0) {
-      const chunk = this.chunks[0]
-      const available = chunk.length - this.readOffset
-      const want = Math.min($.len(p) - copied, available)
-      const target = $.goSlice(p, copied, copied + want)
-      $.copy(target, chunk.subarray(this.readOffset, this.readOffset + want))
-      copied += want
-      this.readOffset += want
-      if (this.readOffset === chunk.length) {
-        this.chunks.shift()
-        this.readOffset = 0
-      }
-    }
-    return [copied, null]
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingReads.push({ data: p, resolve })
+      })
+    })()
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
-    if (this.writerClosed || this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    const data = new Uint8Array($.len(p))
-    $.copy(data, p)
-    this.chunks.push(data)
-    return [$.len(p), null]
+  Write(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.writerClosed || this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      const data = new Uint8Array($.len(p))
+      $.copy(data, p)
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingWrites.push({ data, offset: 0, resolve })
+        this.drain()
+      })
+    })()
   }
 
   CloseReader(err: $.GoError): $.GoError {
     this.readerClosed = true
     this.readerErr = err
-    this.chunks = []
-    this.readOffset = 0
+    this.resolvePendingReads(ErrClosedPipe)
+    this.resolvePendingWrites(ErrClosedPipe)
     return null
   }
 
   CloseWriter(err: $.GoError): $.GoError {
     this.writerClosed = true
     this.writerErr = err
+    if (this.pendingWrites.length === 0) {
+      this.resolvePendingReads(err ?? EOF)
+    }
     return null
   }
+
+  private drain(): void {
+    while (this.pendingWrites.length > 0 && this.pendingReads.length > 0) {
+      if (this.readerClosed) {
+        this.resolvePendingWrites(this.readerErr ?? ErrClosedPipe)
+        return
+      }
+      const pending = this.pendingReads.shift()!
+      pending.resolve(this.consumeNextWrite(pending.data))
+    }
+  }
+
+  private consumeNextWrite(p: $.Bytes): [number, $.GoError] {
+    const pending = this.pendingWrites[0]
+    const n = Math.min($.len(p), pending.data.length - pending.offset)
+    $.copy(p, pending.data.subarray(pending.offset, pending.offset + n))
+    pending.offset += n
+    if (pending.offset === pending.data.length) {
+      this.pendingWrites.shift()
+      pending.resolve([pending.data.length, null])
+      if (this.writerClosed && this.pendingWrites.length === 0) {
+        this.resolvePendingReads(this.writerErr ?? EOF)
+      }
+    }
+    return [n, null]
+  }
+
+  private resolvePendingReads(err: $.GoError): void {
+    while (this.pendingReads.length > 0) {
+      this.pendingReads.shift()!.resolve([0, err])
+    }
+  }
+
+  private resolvePendingWrites(err: $.GoError): void {
+    while (this.pendingWrites.length > 0) {
+      this.pendingWrites.shift()!.resolve([0, err])
+    }
+  }
 }
 
 // PipeReader is the read half of a pipe.
@@ -140,7 +184,7 @@ export class PipeReader implements Reader, Closer {
   constructor(private pipe: pipeState) {}
 
   Read(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Read(data)
+    return this.pipe.Read(data) as any
   }
 
   Close(): $.GoError {
@@ -157,7 +201,7 @@ export class PipeWriter implements Writer, Closer {
   constructor(private pipe: pipeState) {}
 
   Write(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Write(data)
+    return this.pipe.Write(data) as any
   }
 
   Close(): $.GoError {
@@ -232,28 +276,40 @@ class DiscardWriter implements Writer {
   }
 }
 
-export const Discard: Writer = new DiscardWriter()
+export const Discard: Writer | null = new DiscardWriter()
 
 // WriteString writes the contents of the string s to w, which accepts a slice of bytes
-export function WriteString(w: Writer, s: string): [number, $.GoError] {
+export async function WriteString(
+  w: Writer,
+  s: string,
+): Promise<[number, $.GoError]> {
   // Check if w implements StringWriter interface
   if ('WriteString' in w && typeof (w as any).WriteString === 'function') {
-    return (w as StringWriter).WriteString(s)
+    return await ((w as StringWriter).WriteString(s) as any)
   }
 
   // Convert string to bytes and write
   const bytes = new TextEncoder().encode(s)
-  return w.Write(bytes)
+  return await (w.Write(bytes) as any)
 }
 
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
 export class LimitedReader implements Reader {
-  public R: Reader
+  public R: Reader | null
   public N: number
 
-  constructor(r: Reader, n: number) {
-    this.R = r
-    this.N = n
+  constructor(
+    r?: Reader | { R?: Reader | null; N?: number } | null,
+    n?: number,
+  ) {
+    if (r != null && typeof (r as { Read?: unknown }).Read !== 'function') {
+      const init = r as { R?: Reader | null; N?: number }
+      this.R = init.R ?? null
+      this.N = init.N ?? 0
+      return
+    }
+    this.R = (r as Reader | null | undefined) ?? null
+    this.N = n ?? 0
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
@@ -261,6 +317,9 @@ export class LimitedReader implements Reader {
       if (this.N <= 0) {
         return [0, EOF]
       }
+      if (this.R == null) {
+        throw new Error('io.LimitedReader: nil reader')
+      }
 
       let readBuf = p
       if ($.len(p) > this.N) {
@@ -596,7 +655,15 @@ export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
 }
 
 // NopCloser returns a ReadCloser with a no-op Close method wrapping the provided Reader r
-export function NopCloser(r: Reader): ReadCloser {
+export function NopCloser(r: Reader | null): ReadCloser {
+  if (r == null) {
+    return {
+      Read: () => {
+        throw new Error('nil Reader')
+      },
+      Close: () => null,
+    }
+  }
   return {
     Read: r.Read.bind(r),
     Close: () => null,
@@ -645,20 +712,23 @@ class multiReader implements Reader {
 }
 
 // MultiWriter creates a writer that duplicates its writes to all the provided writers
-export function MultiWriter(...writers: Writer[]): Writer {
-  return new multiWriter(writers.slice())
+export function MultiWriter(...writers: (Writer | null)[]): Writer {
+  return new multiWriter(writers.slice()) as any
 }
 
-class multiWriter implements Writer {
-  private writers: Writer[]
+class multiWriter {
+  private writers: (Writer | null)[]
 
-  constructor(writers: Writer[]) {
+  constructor(writers: (Writer | null)[]) {
     this.writers = writers
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
+  async Write(p: $.Bytes): Promise<[number, $.GoError]> {
     for (const w of this.writers) {
-      const [n, err] = w.Write(p)
+      if (w == null) {
+        throw new Error('io.MultiWriter: nil writer')
+      }
+      const [n, err] = await w.Write(p)
       if (err !== null) {
         return [n, err]
       }
@@ -671,23 +741,33 @@ class multiWriter implements Writer {
 }
 
 // TeeReader returns a Reader that writes to w what it reads from r
-export function TeeReader(r: Reader, w: Writer): Reader {
+export function TeeReader(r: Reader | null, w: Writer | null): Reader {
   return new teeReader(r, w)
 }
 
 class teeReader implements Reader {
-  private r: Reader
-  private w: Writer
+  private r: Reader | null
+  private w: Writer | null
 
-  constructor(r: Reader, w: Writer) {
+  constructor(r: Reader | null, w: Writer | null) {
     this.r = r
     this.w = w
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
-    const [n, err] = this.r.Read(p)
+    return this.read(p) as any
+  }
+
+  private async read(p: $.Bytes): Promise<[number, $.GoError]> {
+    if (this.r == null) {
+      throw new Error('io.TeeReader: nil reader')
+    }
+    const [n, err] = await this.r.Read(p)
     if (n > 0) {
-      const [nw, ew] = this.w.Write($.goSlice(p, 0, n))
+      if (this.w == null) {
+        throw new Error('io.TeeReader: nil writer')
+      }
+      const [nw, ew] = await this.w.Write($.goSlice(p, 0, n))
       if (ew !== null) {
         return [n, ew]
       }

package/gs/io/meta.json

@@ -12,6 +12,12 @@
     "CopyN": true,
     "ReadAtLeast": true,
     "ReadFull": true,
-    "ReadAll": true
+    "ReadAll": true,
+    "WriteString": true
+  },
+  "asyncMethods": {
+    "PipeReader.Read": true,
+    "PipeWriter.Write": true,
+    "TeeReader.Read": true
   }
 }

package/gs/math/bits/index.ts

@@ -2,7 +2,7 @@
 // This replaces the auto-generated version that has TypeScript syntax errors
 
 // UintSize is the size of a uint in bits
-export const UintSize = 32 // Assuming 32-bit for JavaScript numbers
+export const UintSize = 64
 
 type Word64 = number | bigint
 
@@ -23,8 +23,8 @@ function word64Result(value: bigint, useBigInt: boolean): Word64 {
 }
 
 // --- Leading zeros ---
-export function LeadingZeros(x: number): number {
-  return Math.clz32(x >>> 0)
+export function LeadingZeros(x: Word64): number {
+  return LeadingZeros64(x)
 }
 
 export function LeadingZeros8(x: number): number {
@@ -53,9 +53,8 @@ export function LeadingZeros64(x: Word64): number {
 }
 
 // --- Trailing zeros ---
-export function TrailingZeros(x: number): number {
-  if (x === 0) return UintSize
-  return TrailingZeros32(x)
+export function TrailingZeros(x: Word64): number {
+  return TrailingZeros64(x)
 }
 
 export function TrailingZeros8(x: number): number {
@@ -90,8 +89,8 @@ export function TrailingZeros64(x: Word64): number {
 }
 
 // --- Ones count ---
-export function OnesCount(x: number): number {
-  return OnesCount32(x)
+export function OnesCount(x: Word64): number {
+  return OnesCount64(x)
 }
 
 export function OnesCount8(x: number): number {
@@ -124,8 +123,11 @@ export function OnesCount64(x: Word64): number {
 }
 
 // --- Rotate left ---
-export function RotateLeft(x: number, k: number): number {
-  return RotateLeft32(x, k)
+export function RotateLeft(x: number, k: number): number
+export function RotateLeft(x: bigint, k: number): bigint
+export function RotateLeft(x: Word64, k: number): number
+export function RotateLeft(x: Word64, k: number): Word64 {
+  return RotateLeft64(x, k)
 }
 
 export function RotateLeft8(x: number, k: number): number {
@@ -151,6 +153,7 @@ export function RotateLeft32(x: number, k: number): number {
 
 export function RotateLeft64(x: number, k: number): number
 export function RotateLeft64(x: bigint, k: number): bigint
+export function RotateLeft64(x: Word64, k: number): number
 export function RotateLeft64(x: Word64, k: number): Word64 {
   const n = 64
   k = k % n
@@ -163,8 +166,11 @@ export function RotateLeft64(x: Word64, k: number): Word64 {
 }
 
 // --- Reverse ---
-export function Reverse(x: number): number {
-  return Reverse32(x)
+export function Reverse(x: number): number
+export function Reverse(x: bigint): bigint
+export function Reverse(x: Word64): number
+export function Reverse(x: Word64): Word64 {
+  return Reverse64(x)
 }
 
 export function Reverse8(x: number): number {
@@ -196,6 +202,7 @@ export function Reverse32(x: number): number {
 
 export function Reverse64(x: number): number
 export function Reverse64(x: bigint): bigint
+export function Reverse64(x: Word64): number
 export function Reverse64(x: Word64): Word64 {
   // Implement 64-bit reverse using similar bit manipulation
   const useBigInt = useBigIntResult(x)
@@ -226,8 +233,11 @@ export function Reverse64(x: Word64): Word64 {
 }
 
 // --- ReverseBytes ---
-export function ReverseBytes(x: number): number {
-  return ReverseBytes32(x)
+export function ReverseBytes(x: number): number
+export function ReverseBytes(x: bigint): bigint
+export function ReverseBytes(x: Word64): number
+export function ReverseBytes(x: Word64): Word64 {
+  return ReverseBytes64(x)
 }
 
 export function ReverseBytes16(x: number): number {
@@ -247,6 +257,7 @@ export function ReverseBytes32(x: number): number {
 
 export function ReverseBytes64(x: number): number
 export function ReverseBytes64(x: bigint): bigint
+export function ReverseBytes64(x: Word64): number
 export function ReverseBytes64(x: Word64): Word64 {
   const useBigInt = useBigIntResult(x)
   const word = toUint64(x)
@@ -266,8 +277,8 @@ export function ReverseBytes64(x: Word64): Word64 {
 }
 
 // --- Len ---
-export function Len(x: number): number {
-  return Len32(x)
+export function Len(x: Word64): number {
+  return Len64(x)
 }
 
 export function Len8(x: number): number {
@@ -287,8 +298,11 @@ export function Len64(x: Word64): number {
 }
 
 // --- Multiplication functions ---
-export function Mul(x: number, y: number): [number, number] {
-  return Mul32(x, y)
+export function Mul(x: number, y: number): [number, number]
+export function Mul(x: bigint, y: bigint): [bigint, bigint]
+export function Mul(x: Word64, y: Word64): [number, number]
+export function Mul(x: Word64, y: Word64): [Word64, Word64] {
+  return Mul64(x, y)
 }
 
 export function Mul32(x: number, y: number): [number, number] {
@@ -301,6 +315,7 @@ export function Mul32(x: number, y: number): [number, number] {
 
 export function Mul64(x: number, y: number): [number, number]
 export function Mul64(x: bigint, y: bigint): [bigint, bigint]
+export function Mul64(x: Word64, y: Word64): [number, number]
 export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y)
   x = toUint64(x)
@@ -309,15 +324,15 @@ export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const lo = product & uint64Mask
   const hi = product >> 64n
 
-  return [
-    word64Result(hi & uint64Mask, useBigInt),
-    word64Result(lo, useBigInt),
-  ]
+  return [word64Result(hi & uint64Mask, useBigInt), word64Result(lo, useBigInt)]
 }
 
 // --- Division functions ---
-export function Div(hi: number, lo: number, y: number): [number, number] {
-  return Div32(hi, lo, y)
+export function Div(hi: number, lo: number, y: number): [number, number]
+export function Div(hi: bigint, lo: bigint, y: bigint): [bigint, bigint]
+export function Div(hi: Word64, lo: Word64, y: Word64): [number, number]
+export function Div(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
+  return Div64(hi, lo, y)
 }
 
 export function Div32(hi: number, lo: number, y: number): [number, number] {
@@ -337,6 +352,7 @@ export function Div32(hi: number, lo: number, y: number): [number, number] {
 
 export function Div64(hi: number, lo: number, y: number): [number, number]
 export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint]
+export function Div64(hi: Word64, lo: Word64, y: Word64): [number, number]
 export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(hi, lo, y)
   hi = toUint64(hi)
@@ -356,8 +372,11 @@ export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
 }
 
 // --- Add and Sub with carry ---
-export function Add(x: number, y: number, carry: number): [number, number] {
-  return Add32(x, y, carry)
+export function Add(x: number, y: number, carry: number): [number, number]
+export function Add(x: bigint, y: bigint, carry: bigint): [bigint, bigint]
+export function Add(x: Word64, y: Word64, carry: Word64): [number, number]
+export function Add(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
+  return Add64(x, y, carry)
 }
 
 export function Add32(x: number, y: number, carry: number): [number, number] {
@@ -369,6 +388,7 @@ export function Add32(x: number, y: number, carry: number): [number, number] {
 
 export function Add64(x: number, y: number, carry: number): [number, number]
 export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint]
+export function Add64(x: Word64, y: Word64, carry: Word64): [number, number]
 export function Add64(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y, carry)
   const sum = toUint64(x) + toUint64(y) + toUint64(carry)
@@ -377,8 +397,11 @@ export function Add64(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
   return [word64Result(result, useBigInt), word64Result(carryOut, useBigInt)]
 }
 
-export function Sub(x: number, y: number, borrow: number): [number, number] {
-  return Sub32(x, y, borrow)
+export function Sub(x: number, y: number, borrow: number): [number, number]
+export function Sub(x: bigint, y: bigint, borrow: bigint): [bigint, bigint]
+export function Sub(x: Word64, y: Word64, borrow: Word64): [number, number]
+export function Sub(x: Word64, y: Word64, borrow: Word64): [Word64, Word64] {
+  return Sub64(x, y, borrow)
 }
 
 export function Sub32(x: number, y: number, borrow: number): [number, number] {
@@ -390,6 +413,7 @@ export function Sub32(x: number, y: number, borrow: number): [number, number] {
 
 export function Sub64(x: number, y: number, borrow: number): [number, number]
 export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint]
+export function Sub64(x: Word64, y: Word64, borrow: Word64): [number, number]
 export function Sub64(x: Word64, y: Word64, borrow: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y, borrow)
   const diff = toUint64(x) - toUint64(y) - toUint64(borrow)