goscript 0.1.0 → 0.1.2

package/gs/math/bits/index.ts

@@ -4,6 +4,24 @@
 // UintSize is the size of a uint in bits
 export const UintSize = 32 // Assuming 32-bit for JavaScript numbers
 
+type Word64 = number | bigint
+
+const uint64Mask = (1n << 64n) - 1n
+
+function toUint64(x: Word64): bigint {
+  return BigInt(x) & uint64Mask
+}
+
+function useBigIntResult(...values: Word64[]): boolean {
+  return values.some((value) => typeof value === 'bigint')
+}
+
+function word64Result(value: bigint, useBigInt: boolean): Word64 {
+  return useBigInt || value > BigInt(Number.MAX_SAFE_INTEGER) ?
+      value
+    : Number(value)
+}
+
 // --- Leading zeros ---
 export function LeadingZeros(x: number): number {
   return Math.clz32(x >>> 0)
@@ -21,8 +39,9 @@ export function LeadingZeros32(x: number): number {
   return Math.clz32(x >>> 0)
 }
 
-export function LeadingZeros64(x: bigint): number {
+export function LeadingZeros64(x: Word64): number {
   // For 64-bit, we need to handle it differently
+  x = toUint64(x)
   if (x === 0n) return 64
   let count = 0
   let mask = 1n << 63n
@@ -59,7 +78,8 @@ export function TrailingZeros32(x: number): number {
   return count
 }
 
-export function TrailingZeros64(x: bigint): number {
+export function TrailingZeros64(x: Word64): number {
+  x = toUint64(x)
   if (x === 0n) return 64
   let count = 0
   while ((x & 1n) === 0n && count < 64) {
@@ -93,7 +113,8 @@ export function OnesCount32(x: number): number {
   return count
 }
 
-export function OnesCount64(x: bigint): number {
+export function OnesCount64(x: Word64): number {
+  x = toUint64(x)
   let count = 0
   while (x > 0n) {
     count++
@@ -128,12 +149,17 @@ export function RotateLeft32(x: number, k: number): number {
   return ((x << k) | (x >>> (n - k))) >>> 0
 }
 
-export function RotateLeft64(x: bigint, k: number): bigint {
+export function RotateLeft64(x: number, k: number): number
+export function RotateLeft64(x: bigint, k: number): bigint
+export function RotateLeft64(x: Word64, k: number): Word64 {
   const n = 64
   k = k % n
-  const mask = (1n << 64n) - 1n
-  x = x & mask
-  return ((x << BigInt(k)) | (x >> BigInt(n - k))) & mask
+  const useBigInt = useBigIntResult(x)
+  const word = toUint64(x)
+  return word64Result(
+    ((word << BigInt(k)) | (word >> BigInt(n - k))) & uint64Mask,
+    useBigInt,
+  )
 }
 
 // --- Reverse ---
@@ -168,25 +194,35 @@ export function Reverse32(x: number): number {
   return x >>> 0
 }
 
-export function Reverse64(x: bigint): bigint {
+export function Reverse64(x: number): number
+export function Reverse64(x: bigint): bigint
+export function Reverse64(x: Word64): Word64 {
   // Implement 64-bit reverse using similar bit manipulation
-  const mask = (1n << 64n) - 1n
-  x = x & mask
+  const useBigInt = useBigIntResult(x)
+  let word = toUint64(x)
 
   // Swap 32-bit halves
-  x = ((x & 0xffffffff00000000n) >> 32n) | ((x & 0x00000000ffffffffn) << 32n)
+  word =
+    ((word & 0xffffffff00000000n) >> 32n) |
+    ((word & 0x00000000ffffffffn) << 32n)
   // Swap 16-bit chunks
-  x = ((x & 0xffff0000ffff0000n) >> 16n) | ((x & 0x0000ffff0000ffffn) << 16n)
+  word =
+    ((word & 0xffff0000ffff0000n) >> 16n) |
+    ((word & 0x0000ffff0000ffffn) << 16n)
   // Swap 8-bit chunks
-  x = ((x & 0xff00ff00ff00ff00n) >> 8n) | ((x & 0x00ff00ff00ff00ffn) << 8n)
+  word =
+    ((word & 0xff00ff00ff00ff00n) >> 8n) | ((word & 0x00ff00ff00ff00ffn) << 8n)
   // Swap 4-bit chunks
-  x = ((x & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((x & 0x0f0f0f0f0f0f0f0fn) << 4n)
+  word =
+    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
   // Swap 2-bit chunks
-  x = ((x & 0xccccccccccccccccn) >> 2n) | ((x & 0x3333333333333333n) << 2n)
+  word =
+    ((word & 0xccccccccccccccccn) >> 2n) | ((word & 0x3333333333333333n) << 2n)
   // Swap 1-bit chunks
-  x = ((x & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((x & 0x5555555555555555n) << 1n)
+  word =
+    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((word & 0x5555555555555555n) << 1n)
 
-  return x & mask
+  return word64Result(word & uint64Mask, useBigInt)
 }
 
 // --- ReverseBytes ---
@@ -209,20 +245,23 @@ export function ReverseBytes32(x: number): number {
   )
 }
 
-export function ReverseBytes64(x: bigint): bigint {
-  const mask = (1n << 64n) - 1n
-  x = x & mask
-
-  return (
-    (((x & 0xffn) << 56n) |
-      ((x & 0xff00n) << 40n) |
-      ((x & 0xff0000n) << 24n) |
-      ((x & 0xff000000n) << 8n) |
-      ((x & 0xff00000000n) >> 8n) |
-      ((x & 0xff0000000000n) >> 24n) |
-      ((x & 0xff000000000000n) >> 40n) |
-      ((x & 0xff00000000000000n) >> 56n)) &
-    mask
+export function ReverseBytes64(x: number): number
+export function ReverseBytes64(x: bigint): bigint
+export function ReverseBytes64(x: Word64): Word64 {
+  const useBigInt = useBigIntResult(x)
+  const word = toUint64(x)
+
+  return word64Result(
+    (((word & 0xffn) << 56n) |
+      ((word & 0xff00n) << 40n) |
+      ((word & 0xff0000n) << 24n) |
+      ((word & 0xff000000n) << 8n) |
+      ((word & 0xff00000000n) >> 8n) |
+      ((word & 0xff0000000000n) >> 24n) |
+      ((word & 0xff000000000000n) >> 40n) |
+      ((word & 0xff00000000000000n) >> 56n)) &
+      uint64Mask,
+    useBigInt,
   )
 }
 
@@ -243,7 +282,7 @@ export function Len32(x: number): number {
   return 32 - LeadingZeros32(x)
 }
 
-export function Len64(x: bigint): number {
+export function Len64(x: Word64): number {
   return 64 - LeadingZeros64(x)
 }
 
@@ -260,26 +299,20 @@ export function Mul32(x: number, y: number): [number, number] {
   return [hi, lo]
 }
 
-export function Mul64(x: bigint, y: bigint): [bigint, bigint] {
-  const mask32 = 0xffffffffn
-
-  // Split into 32-bit parts
-  const x0 = x & mask32
-  const x1 = x >> 32n
-  const y0 = y & mask32
-  const y1 = y >> 32n
-
-  // Multiply parts
-  const p00 = x0 * y0
-  const p01 = x0 * y1
-  const p10 = x1 * y0
-  const p11 = x1 * y1
+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): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y)
+  x = toUint64(x)
+  y = toUint64(y)
+  const product = x * y
+  const lo = product & uint64Mask
+  const hi = product >> 64n
 
-  // Combine results
-  const lo = p00 + ((p01 + p10) << 32n)
-  const hi = p11 + ((p01 + p10) >> 32n) + (lo < p00 ? 1n : 0n)
-
-  return [hi, lo]
+  return [
+    word64Result(hi & uint64Mask, useBigInt),
+    word64Result(lo, useBigInt),
+  ]
 }
 
 // --- Division functions ---
@@ -302,7 +335,13 @@ export function Div32(hi: number, lo: number, y: number): [number, number] {
   return [Number(quotient), Number(remainder)]
 }
 
-export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint] {
+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): [Word64, Word64] {
+  const useBigInt = useBigIntResult(hi, lo, y)
+  hi = toUint64(hi)
+  lo = toUint64(lo)
+  y = toUint64(y)
   if (y === 0n) {
     throw new Error('division by zero')
   }
@@ -313,7 +352,7 @@ export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint] {
   const quotient = dividend / y
   const remainder = dividend % y
 
-  return [quotient, remainder]
+  return [word64Result(quotient, useBigInt), word64Result(remainder, useBigInt)]
 }
 
 // --- Add and Sub with carry ---
@@ -328,12 +367,14 @@ export function Add32(x: number, y: number, carry: number): [number, number] {
   return [result, carryOut]
 }
 
-export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint] {
-  const mask = (1n << 64n) - 1n
-  const sum = (x & mask) + (y & mask) + (carry & mask)
-  const result = sum & mask
-  const carryOut = sum > mask ? 1n : 0n
-  return [result, carryOut]
+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): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y, carry)
+  const sum = toUint64(x) + toUint64(y) + toUint64(carry)
+  const result = sum & uint64Mask
+  const carryOut = sum > uint64Mask ? 1n : 0n
+  return [word64Result(result, useBigInt), word64Result(carryOut, useBigInt)]
 }
 
 export function Sub(x: number, y: number, borrow: number): [number, number] {
@@ -347,10 +388,12 @@ export function Sub32(x: number, y: number, borrow: number): [number, number] {
   return [result, borrowOut]
 }
 
-export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint] {
-  const mask = (1n << 64n) - 1n
-  const diff = (x & mask) - (y & mask) - (borrow & mask)
-  const result = diff & mask
+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): [Word64, Word64] {
+  const useBigInt = useBigIntResult(x, y, borrow)
+  const diff = toUint64(x) - toUint64(y) - toUint64(borrow)
+  const result = diff & uint64Mask
   const borrowOut = diff < 0n ? 1n : 0n
-  return [result, borrowOut]
+  return [word64Result(result, useBigInt), word64Result(borrowOut, useBigInt)]
 }

package/gs/math/const.gs.test.ts

@@ -69,12 +69,18 @@ describe('Mathematical Constants', () => {
     expect(MaxUint32).toBe(4294967295)
   })
 
-  it('should have correct bigint limits', () => {
-    expect(MaxInt).toBe(9223372036854775807n)
-    expect(MinInt).toBe(-9223372036854775808n)
-    expect(MaxInt64).toBe(9223372036854775807n)
-    expect(MinInt64).toBe(-9223372036854775808n)
+  it('should have correct wide integer limits', () => {
+    expect(MaxInt).toBe(Number(9223372036854775807n))
+    expect(MinInt).toBe(Number(-9223372036854775808n))
+    expect(MaxInt64).toBe(Number(9223372036854775807n))
+    expect(MinInt64).toBe(Number(-9223372036854775808n))
     expect(MaxUint).toBe(0xffffffffffffffffn)
     expect(MaxUint64).toBe(0xffffffffffffffffn)
   })
+
+  it('should typecheck current number-based uint64 comparisons', () => {
+    const counter: number = 0
+    const atLimit: boolean = counter === MaxUint64
+    expect(atLimit).toBe(false)
+  })
 })

package/gs/math/const.gs.ts

@@ -47,10 +47,10 @@ export let SmallestNonzeroFloat64: number = Number.MIN_VALUE
 let intSize: number = (32 << ((~(0 as number) >> 63)))
 
 // MaxInt32 or MaxInt64 depending on intSize.
-export let MaxInt: bigint = 9223372036854775807n
+export let MaxInt: number = 9223372036854775807
 
 // MinInt32 or MinInt64 depending on intSize.
-export let MinInt: bigint = -9223372036854775808n
+export let MinInt: number = -9223372036854775808
 
 // 127
 export let MaxInt8: number = 127
@@ -71,10 +71,10 @@ export let MaxInt32: number = 2147483647
 export let MinInt32: number = -2147483648
 
 // 9223372036854775807
-export let MaxInt64: bigint = 9223372036854775807n
+export let MaxInt64: number = 9223372036854775807
 
 // -9223372036854775808
-export let MinInt64: bigint = -9223372036854775808n
+export let MinInt64: number = -9223372036854775808
 
 // MaxUint32 or MaxUint64 depending on intSize.
 export let MaxUint: bigint = 0xFFFFFFFFFFFFFFFFn
@@ -89,5 +89,4 @@ export let MaxUint16: number = 65535
 export let MaxUint32: number = 4294967295
 
 // 18446744073709551615
-export let MaxUint64: bigint = 0xFFFFFFFFFFFFFFFFn
-
+export let MaxUint64: number | bigint = 0xFFFFFFFFFFFFFFFFn

package/gs/mime/index.ts

@@ -0,0 +1,60 @@
+export function FormatMediaType(
+  t: string,
+  param: Map<string, string> | Record<string, string> | null,
+): string {
+  if (!isToken(t)) {
+    return ''
+  }
+  let out = t
+  const entries =
+    param instanceof Map ?
+      Array.from(param.entries())
+    : Object.entries(param ?? {})
+  entries.sort(([a], [b]) => a.localeCompare(b))
+  for (const [key, value] of entries) {
+    if (!isToken(key)) {
+      return ''
+    }
+    out += formatParam(key, String(value))
+  }
+  return out
+}
+
+function formatParam(key: string, value: string): string {
+  if (isToken(value)) {
+    return `; ${key}=${value}`
+  }
+  return `; ${key}*=utf-8''${percentEncode(value)}`
+}
+
+function isToken(value: string): boolean {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value)
+}
+
+function percentEncode(value: string): string {
+  let out = ''
+  for (const byte of new TextEncoder().encode(value)) {
+    if (
+      (byte >= 0x30 && byte <= 0x39) ||
+      (byte >= 0x41 && byte <= 0x5a) ||
+      (byte >= 0x61 && byte <= 0x7a) ||
+      byte === 0x21 ||
+      byte === 0x23 ||
+      byte === 0x24 ||
+      byte === 0x26 ||
+      byte === 0x2b ||
+      byte === 0x2d ||
+      byte === 0x2e ||
+      byte === 0x5e ||
+      byte === 0x5f ||
+      byte === 0x60 ||
+      byte === 0x7c ||
+      byte === 0x7e
+    ) {
+      out += String.fromCharCode(byte)
+      continue
+    }
+    out += `%${byte.toString(16).toUpperCase().padStart(2, '0')}`
+  }
+  return out
+}

package/gs/net/http/httptest/index.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Handler, Header_Get, Header_Set, MethodGet, NewRequest, StatusPartialContent } from '../index.js'
+import { NewServer, NewUnstartedServer, Server_Start } from './index.js'
+
+describe('net/http/httptest override', () => {
+  it('exports server helpers for typechecked server tests', () => {
+    const handler: Handler = {
+      ServeHTTP: () => undefined,
+    }
+
+    const srv = NewServer(handler)
+    expect(srv.URL).toBe('http://127.0.0.1')
+    expect(srv.Client()).toBeTruthy()
+    expect(srv.Config().Handler).toBe(handler)
+    expect(Server_Start(NewUnstartedServer(handler))?.Error()).toBe(
+      'net/http/httptest: Server.Start is not implemented in GoScript',
+    )
+  })
+
+  it('routes Client.Do through the in-memory server handler', async () => {
+    const srv = NewServer({
+      ServeHTTP(w, r) {
+        Header_Set(w!.Header(), 'Content-Range', 'bytes 0-3/4')
+        const range = Header_Get($.pointerValue(r)!.Header, 'Range')
+        if (range !== 'bytes=0-3') {
+          w!.WriteHeader(400)
+          w!.Write($.stringToBytes(range))
+          return
+        }
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('data'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/pack.kvf', null)
+    expect(reqErr).toBeNull()
+    Header_Set(req!.Header, 'Range', 'bytes=0-3')
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    expect(Header_Get(resp!.Header, 'Content-Range')).toBe('bytes 0-3/4')
+    const buf = new Uint8Array(4)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(4)
+    expect(Buffer.from(buf).toString('utf8')).toBe('data')
+    expect(resp!.Body!.Close()).toBeNull()
+  })
+})

package/gs/net/http/httptest/index.ts

@@ -0,0 +1,120 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as http from '@goscript/net/http/index.js'
+import * as io from '@goscript/io/index.js'
+
+class responseBody implements io.ReadCloser {
+  private reader: bytes.Reader
+
+  constructor(data: $.Bytes) {
+    this.reader = bytes.NewReader(Uint8Array.from(data ?? []))
+  }
+
+  public Read(p: $.Bytes): [number, $.GoError] {
+    return this.reader.Read(p)
+  }
+
+  public Close(): $.GoError {
+    return null
+  }
+}
+
+export class ResponseRecorder implements http.ResponseWriter {
+  public Code = 200
+  public Body = new bytes.Buffer()
+  private headerMap = new http.Header()
+  private wroteHeader = false
+
+  public Header(): http.Header {
+    return this.headerMap
+  }
+
+  public Write(p: $.Slice<number>): [number, $.GoError] {
+    if (!this.wroteHeader) {
+      this.WriteHeader(http.StatusOK)
+    }
+    return this.Body.Write(p)
+  }
+
+  public WriteHeader(statusCode: number): void {
+    if (this.wroteHeader) {
+      return
+    }
+    this.wroteHeader = true
+    this.Code = statusCode
+  }
+
+  public Result(): http.Response {
+    return new http.Response({
+      Body: new responseBody(this.Body.Bytes()),
+      Header: this.headerMap,
+      StatusCode: this.Code,
+    })
+  }
+}
+
+export function NewRecorder(): ResponseRecorder {
+  return new ResponseRecorder()
+}
+
+export function NewRequest(method: string, target: string, body: io.Reader | null): http.Request {
+  const [req, err] = http.NewRequest(method, target, body)
+  if (err != null || req == null) {
+    throw err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+  }
+  return req
+}
+
+export class Server {
+  public URL: string
+  private handler: http.Handler | null
+
+  constructor(init?: Partial<Server> & { Handler?: http.Handler | null }) {
+    this.URL = init?.URL ?? 'http://127.0.0.1'
+    this.handler = init?.Handler ?? null
+  }
+
+  public Client(): http.Client {
+    return new http.Client({ Transport: new serverTransport(this) })
+  }
+
+  public Close(): void {}
+
+  public Config(): http.Server {
+    return new http.Server({ Handler: this.handler })
+  }
+
+  public ServeHTTP(w: http.ResponseWriter | null, r: http.Request | $.VarRef<http.Request> | null): void | Promise<void> {
+    return this.handler?.ServeHTTP(w, r)
+  }
+}
+
+class serverTransport implements http.RoundTripper {
+  constructor(private server: Server) {}
+
+  public RoundTrip(req: http.Request | $.VarRef<http.Request> | null): [http.Response | null, $.GoError] {
+    const request = $.pointerValue<http.Request | null>(req)
+    if (request == null) {
+      return [null, errors.New('net/http: nil Request')]
+    }
+    const recorder = NewRecorder()
+    const served = this.server.ServeHTTP(recorder, request)
+    if (served instanceof Promise) {
+      return [null, errors.New('net/http/httptest: async handlers are not supported by Client.Do')]
+    }
+    return [recorder.Result(), null]
+  }
+}
+
+export function NewServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function NewUnstartedServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function Server_Start(_s: Server | $.VarRef<Server> | null): $.GoError {
+  return errors.New('net/http/httptest: Server.Start is not implemented in GoScript')
+}