goscript 0.1.3 → 0.2.0

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
 
@@ -22,9 +22,13 @@ function word64Result(value: bigint, useBigInt: boolean): Word64 {
     : Number(value)
 }
 
+function rotateCount(k: number, n: number): number {
+  return ((k % n) + n) % n
+}
+
 // --- 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 +57,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 +93,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,36 +127,40 @@ 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 {
   const n = 8
-  k = k % n
+  k = rotateCount(k, n)
   x = x & 0xff
   return ((x << k) | (x >> (n - k))) & 0xff
 }
 
 export function RotateLeft16(x: number, k: number): number {
   const n = 16
-  k = k % n
+  k = rotateCount(k, n)
   x = x & 0xffff
   return ((x << k) | (x >> (n - k))) & 0xffff
 }
 
 export function RotateLeft32(x: number, k: number): number {
   const n = 32
-  k = k % n
+  k = rotateCount(k, n)
   x = x >>> 0 // Ensure unsigned
   return ((x << k) | (x >>> (n - k))) >>> 0
 }
 
 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
+  k = rotateCount(k, n)
   const useBigInt = useBigIntResult(x)
   const word = toUint64(x)
   return word64Result(
@@ -163,8 +170,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 +206,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 +237,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 +261,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 +281,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 +302,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 +319,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 +328,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 +356,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)
@@ -355,9 +375,27 @@ export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
   return [word64Result(quotient, useBigInt), word64Result(remainder, useBigInt)]
 }
 
+export function Rem(hi: Word64, lo: Word64, y: Word64): Word64 {
+  return Div(hi, lo, y)[1]
+}
+
+export function Rem32(hi: number, lo: number, y: number): number {
+  return Div32(hi, lo, y)[1]
+}
+
+export function Rem64(hi: number, lo: number, y: number): number
+export function Rem64(hi: bigint, lo: bigint, y: bigint): bigint
+export function Rem64(hi: Word64, lo: Word64, y: Word64): number
+export function Rem64(hi: Word64, lo: Word64, y: Word64): Word64 {
+  return Div64(hi, lo, y)[1]
+}
+
 // --- 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 +407,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 +416,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 +432,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)

package/gs/math/bits/parity.json

@@ -0,0 +1,156 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Add": {
+      "status": "real"
+    },
+    "Add32": {
+      "status": "real"
+    },
+    "Add64": {
+      "status": "real"
+    },
+    "Div": {
+      "status": "real"
+    },
+    "Div32": {
+      "status": "real"
+    },
+    "Div64": {
+      "status": "real"
+    },
+    "LeadingZeros": {
+      "status": "real"
+    },
+    "LeadingZeros16": {
+      "status": "real"
+    },
+    "LeadingZeros32": {
+      "status": "real"
+    },
+    "LeadingZeros64": {
+      "status": "real"
+    },
+    "LeadingZeros8": {
+      "status": "real"
+    },
+    "Len": {
+      "status": "real"
+    },
+    "Len16": {
+      "status": "real"
+    },
+    "Len32": {
+      "status": "real"
+    },
+    "Len64": {
+      "status": "real"
+    },
+    "Len8": {
+      "status": "real"
+    },
+    "Mul": {
+      "status": "real"
+    },
+    "Mul32": {
+      "status": "real"
+    },
+    "Mul64": {
+      "status": "real"
+    },
+    "OnesCount": {
+      "status": "real"
+    },
+    "OnesCount16": {
+      "status": "real"
+    },
+    "OnesCount32": {
+      "status": "real"
+    },
+    "OnesCount64": {
+      "status": "real"
+    },
+    "OnesCount8": {
+      "status": "real"
+    },
+    "Rem": {
+      "status": "real"
+    },
+    "Rem32": {
+      "status": "real"
+    },
+    "Rem64": {
+      "status": "real"
+    },
+    "Reverse": {
+      "status": "real"
+    },
+    "Reverse16": {
+      "status": "real"
+    },
+    "Reverse32": {
+      "status": "real"
+    },
+    "Reverse64": {
+      "status": "real"
+    },
+    "Reverse8": {
+      "status": "real"
+    },
+    "ReverseBytes": {
+      "status": "real"
+    },
+    "ReverseBytes16": {
+      "status": "real"
+    },
+    "ReverseBytes32": {
+      "status": "real"
+    },
+    "ReverseBytes64": {
+      "status": "real"
+    },
+    "RotateLeft": {
+      "status": "real"
+    },
+    "RotateLeft16": {
+      "status": "real"
+    },
+    "RotateLeft32": {
+      "status": "real"
+    },
+    "RotateLeft64": {
+      "status": "real"
+    },
+    "RotateLeft8": {
+      "status": "real"
+    },
+    "Sub": {
+      "status": "real"
+    },
+    "Sub32": {
+      "status": "real"
+    },
+    "Sub64": {
+      "status": "real"
+    },
+    "TrailingZeros": {
+      "status": "real"
+    },
+    "TrailingZeros16": {
+      "status": "real"
+    },
+    "TrailingZeros32": {
+      "status": "real"
+    },
+    "TrailingZeros64": {
+      "status": "real"
+    },
+    "TrailingZeros8": {
+      "status": "real"
+    },
+    "UintSize": {
+      "status": "real"
+    }
+  }
+}

package/gs/mime/index.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  AddExtensionType,
+  BEncoding,
+  ErrInvalidMediaParameter,
+  ExtensionsByType,
+  FormatMediaType,
+  ParseMediaType,
+  QEncoding,
+  TypeByExtension,
+  WordDecoder,
+  WordEncoder_Encode,
+} from './index.js'
+
+describe('mime override', () => {
+  it('parses, formats, and looks up media types', () => {
+    const [mediaType, params, err] = ParseMediaType(
+      'Text/Plain; Charset="utf-8"; format=flowed',
+    )
+    expect(err).toBeNull()
+    expect(mediaType).toBe('text/plain')
+    expect(params.get('charset')).toBe('utf-8')
+    expect(params.get('format')).toBe('flowed')
+    const [trailingMediaType, trailingParams, trailingErr] = ParseMediaType('text/plain;')
+    expect(trailingErr).toBeNull()
+    expect(trailingMediaType).toBe('text/plain')
+    expect(trailingParams.size).toBe(0)
+
+    expect(
+      FormatMediaType('text/plain', new Map([['charset', 'utf-8']])),
+    ).toBe('text/plain; charset=utf-8')
+    expect(
+      FormatMediaType('Attachment', new Map([['FileName', 'hello.txt']])),
+    ).toBe('attachment; filename=hello.txt')
+    expect(
+      FormatMediaType('attachment', new Map([['filename', 'foo bar.txt']])),
+    ).toBe('attachment; filename="foo bar.txt"')
+    expect(
+      FormatMediaType('text/plain', new Map([
+        ['z', 'last'],
+        ['a', 'first'],
+      ])),
+    ).toBe('text/plain; a=first; z=last')
+
+    const encoded = FormatMediaType(
+      'attachment',
+      new Map([['filename', 'résumé.txt']]),
+    )
+    expect(encoded).toBe("attachment; filename*=utf-8''r%C3%A9sum%C3%A9.txt")
+    const [, encodedParams, encodedErr] = ParseMediaType(encoded)
+    expect(encodedErr).toBeNull()
+    expect(encodedParams.get('filename')).toBe('résumé.txt')
+    const [, pathParams, pathErr] = ParseMediaType('form-data; filename="C:\\dev\\go.txt"; quoted="a\\"b"')
+    expect(pathErr).toBeNull()
+    expect(pathParams.get('filename')).toBe('C:\\dev\\go.txt')
+    expect(pathParams.get('quoted')).toBe('a"b')
+
+    expect(TypeByExtension('.json')).toBe('application/json')
+    expect(AddExtensionType('.goscript', 'text/plain; charset=utf-8')).toBeNull()
+    const [extensions, extensionErr] = ExtensionsByType('text/plain')
+    expect(extensionErr).toBeNull()
+    expect(extensions).toContain('.goscript')
+  })
+
+  it('reports invalid media parameters', () => {
+    const [, , err] = ParseMediaType('text/plain; broken')
+    expect(err).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; filename=foo bar')[2]).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; filename="unterminated')[2]).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; x=1; x=2')[2]).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; bad[]=x')[2]).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; bad{}=x')[1].get('bad{}')).toBe('x')
+  })
+
+  it('encodes and decodes RFC 2047 words', () => {
+    expect(WordEncoder_Encode(BEncoding, 'utf-8', 'hello')).toBe('hello')
+
+    const bWord = WordEncoder_Encode(BEncoding, 'utf-8', 'héllo')
+    expect(new WordDecoder().Decode(bWord)).toEqual(['héllo', null])
+
+    const qWord = WordEncoder_Encode(QEncoding, 'utf-8', 'hello world')
+    expect(qWord).toBe('hello world')
+
+    const encodedQWord = WordEncoder_Encode(QEncoding, 'utf-8', 'héllo world')
+    const [header, err] = new WordDecoder().DecodeHeader(`subject ${encodedQWord}`)
+    expect(err).toBeNull()
+    expect(header).toBe('subject héllo world')
+  })
+})