goscript 0.2.6 → 0.2.7

package/gs/bytes/bytes.gs.ts

@@ -638,22 +638,19 @@ export function ToTitle(s: $.Bytes): $.Bytes {
 // ToUpperSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
 // upper case, giving priority to the special casing rules.
 export function ToUpperSpecial(c: unicode.SpecialCase, s: $.Bytes): $.Bytes {
-	// For now, ignore special case and fall back to regular ToUpper
-	return ToUpper(s)
+	return Map((r) => c.ToUpper(r), s)
 }
 
 // ToLowerSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
 // lower case, giving priority to the special casing rules.
 export function ToLowerSpecial(c: unicode.SpecialCase, s: $.Bytes): $.Bytes {
-	// For now, ignore special case and fall back to regular ToLower
-	return ToLower(s)
+	return Map((r) => c.ToLower(r), s)
 }
 
 // ToTitleSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
 // title case, giving priority to the special casing rules.
 export function ToTitleSpecial(c: unicode.SpecialCase, s: $.Bytes): $.Bytes {
-	// For now, ignore special case and fall back to regular ToTitle
-	return ToTitle(s)
+	return Map((r) => c.ToTitle(r), s)
 }
 
 // ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes
@@ -1124,38 +1121,40 @@ export function Replace(s: $.Bytes, old: $.Bytes, _new: $.Bytes, n: number): $.B
 		return new Uint8Array($.bytesToArray(s))
 	}
 	
-	// Handle empty old pattern - replace at beginning and after each UTF-8 sequence
+	// Handle empty old pattern - matches at the start and after each UTF-8
+	// sequence, yielding up to runeCount+1 insertions. After the insertion
+	// limit is reached the untouched remainder of s is appended, as in Go.
 	if (old === null || $.len(old) === 0) {
 		const result: number[] = []
 		const newBytes = _new === null ? [] : $.bytesToArray(_new)
-		
-		// Add replacement at beginning
-		if (n !== 0) {
-			result.push(...newBytes)
-			if (n > 0) n--
-		}
-		
-		// Add replacement after each UTF-8 sequence
-		for (let i = 0; i < $.len(s) && n !== 0; ) {
+
+		// Count runes to bound n the way Go's Count does for an empty pattern.
+		let runeCount = 0
+		for (let i = 0; i < $.len(s); ) {
 			const [, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
-			if (size <= 0) {
-				result.push(s![i])
-				i++
-			} else {
-				// Add the rune bytes
-				for (let j = 0; j < size; j++) {
-					result.push(s![i + j])
+			i += size > 0 ? size : 1
+			runeCount++
+		}
+		const limit = n < 0 ? runeCount + 1 : Math.min(n, runeCount + 1)
+
+		let start = 0
+		for (let ins = 0; ins < limit; ins++) {
+			if (ins > 0) {
+				const [, size] = utf8.DecodeRune($.goSlice(s, start, undefined))
+				const wid = size > 0 ? size : 1
+				for (let j = 0; j < wid; j++) {
+					result.push(s![start + j])
 				}
-				i += size
-			}
-			
-			// Add replacement after this rune
-			if (n !== 0) {
-				result.push(...newBytes)
-				if (n > 0) n--
+				start += wid
 			}
+			result.push(...newBytes)
 		}
-		
+
+		// Append the untouched remainder after the last insertion.
+		for (let j = start; j < $.len(s); j++) {
+			result.push(s![j])
+		}
+
 		return new Uint8Array(result)
 	}
 	
@@ -1226,18 +1225,32 @@ export function EqualFold(s: $.Bytes, t: $.Bytes): boolean {
 			if (s![si] !== t![ti]) return false
 			si++
 			ti++
-		} else {
-			// Convert both to lowercase for comparison
-			const sLower = unicode.ToLower(sr)
-			const tLower = unicode.ToLower(tr)
-			
-			if (sLower !== tLower) return false
-			
-			si += ssize
-			ti += tsize
+			continue
+		}
+		si += ssize
+		ti += tsize
+		let a = sr
+		let b = tr
+		if (a === b) continue
+		if (b < a) {
+			const tmp = a
+			a = b
+			b = tmp
 		}
+		if (b < 0x80) {
+			// ASCII: a and b match only as the same letter in opposite case.
+			if (a >= 0x41 && a <= 0x5a && b === a + 0x20) continue
+			return false
+		}
+		// Walk the simple-fold orbit of the smaller rune toward the larger.
+		let r = unicode.SimpleFold(a)
+		while (r !== a && r < b) {
+			r = unicode.SimpleFold(r)
+		}
+		if (r === b) continue
+		return false
 	}
-	
+
 	return si === $.len(s) && ti === $.len(t)
 }
 

package/gs/bytes/bytes.test.ts

@@ -1,8 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
-import { IndexFunc } from './index.js'
+import { IndexFunc, Replace } from './index.js'
 import { describe, expect, test } from 'vitest'
 
+const rep = (s: string, old: string, n: string, count: number): string =>
+  $.bytesToString(
+    Replace(
+      $.stringToBytes(s),
+      $.stringToBytes(old),
+      $.stringToBytes(n),
+      count,
+    ),
+  )
+
 describe('bytes', () => {
+  test('Replace with empty old appends the untouched remainder', () => {
+    // Go: bytes.Replace([]byte("abc"), []byte(""), []byte("-"), 2) => "-a-bc".
+    expect(rep('abc', '', '-', 2)).toBe('-a-bc')
+    expect(rep('abc', '', '-', -1)).toBe('-a-b-c-')
+    expect(rep('aaa', 'a', 'b', -1)).toBe('bbb')
+  })
+
   test('IndexFunc accepts generated async-shaped callbacks', () => {
     const predicate: (r: number) => boolean | Promise<boolean> = (r) =>
       r === 0x62

package/gs/bytes/reader.gs.ts

@@ -160,29 +160,28 @@ export class Reader {
 	}
 
 	// Seek implements the [io.Seeker] interface.
-	public Seek(offset: number, whence: number): [number, $.GoError] {
+	public Seek(offset: bigint, whence: number): [bigint, $.GoError] {
 		const r = this
 		r.prevRune = -1
 		let abs: number = 0
 		switch (whence) {
 			case io.SeekStart:
-				abs = offset
+				abs = Number(offset)
 				break
 			case io.SeekCurrent:
-				abs = r.i + offset
+				abs = r.i + Number(offset)
 				break
 			case io.SeekEnd:
-				abs = ($.len(r.s) as number) + offset
+				abs = ($.len(r.s) as number) + Number(offset)
 				break
 			default:
-				return [0, errors.New("bytes.Reader.Seek: invalid whence")]
-				break
+				return [0n, errors.New("bytes.Reader.Seek: invalid whence")]
 		}
 		if (abs < 0) {
-			return [0, errors.New("bytes.Reader.Seek: negative position")]
+			return [0n, errors.New("bytes.Reader.Seek: negative position")]
 		}
 		r.i = abs
-		return [abs, null]
+		return [BigInt(abs), null]
 	}
 
 	// WriteTo implements the [io.WriterTo] interface.

package/gs/cmp/index.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+
+import { Compare, Less, Or } from './index.js'
+
+describe('cmp.Compare', () => {
+  it('orders ordinary values', () => {
+    expect(Compare(1, 2)).toBe(-1)
+    expect(Compare(2, 1)).toBe(1)
+    expect(Compare(2, 2)).toBe(0)
+    expect(Compare('a', 'b')).toBe(-1)
+  })
+
+  it('orders NaN below every non-NaN value (Go cmp.Compare)', () => {
+    expect(Compare(Number.NaN, 1)).toBe(-1)
+    expect(Compare(1, Number.NaN)).toBe(1)
+    expect(Compare(Number.NaN, Number.NEGATIVE_INFINITY)).toBe(-1)
+  })
+
+  it('treats two NaNs as equal', () => {
+    expect(Compare(Number.NaN, Number.NaN)).toBe(0)
+  })
+
+  it('treats -0 and 0 as equal', () => {
+    expect(Compare(-0, 0)).toBe(0)
+  })
+})
+
+describe('cmp.Less', () => {
+  it('reports NaN as less than any non-NaN value', () => {
+    expect(Less(Number.NaN, 1)).toBe(true)
+    expect(Less(1, Number.NaN)).toBe(false)
+    expect(Less(Number.NaN, Number.NaN)).toBe(false)
+  })
+
+  it('reports ordinary ordering', () => {
+    expect(Less(1, 2)).toBe(true)
+    expect(Less(2, 1)).toBe(false)
+  })
+})
+
+describe('cmp.Or', () => {
+  it('returns the first non-zero comparison', () => {
+    expect(Or(0, 0, -1, 1)).toBe(-1)
+    expect(Or(0, 0)).toBe(0)
+  })
+
+  it('returns the first non-zero value for any comparable type', () => {
+    expect(Or('', 'default')).toBe('default')
+    expect(Or('first', 'second')).toBe('first')
+    expect(Or(false, true)).toBe(true)
+    expect(Or(0n, 5n)).toBe(5n)
+    expect(Or('', '')).toBe('')
+    expect(Or(false, false)).toBe(false)
+  })
+})

package/gs/cmp/index.ts

@@ -8,22 +8,58 @@ export type Ordered = number | string | boolean | bigint
 // -1 if a < b
 //  0 if a == b
 //  1 if a > b
+// Floating-point NaN orders below every non-NaN value and equals itself, as in
+// Go's cmp.Compare; raw JS < / > would report two incomparable NaNs as equal.
 export function Compare<T extends Ordered>(a: T, b: T): number {
-  if (a < b) return -1
-  if (a > b) return 1
+  const aNaN = Number.isNaN(a as unknown as number)
+  const bNaN = Number.isNaN(b as unknown as number)
+  if (aNaN && bNaN) return 0
+  if (aNaN || a < b) return -1
+  if (bNaN || a > b) return 1
   return 0
 }
 
-// Less reports whether a < b
+// Less reports whether a < b, treating NaN as less than any non-NaN value to
+// match Go's cmp.Less.
 export function Less<T extends Ordered>(a: T, b: T): boolean {
-  return a < b
+  return (
+    (Number.isNaN(a as unknown as number) &&
+      !Number.isNaN(b as unknown as number)) ||
+    a < b
+  )
 }
 
 // Or returns the first non-zero result from the comparison functions,
-// or zero if all comparisons return zero
-export function Or(...comparisons: number[]): number {
-  for (const cmp of comparisons) {
-    if (cmp !== 0) return cmp
+// isZeroValue reports whether v equals the zero value for its comparable kind,
+// matching Go's `val != zero` test in cmp.Or. Scalars compare against their
+// typed zero; pointers, interfaces, maps, slices, channels, and funcs are zero
+// only when nil.
+function isZeroValue(v: unknown): boolean {
+  switch (typeof v) {
+    case 'number':
+      return v === 0
+    case 'bigint':
+      return v === 0n
+    case 'string':
+      return v === ''
+    case 'boolean':
+      return v === false
+    case 'undefined':
+      return true
+    default:
+      return v === null
   }
-  return 0
+}
+
+// Or returns the first of its arguments that is not equal to that comparable
+// type's zero value, or the zero value if every argument is zero, as in Go's
+// cmp.Or. The earlier number-only implementation treated the empty string,
+// false, and 0n as non-zero.
+export function Or<T>(...vals: T[]): T {
+  for (const v of vals) {
+    if (!isZeroValue(v)) {
+      return v
+    }
+  }
+  return vals.length > 0 ? vals[vals.length - 1] : (undefined as T)
 }

package/gs/context/context.ts

@@ -209,7 +209,7 @@ class timerContext extends cancelContext {
   }
 
   startTimer(): void {
-    const duration = this.deadline.Sub(time.Now()) / 1000000
+    const duration = Number(this.deadline.Sub(time.Now())) / 1000000
 
     if (duration <= 0) {
       // Already expired
@@ -341,7 +341,7 @@ export function WithDeadlineCause(
 // WithTimeout returns WithDeadline(parent, Date.now() + timeout)
 export function WithTimeout(
   parent: Context,
-  timeout: number,
+  timeout: time.Duration,
 ): [ContextNonNil, CancelFunc] {
   return WithDeadline(parent, time.Now().Add(timeout))
 }
@@ -349,7 +349,7 @@ export function WithTimeout(
 // WithTimeoutCause is like WithTimeout but also sets the cause
 export function WithTimeoutCause(
   parent: Context,
-  timeout: number,
+  timeout: time.Duration,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
   return WithDeadlineCause(parent, time.Now().Add(timeout), cause)

package/gs/embed/index.ts

@@ -201,8 +201,8 @@ class embedFileInfo {
     return this.name
   }
 
-  Size(): number {
-    return this.size
+  Size(): bigint {
+    return BigInt(this.size)
   }
 
   Sys(): null {

package/gs/encoding/binary/index.test.ts

@@ -236,4 +236,108 @@ describe('encoding/binary override', () => {
       BigEndian.PutUint32($.makeSlice<number>(1, undefined, 'byte'), 1),
     ).toThrow('runtime error: index out of range [3] with length 1')
   })
+
+  it('sizes, appends, and decodes complex64 and complex128', () => {
+    const c128 = $.namedValueInterfaceValue<unknown>(
+      { real: 1.5, imag: 2.5 },
+      'complex128',
+      {},
+      { kind: $.TypeKind.Basic, name: 'complex128' },
+    )
+    expect(Size(c128)).toBe(16)
+    const [enc128, err128] = Append(null, BigEndian, c128)
+    expect(err128).toBeNull()
+    expect(Array.from($.bytesToUint8Array(enc128))).toEqual([
+      0x3f, 0xf8, 0, 0, 0, 0, 0, 0, 0x40, 0x04, 0, 0, 0, 0, 0, 0,
+    ])
+
+    const ref128 = $.varRef<unknown>({ real: 0, imag: 0 })
+    const target128 = $.namedValueInterfaceValue<unknown>(
+      ref128,
+      '*complex128',
+      {},
+      {
+        kind: $.TypeKind.Pointer,
+        elemType: { kind: $.TypeKind.Basic, name: 'complex128' },
+      },
+    )
+    expect(Decode(enc128, BigEndian, target128)).toEqual([16, null])
+    expect(ref128.value).toEqual({ real: 1.5, imag: 2.5 })
+
+    const c64 = $.namedValueInterfaceValue<unknown>(
+      { real: 1, imag: -1 },
+      'complex64',
+      {},
+      { kind: $.TypeKind.Basic, name: 'complex64' },
+    )
+    expect(Size(c64)).toBe(8)
+  })
+
+  it('sizes, appends, and decodes fixed-size structs field by field', () => {
+    const structInfo: $.TypeInfo = {
+      kind: $.TypeKind.Struct,
+      name: 'Sample',
+      methods: [],
+      fields: [
+        {
+          name: 'A',
+          key: 'A',
+          type: { kind: $.TypeKind.Basic, name: 'int32' },
+        },
+        {
+          name: 'B',
+          key: 'B',
+          type: { kind: $.TypeKind.Basic, name: 'uint16' },
+        },
+        {
+          name: 'C',
+          key: 'C',
+          type: {
+            kind: $.TypeKind.Array,
+            length: 2,
+            elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+          },
+        },
+      ],
+    }
+
+    const instance = {
+      _fields: {
+        A: $.varRef(0x01020304),
+        B: $.varRef(0x0506),
+        C: $.varRef([0xaa, 0xbb]),
+      },
+    }
+    const value = $.namedValueInterfaceValue<unknown>(
+      instance,
+      'Sample',
+      {},
+      structInfo,
+    )
+
+    expect(Size(value)).toBe(8)
+    const [encoded, err] = Append(null, BigEndian, value)
+    expect(err).toBeNull()
+    expect(Array.from($.bytesToUint8Array(encoded))).toEqual([
+      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xaa, 0xbb,
+    ])
+
+    const decodedInstance = {
+      _fields: {
+        A: $.varRef(0),
+        B: $.varRef(0),
+        C: $.varRef([0, 0]),
+      },
+    }
+    const target = $.namedValueInterfaceValue<unknown>(
+      $.varRef(decodedInstance),
+      '*Sample',
+      {},
+      { kind: $.TypeKind.Pointer, elemType: structInfo },
+    )
+    expect(Decode(encoded, BigEndian, target)).toEqual([8, null])
+    expect(decodedInstance._fields.A.value).toBe(0x01020304)
+    expect(decodedInstance._fields.B.value).toBe(0x0506)
+    expect(decodedInstance._fields.C.value).toEqual([0xaa, 0xbb])
+  })
 })