goscript 0.0.39 → 0.0.41

package/gs/sort/index.ts

@@ -0,0 +1,24 @@
+export {
+  Find,
+  Search,
+  SearchFloat64s,
+  SearchInts,
+  SearchStrings,
+} from './search.gs'
+export { Slice, SliceIsSorted, SliceStable } from './slice.gs'
+export {
+  Float64Slice,
+  Float64s,
+  Float64sAreSorted,
+  IntSlice,
+  Ints,
+  IntsAreSorted,
+  IsSorted,
+  Reverse,
+  Sort,
+  Stable,
+  StringSlice,
+  Strings,
+  StringsAreSorted,
+} from './sort.gs'
+export type { Interface } from './sort.gs'

package/gs/sort/search.gs.ts

@@ -0,0 +1,128 @@
+import * as $ from "@goscript/builtin/index.js";
+
+// Search uses binary search to find and return the smallest index i
+// in [0, n) at which f(i) is true, assuming that on the range [0, n),
+// f(i) == true implies f(i+1) == true. That is, Search requires that
+// f is false for some (possibly empty) prefix of the input range [0, n)
+// and then true for the (possibly empty) remainder; Search returns
+// the first true index. If there is no such index, Search returns n.
+// (Note that the "not found" return value is not -1 as in, for instance,
+// strings.Index.)
+// Search calls f(i) only for i in the range [0, n).
+//
+// A common use of Search is to find the index i for a value x in
+// a sorted, indexable data structure such as an array or slice.
+// In this case, the argument f, typically a closure, captures the value
+// to be searched for, and how the data structure is indexed and
+// ordered.
+//
+// For instance, given a slice data sorted in ascending order,
+// the call Search(len(data), func(i int) bool { return data[i] >= 23 })
+// returns the smallest index i such that data[i] >= 23. If the caller
+// wants to find whether 23 is in the slice, it must test data[i] == 23
+// separately.
+//
+// Searching data sorted in descending order would use the <=
+// operator instead of the >= operator.
+//
+// To complete the example above, the following code tries to find the value
+// x in an integer slice data sorted in ascending order:
+//
+//	x := 23
+//	i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
+//	if i < len(data) && data[i] == x {
+//		// x is present at data[i]
+//	} else {
+//		// x is not present in data,
+//		// but i is the index where it would be inserted.
+//	}
+//
+// As a more whimsical example, this program guesses your number:
+//
+//	func GuessingGame() {
+//		var s string
+//		fmt.Printf("Pick an integer from 0 to 100.\n")
+//		answer := sort.Search(100, func(i int) bool {
+//			fmt.Printf("Is your number <= %d? ", i)
+//			fmt.Scanf("%s", &s)
+//			return s != "" && s[0] == 'y'
+//		})
+//		fmt.Printf("Your number is %d.\n", answer)
+//	}
+export function Search(n: number, f: (i: number) => boolean): number {
+	let left = 0
+	let right = n
+	while (left < right) {
+		const mid = Math.floor((left + right) / 2)
+		if (f(mid)) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	return left
+}
+
+// Find uses binary search to find and return the smallest index i in [0, n)
+// at which cmp(i) <= 0. If there is no such index i, Find returns i = n.
+// The found result is true if i < n and cmp(i) == 0.
+// Find calls cmp(i) only for i in the range [0, n).
+//
+// To permit binary search, Find requires that cmp(i) > 0 for a leading
+// prefix of the range, cmp(i) == 0 in the middle, and cmp(i) < 0 for
+// the final suffix of the range. (Each subrange could be empty.)
+// The usual way to establish this condition is to interpret cmp(i)
+// as a comparison of a desired target value t against entry i in an
+// underlying indexed data structure x, returning <0, 0, and >0
+// when t < x[i], t == x[i], and t > x[i], respectively.
+//
+// For example, to look for a particular string in a sorted, random-access
+// list of strings:
+//
+//	i, found := sort.Find(x.Len(), func(i int) int {
+//	    return strings.Compare(target, x.At(i))
+//	})
+//	if found {
+//	    fmt.Printf("found %s at entry %d\n", target, i)
+//	} else {
+//	    fmt.Printf("%s not found, would insert at %d", target, i)
+//	}
+export function Find(n: number, cmp: (i: number) => number): [number, boolean] {
+	let left = 0
+	let right = n
+	while (left < right) {
+		const mid = Math.floor((left + right) / 2)
+		if (cmp(mid) <= 0) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	const found = left < n && cmp(left) === 0
+	return [left, found]
+}
+
+// SearchInts searches for x in a sorted slice of ints and returns the index
+// as specified by Search. The return value is the index to insert x if x is
+// not present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchInts(a: $.Slice<number>, x: number): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as number) >= x)
+}
+
+// SearchFloat64s searches for x in a sorted slice of float64s and returns the index
+// as specified by Search. The return value is the index to insert x if x is not
+// present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchFloat64s(a: $.Slice<number>, x: number): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as number) >= x)
+}
+
+// SearchStrings searches for x in a sorted slice of strings and returns the index
+// as specified by Search. The return value is the index to insert x if x is not
+// present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchStrings(a: $.Slice<string>, x: string): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as string) >= x)
+}
+

package/gs/sort/slice.gs.ts

@@ -0,0 +1,59 @@
+import * as $ from "@goscript/builtin/index.js";
+
+// Helper type for slice metadata
+interface SliceMetadata<T> {
+  backing: T[]
+  offset: number
+  length: number
+  capacity: number
+}
+
+// Helper function to swap elements in a slice
+function swapInSlice<T>(slice: $.Slice<T>, i: number, j: number): void {
+  if (!slice) return
+  
+  const temp = $.index(slice, i)
+  if (Array.isArray(slice)) {
+    const val_j = $.index(slice, j)
+    const val_i = temp
+    slice[i] = val_j as T
+    slice[j] = val_i as T
+  } else if (typeof slice === 'object' && '__meta__' in slice) {
+    const meta = (slice as any).__meta__ as SliceMetadata<T>
+    const backing = meta.backing
+    backing[meta.offset + i] = $.index(slice, j) as T
+    backing[meta.offset + j] = temp as T
+  }
+}
+
+// Slice sorts the slice x given the provided less function
+export function Slice(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+  if (!x) return
+  
+  // Simple insertion sort using the provided less function
+  const n = $.len(x)
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && less(j, j - 1); j--) {
+      swapInSlice(x, j, j - 1)
+    }
+  }
+}
+
+// SliceIsSorted reports whether the slice x is sorted according to the provided less function
+export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => boolean): boolean {
+  if (!x) return true
+  
+  const n = $.len(x)
+  for (let i = n - 1; i > 0; i--) {
+    if (less(i, i - 1)) {
+      return false
+    }
+  }
+  return true
+}
+
+// SliceStable sorts the slice x while keeping the original order of equal elements
+export function SliceStable(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+  // For simplicity, use the same sort - can be improved later
+  Slice(x, less)
+} 

package/gs/sort/sort.gs.ts

@@ -0,0 +1,227 @@
+import * as $ from '@goscript/builtin/index.js'
+
+// Interface defines the methods required for sorting
+export interface Interface {
+  Len(): number
+  Less(i: number, j: number): boolean
+  Swap(i: number, j: number): void
+}
+
+// Helper type for slice metadata
+interface SliceMetadata<T> {
+  backing: T[]
+  offset: number
+  length: number
+  capacity: number
+}
+
+// IntSlice type for sorting integers
+export class IntSlice {
+  constructor(private _value: $.Slice<number>) {}
+
+  Len(): number {
+    return $.len(this._value)
+  }
+
+  Less(i: number, j: number): boolean {
+    return ($.index(this._value, i) as number) < ($.index(this._value, j) as number)
+  }
+
+  Swap(i: number, j: number): void {
+    const temp = $.index(this._value, i) as number
+    if (Array.isArray(this._value)) {
+      this._value[i] = $.index(this._value, j) as number
+      this._value[j] = temp
+    } else if (this._value && typeof this._value === 'object' && '__meta__' in this._value) {
+      const meta = (this._value as any).__meta__ as SliceMetadata<number>
+      const backing = meta.backing
+      backing[meta.offset + i] = $.index(this._value, j) as number
+      backing[meta.offset + j] = temp
+    }
+  }
+}
+
+// Float64Slice type for sorting float64s
+export class Float64Slice {
+  constructor(private _value: $.Slice<number>) {}
+
+  Len(): number {
+    return $.len(this._value)
+  }
+
+  Less(i: number, j: number): boolean {
+    return ($.index(this._value, i) as number) < ($.index(this._value, j) as number)
+  }
+
+  Swap(i: number, j: number): void {
+    const temp = $.index(this._value, i) as number
+    if (Array.isArray(this._value)) {
+      this._value[i] = $.index(this._value, j) as number
+      this._value[j] = temp
+    } else if (this._value && typeof this._value === 'object' && '__meta__' in this._value) {
+      const meta = (this._value as any).__meta__ as SliceMetadata<number>
+      const backing = meta.backing
+      backing[meta.offset + i] = $.index(this._value, j) as number
+      backing[meta.offset + j] = temp
+    }
+  }
+}
+
+// StringSlice type for sorting strings
+export class StringSlice {
+  constructor(private _value: $.Slice<string>) {}
+
+  Len(): number {
+    return $.len(this._value)
+  }
+
+  Less(i: number, j: number): boolean {
+    return ($.index(this._value, i) as string) < ($.index(this._value, j) as string)
+  }
+
+  Swap(i: number, j: number): void {
+    const temp = $.index(this._value, i) as string
+    if (Array.isArray(this._value)) {
+      this._value[i] = $.index(this._value, j) as string
+      this._value[j] = temp
+    } else if (this._value && typeof this._value === 'object' && '__meta__' in this._value) {
+      const meta = (this._value as any).__meta__ as SliceMetadata<string>
+      const backing = meta.backing
+      backing[meta.offset + i] = $.index(this._value, j) as string
+      backing[meta.offset + j] = temp
+    }
+  }
+}
+
+// Sort sorts data in ascending order as determined by the Less method
+export function Sort(data: Interface): void {
+  // Use a simple insertion sort for now - can be optimized later
+  const n = data.Len()
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && data.Less(j, j - 1); j--) {
+      data.Swap(j, j - 1)
+    }
+  }
+}
+
+// Stable sorts data while keeping the original order of equal elements
+export function Stable(data: Interface): void {
+  // For simplicity, use the same sort - can be improved later
+  Sort(data)
+}
+
+// IsSorted reports whether data is sorted
+export function IsSorted(data: Interface): boolean {
+  const n = data.Len()
+  for (let i = n - 1; i > 0; i--) {
+    if (data.Less(i, i - 1)) {
+      return false
+    }
+  }
+  return true
+}
+
+// Reverse returns the reverse order for data
+export function Reverse(data: Interface): Interface {
+  return {
+    Len: () => data.Len(),
+    Less: (i: number, j: number) => data.Less(j, i),
+    Swap: (i: number, j: number) => data.Swap(i, j)
+  }
+}
+
+// Helper function to swap elements in a slice
+function swapInSlice<T>(slice: $.Slice<T>, i: number, j: number): void {
+  if (!slice) return
+  
+  const temp = $.index(slice, i)
+  if (Array.isArray(slice)) {
+    const val_j = $.index(slice, j)
+    const val_i = temp
+    slice[i] = val_j as T
+    slice[j] = val_i as T
+  } else if (typeof slice === 'object' && '__meta__' in slice) {
+    const meta = (slice as any).__meta__ as SliceMetadata<T>
+    const backing = meta.backing
+    backing[meta.offset + i] = $.index(slice, j) as T
+    backing[meta.offset + j] = temp as T
+  }
+}
+
+// Ints sorts a slice of ints in increasing order
+export function Ints(x: $.Slice<number>): void {
+  if (!x) return
+  
+  const n = $.len(x)
+  // Simple insertion sort
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && ($.index(x, j) as number) < ($.index(x, j - 1) as number); j--) {
+      swapInSlice(x, j, j - 1)
+    }
+  }
+}
+
+// IntsAreSorted reports whether the slice x is sorted in increasing order
+export function IntsAreSorted(x: $.Slice<number>): boolean {
+  if (!x) return true
+  
+  const n = $.len(x)
+  for (let i = n - 1; i > 0; i--) {
+    if (($.index(x, i) as number) < ($.index(x, i - 1) as number)) {
+      return false
+    }
+  }
+  return true
+}
+
+// Float64s sorts a slice of float64s in increasing order
+export function Float64s(x: $.Slice<number>): void {
+  if (!x) return
+  
+  const n = $.len(x)
+  // Simple insertion sort
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && ($.index(x, j) as number) < ($.index(x, j - 1) as number); j--) {
+      swapInSlice(x, j, j - 1)
+    }
+  }
+}
+
+// Float64sAreSorted reports whether the slice x is sorted in increasing order
+export function Float64sAreSorted(x: $.Slice<number>): boolean {
+  if (!x) return true
+  
+  const n = $.len(x)
+  for (let i = n - 1; i > 0; i--) {
+    if (($.index(x, i) as number) < ($.index(x, i - 1) as number)) {
+      return false
+    }
+  }
+  return true
+}
+
+// Strings sorts a slice of strings in increasing order
+export function Strings(x: $.Slice<string>): void {
+  if (!x) return
+  
+  const n = $.len(x)
+  // Simple insertion sort
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && ($.index(x, j) as string) < ($.index(x, j - 1) as string); j--) {
+      swapInSlice(x, j, j - 1)
+    }
+  }
+}
+
+// StringsAreSorted reports whether the slice x is sorted in increasing order
+export function StringsAreSorted(x: $.Slice<string>): boolean {
+  if (!x) return true
+  
+  const n = $.len(x)
+  for (let i = n - 1; i > 0; i--) {
+    if (($.index(x, i) as string) < ($.index(x, i - 1) as string)) {
+      return false
+    }
+  }
+  return true
+} 

package/gs/strconv/atob.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { syntaxError } from "./atoi.gs.js";
 
 // ParseBool returns the boolean value represented by the string.

package/gs/strconv/atof.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { ErrSyntax, ErrRange, NumError } from "./atoi.gs.js";
 
 // ParseFloat converts the string s to a floating-point number

package/gs/strconv/atoi.gs.ts

@@ -1,8 +1,7 @@
-import * as $ from "@goscript/builtin/builtin.js";
-import * as errors from "@goscript/errors/index.js";
+import * as $ from "@goscript/builtin/index.js";
 
-export let ErrRange: $.GoError = errors.New("value out of range");
-export let ErrSyntax: $.GoError = errors.New("invalid syntax");
+export let ErrRange: $.GoError = $.newError("value out of range");
+export let ErrSyntax: $.GoError = $.newError("invalid syntax");
 
 export class NumError {
 	// the failing function (ParseBool, ParseInt, ParseUint, ParseFloat, ParseComplex)
@@ -82,11 +81,11 @@ export function rangeError(fn: string, str: string): NumError {
 }
 
 export function baseError(fn: string, str: string, base: number): NumError {
-	return new NumError({Func: fn, Num: str, Err: errors.New("invalid base " + base)});
+	return new NumError({Func: fn, Num: str, Err: $.newError("invalid base " + base)});
 }
 
 export function bitSizeError(fn: string, str: string, bitSize: number): NumError {
-	return new NumError({Func: fn, Num: str, Err: errors.New("invalid bit size " + bitSize)});
+	return new NumError({Func: fn, Num: str, Err: $.newError("invalid bit size " + bitSize)});
 }
 
 export let IntSize: number = 64;

package/gs/strconv/doc.gs.ts

@@ -1,2 +1,2 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 

package/gs/strconv/ftoa.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 // FormatFloat converts the floating-point number f to a string,
 // according to the format fmt and precision prec. It rounds the

package/gs/strconv/itoa.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 // FormatUint returns the string representation of i in the given base,
 // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'

package/gs/strconv/metadata.go

@@ -0,0 +1,7 @@
+package strconv
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"errors",
+}

package/gs/strconv/quote.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { ErrSyntax } from "./atoi.gs.js";
 
 // Quote returns a double-quoted Go string literal representing s.

package/gs/strings/builder.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 export class Builder {
   private _content: string = ''

package/gs/strings/iter.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { Index, IndexByte } from './strings.js'
 
 import * as iter from '@goscript/iter/index.js'

package/gs/strings/metadata.go

@@ -0,0 +1,11 @@
+package strings
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"errors",
+	"io",
+	"iter",
+	"unicode",
+	"unicode/utf8",
+}

package/gs/strings/reader.ts

@@ -1,6 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
-
-import * as errors from '@goscript/errors/index.js'
+import * as $ from '@goscript/builtin/index.js'
 
 import * as io from '@goscript/io/index.js'
 
@@ -90,7 +88,7 @@ export class Reader {
   public ReadAt(b: Uint8Array, off: number): [number, $.GoError] {
     const r = this
     if (off < 0) {
-      return [0, errors.New('strings.Reader.ReadAt: negative offset')]
+      return [0, $.newError('strings.Reader.ReadAt: negative offset')]
     }
     if (off >= ($.len(r!.s) as number)) {
       return [0, io.EOF]
@@ -119,7 +117,7 @@ export class Reader {
   public UnreadByte(): $.GoError {
     const r = this
     if (r!.i <= 0) {
-      return errors.New('strings.Reader.UnreadByte: at beginning of string')
+      return $.newError('strings.Reader.UnreadByte: at beginning of string')
     }
     r!.prevRune = -1
     r!.i--
@@ -151,10 +149,10 @@ export class Reader {
   public UnreadRune(): $.GoError {
     const r = this
     if (r!.i <= 0) {
-      return errors.New('strings.Reader.UnreadRune: at beginning of string')
+      return $.newError('strings.Reader.UnreadRune: at beginning of string')
     }
     if (r!.prevRune < 0) {
-      return errors.New(
+      return $.newError(
         'strings.Reader.UnreadRune: previous operation was not ReadRune',
       )
     }
@@ -179,11 +177,11 @@ export class Reader {
         abs = ($.len(r!.s) as number) + offset
         break
       default:
-        return [0, errors.New('strings.Reader.Seek: invalid whence')]
+        return [0, $.newError('strings.Reader.Seek: invalid whence')]
         break
     }
     if (abs < 0) {
-      return [0, errors.New('strings.Reader.Seek: negative position')]
+      return [0, $.newError('strings.Reader.Seek: negative position')]
     }
     r!.i = abs
     return [abs, null]

package/gs/strings/replace.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { makeStringFinder, stringFinder } from './search.js'
 import { Count, HasPrefix } from './strings.js'
 import { Builder } from './builder.js'

package/gs/strings/strings.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 // Count counts the number of non-overlapping instances of substr in s.
 // If substr is an empty string, Count returns 1 + the number of Unicode code points in s.

package/gs/sync/atomic/doc.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 import * as unsafe from "@goscript/unsafe/index.js"
 

package/gs/sync/atomic/doc_64.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 // SwapInt64 atomically stores new into *addr and returns the previous *addr value.
 // Consider using the more ergonomic and less error-prone [Int64.Swap] instead

package/gs/sync/atomic/type.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { AddInt32, AddUint32, AddUintptr, AndInt32, AndUint32, AndUintptr, CompareAndSwapInt32, CompareAndSwapPointer, CompareAndSwapUint32, CompareAndSwapUintptr, LoadInt32, LoadPointer, LoadUint32, LoadUintptr, OrInt32, OrUint32, OrUintptr, StoreInt32, StorePointer, StoreUint32, StoreUintptr, SwapInt32, SwapPointer, SwapUint32, SwapUintptr, uintptr } from "./doc.gs.js";
 import { AddInt64, AddUint64, AndInt64, AndUint64, CompareAndSwapInt64, CompareAndSwapUint64, LoadInt64, LoadUint64, OrInt64, OrUint64, StoreInt64, StoreUint64, SwapInt64, SwapUint64 } from "./doc_64.gs.js";
 

package/gs/sync/atomic/value.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { CompareAndSwapPointer, LoadPointer, StorePointer, SwapPointer } from "./doc.gs.js";
 
 import * as unsafe from "@goscript/unsafe/index.js"

package/gs/sync/metadata.go

@@ -0,0 +1,7 @@
+package sync
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"unsafe",
+}

package/gs/syscall/index.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 // Essential type aliases
 export type uintptr = number

package/gs/unicode/utf8/utf8.ts

@@ -1,6 +1,6 @@
 // Package utf8 implements functions and constants to support text encoded in UTF-8.
 
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 // RuneError is the "error" Rune or "Unicode replacement character"
 export const RuneError = 0xfffd