goscript 0.0.61 → 0.0.62

package/gs/math/hypot.gs.test.ts

@@ -43,7 +43,9 @@ describe('Hypot', () => {
   it('should handle very large values without overflow', () => {
     const large = 1e150
     const result = Hypot(large, large)
-    expect(result).toBeCloseTo(large * Math.sqrt(2), 5)
+    const expected = large * Math.sqrt(2)
+    // Use relative tolerance for very large numbers
+    expect(Math.abs(result - expected) / expected).toBeLessThan(1e-10)
     expect(IsInf(result, 0)).toBe(false)
   })
 

package/gs/math/pow10.gs.test.ts

@@ -26,10 +26,11 @@ describe('Pow10', () => {
   })
 
   it('should handle large positive exponents', () => {
-    expect(Pow10(100)).toBe(1e100)
-    expect(Pow10(200)).toBe(1e200)
-    expect(Pow10(300)).toBe(1e300)
-    expect(Pow10(308)).toBe(1e308)
+    // Use relative tolerance for very large numbers
+    expect(Math.abs(Pow10(100) - 1e100) / 1e100).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(200) - 1e200) / 1e200).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(300) - 1e300) / 1e300).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(308) - 1e308) / 1e308).toBeLessThan(1e-10)
     expect(Pow10(309)).toBe(Number.POSITIVE_INFINITY)
     expect(Pow10(400)).toBe(Number.POSITIVE_INFINITY)
   })

package/gs/reflect/index.ts

@@ -35,19 +35,20 @@ export { Swapper } from './swapper.js'
 // Export new types and constants
 export {
   StructTag,
+  StructTag_Get,
   StructField,
   ValueError,
-  SelectDir,
   SelectSend,
   SelectRecv,
   SelectDefault,
+  SelectCase,
   bitVector,
 } from './types.js'
 export type {
   uintptr,
   Pointer,
   Method,
-  SelectCase,
+  SelectDir,
   SliceHeader,
   StringHeader,
   MapIter,

package/gs/reflect/map.test.ts

@@ -11,20 +11,21 @@ describe('MapIter', () => {
     const iter = new MapIter<string, number>(map)
 
     expect(iter.current?.done === false).toBe(true)
-    expect(iter.Key()).toBe('one')
-    expect(iter.Value()).toBe(1)
+    // Key() and Value() return reflect.Value objects now
+    expect(iter.Key().Interface()).toBe('one')
+    expect(iter.Value().Interface()).toBe(1)
 
     expect(iter.Next()).toBe(true)
     expect(iter.current?.done === false).toBe(true)
-    expect(typeof iter.Key()).toBe('string')
-    expect(typeof iter.Value()).toBe('number')
+    expect(iter.Key().Kind()).toBe(24) // String kind
+    expect(iter.Value().Kind()).toBe(2) // Int kind
 
     const newMap = new Map<string, number>()
     newMap.set('reset', 100)
     iter.Reset(newMap)
 
     expect(iter.current?.done === false).toBe(true)
-    expect(iter.Key()).toBe('reset')
-    expect(iter.Value()).toBe(100)
+    expect(iter.Key().Interface()).toBe('reset')
+    expect(iter.Value().Interface()).toBe(100)
   })
 })

package/gs/reflect/map.ts

@@ -1,4 +1,4 @@
-import { Type, Kind, Value, Map as MapKind } from './type.js'
+import { Type, Kind, Value, Map as MapKind, StructField, TypeOf } from './type.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -20,26 +20,66 @@ class MapType implements Type {
     return MapKind // Map kind
   }
 
+  public Name(): string {
+    return '' // Map types are unnamed composite types
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
-  public Key(): Type | null {
+  public Key(): Type {
     return this._keyType
   }
 
   public NumField(): number {
     return 0
   }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type map')
+  }
+
+  public Implements(u: Type | null): boolean {
+    if (!u) {
+      return false
+    }
+    if (u.Kind() !== 20) {
+      // Interface kind
+      throw new Error('reflect: non-interface type passed to Type.Implements')
+    }
+    return false
+  }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: OverflowInt of non-integer type map')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: OverflowUint of non-integer type map')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: OverflowFloat of non-float type map')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: Bits of non-sized type map')
+  }
 }
 
 /**
  * MapIter provides an iterator interface for Go maps.
  * It wraps a JavaScript Map iterator and provides methods to iterate over key-value pairs.
+ * Returns reflect.Value for Key() and Value() to match Go's reflect.MapIter.
  * @template K - The type of keys in the map
  * @template V - The type of values in the map
  */
@@ -57,12 +97,14 @@ export class MapIter<K = unknown, V = unknown> {
     return !this.current.done
   }
 
-  public Key(): K | null {
-    return this.current?.value?.[0] ?? null
+  public Key(): Value {
+    const rawKey = this.current?.value?.[0] ?? null
+    return new Value(rawKey, TypeOf(rawKey))
   }
 
-  public Value(): V | null {
-    return this.current?.value?.[1] ?? null
+  public Value(): Value {
+    const rawVal = this.current?.value?.[1] ?? null
+    return new Value(rawVal, TypeOf(rawVal))
   }
 
   public Reset(m: Map<K, V>): void {