goscript 0.0.40 → 0.0.42

package/gs/builtin/builtin.ts

@@ -1,13 +1,22 @@
-export * from './varRef.js'
-export * from './channel.js'
-export * from './defer.js'
-export * from './io.js'
-export * from './map.js'
-export * from './slice.js'
-export * from './type.js'
 import type { Slice, SliceProxy } from './slice.js'
 import { isSliceProxy } from './slice.js'
 
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export function println(...args: any[]): void {
+  console.log(...args)
+}
+
+/**
+ * Implementation of Go's built-in panic function
+ * @param args Arguments passed to panic
+ */
+export function panic(...args: any[]): void {
+  throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`)
+}
+
 // Bytes represents all valid []byte representations in TypeScript
 // This includes Uint8Array (the preferred representation) and $.Slice<number> (which includes null)
 export type Bytes = Uint8Array | Slice<number>
@@ -25,63 +34,6 @@ export function int(value: number): number {
   return Math.trunc(value)
 }
 
-// Copy is the Go builtin function that copies the contents of one slice to another.
-// It returns the number of elements copied.
-export function copy<T>(
-  dst: T[] | Uint8Array,
-  src: T[] | Uint8Array | string,
-): number {
-  // Handle string to Uint8Array copy (common in Go)
-  if (typeof src === 'string' && dst instanceof Uint8Array) {
-    const encoder = new TextEncoder()
-    const srcBytes = encoder.encode(src)
-    const n = Math.min(dst.length, srcBytes.length)
-    for (let i = 0; i < n; i++) {
-      dst[i] = srcBytes[i]
-    }
-    return n
-  }
-
-  // Handle Uint8Array to Uint8Array copy
-  if (dst instanceof Uint8Array && src instanceof Uint8Array) {
-    const n = Math.min(dst.length, src.length)
-    for (let i = 0; i < n; i++) {
-      dst[i] = src[i]
-    }
-    return n
-  }
-
-  // Handle array to array copy (original implementation)
-  if (Array.isArray(dst) && Array.isArray(src)) {
-    const n = Math.min(dst.length, src.length)
-    for (let i = 0; i < n; i++) {
-      dst[i] = src[i]
-    }
-    return n
-  }
-
-  // Handle mixed types - convert to compatible format
-  if (dst instanceof Uint8Array && Array.isArray(src)) {
-    const n = Math.min(dst.length, src.length)
-    for (let i = 0; i < n; i++) {
-      dst[i] = src[i] as number
-    }
-    return n
-  }
-
-  if (Array.isArray(dst) && src instanceof Uint8Array) {
-    const n = Math.min(dst.length, src.length)
-    for (let i = 0; i < n; i++) {
-      dst[i] = src[i] as T
-    }
-    return n
-  }
-
-  throw new Error(
-    `Unsupported copy operation between ${typeof dst} and ${typeof src}`,
-  )
-}
-
 // Duration multiplication helper for time package operations
 // Handles expressions like time.Hour * 24
 export function multiplyDuration(duration: any, multiplier: number): any {

package/gs/builtin/errors.ts

@@ -0,0 +1,25 @@
+/**
+ * Represents the Go error type (interface).
+ */
+export type GoError = {
+  Error(): string
+} | null
+
+// newError creates a new Go error with the given message
+export function newError(text: string): GoError {
+  return {
+    Error: () => text,
+  }
+}
+
+// toGoError converts a JavaScript Error to a Go error
+// if the error is already a Go error, it returns it unchanged
+export function toGoError(err: Error): GoError {
+  if ("Error" in err) {
+    return err as GoError
+  }
+  return {
+    JsError: err,
+    Error: () => err.message,
+  } as GoError
+}

package/gs/builtin/index.ts

@@ -1 +1,8 @@
 export * from './builtin.js'
+export * from './slice.js'
+export * from './channel.js'
+export * from './map.js'
+export * from './type.js'
+export * from './varRef.js'
+export * from './defer.js'
+export * from './errors.js'

package/gs/builtin/slice.ts

@@ -816,97 +816,152 @@ export function append<T>(
 /**
  * Copies elements from src to dst.
  * @param dst The destination slice.
- * @param src The source slice.
+ * @param src The source slice or string.
  * @returns The number of elements copied.
  */
-export const copy = <T>(dst: Slice<T>, src: Slice<T>): number => {
-  if (dst === null || src === null) {
+export function copy(dst: Uint8Array, src: Uint8Array | string): number
+export function copy(dst: Uint8Array, src: Slice<number>): number
+export function copy<T>(dst: Slice<T>, src: Slice<T>): number
+export function copy<T>(dst: Slice<T>, src: string): number
+export function copy<T>(dst: Slice<T> | Uint8Array, src: Slice<T> | Uint8Array | string): number {
+  if (dst === null) {
     return 0
   }
 
-  const dstLen = len(dst)
-  const srcLen = len(src)
+  // Handle string source first
+  if (typeof src === 'string') {
+    return copyFromString(dst, src)
+  }
+
+  if (src === null) {
+    return 0
+  }
+
+  // Now we know src is Slice<T> | Uint8Array
+  const dstLen = dst instanceof Uint8Array ? dst.length : len(dst)
+  const srcLen = src instanceof Uint8Array ? src.length : len(src)
   const count = Math.min(dstLen, srcLen)
 
   if (count === 0) {
     return 0
   }
 
-  const isDstUint8Array = dst instanceof Uint8Array
-  const isSrcUint8Array = src instanceof Uint8Array
+  // Handle all combinations of dst and src types
+  if (dst instanceof Uint8Array && src instanceof Uint8Array) {
+    // Uint8Array to Uint8Array
+    dst.set(src.subarray(0, count))
+    return count
+  }
+
+  if (dst instanceof Uint8Array) {
+    // Uint8Array destination, Slice<number> source
+    return copyToUint8Array(dst, src as Slice<number>, count)
+  }
 
-  if (isDstUint8Array && isSrcUint8Array) {
-    ;(dst as Uint8Array).set((src as Uint8Array).subarray(0, count))
-  } else if (isDstUint8Array) {
-    // dst is Uint8Array, src is Slice<number> or number[]
-    const dstUint8 = dst as Uint8Array
+  if (src instanceof Uint8Array) {
+    // Slice<T> destination, Uint8Array source
+    return copyFromUint8Array(dst as Slice<T>, src, count)
+  }
+
+  // Both are Slice<T>
+  return copyBetweenSlices(dst as Slice<T>, src as Slice<T>, count)
+}
+
+/**
+ * Helper: Copy from string to any destination type
+ */
+function copyFromString<T>(dst: Slice<T> | Uint8Array, src: string): number {
+  const encoder = new TextEncoder()
+  const srcBytes = encoder.encode(src)
+  const dstLen = dst instanceof Uint8Array ? dst.length : len(dst)
+  const count = Math.min(dstLen, srcBytes.length)
+  
+  if (count === 0) {
+    return 0
+  }
+
+  if (dst instanceof Uint8Array) {
+    for (let i = 0; i < count; i++) {
+      dst[i] = srcBytes[i]
+    }
+  } else if (isComplexSlice(dst)) {
+    const dstMeta = dst.__meta__
+    for (let i = 0; i < count; i++) {
+      dstMeta.backing[dstMeta.offset + i] = srcBytes[i] as unknown as T
+      ;(dst as any)[i] = srcBytes[i]
+    }
+  } else if (Array.isArray(dst)) {
+    for (let i = 0; i < count; i++) {
+      dst[i] = srcBytes[i] as unknown as T
+    }
+  }
+  
+  return count
+}
+
+/**
+ * Helper: Copy from Slice<number> to Uint8Array
+ */
+function copyToUint8Array(dst: Uint8Array, src: Slice<number>, count: number): number {
+  if (isComplexSlice(src)) {
+    const srcMeta = src.__meta__
+    for (let i = 0; i < count; i++) {
+      dst[i] = srcMeta.backing[srcMeta.offset + i]
+    }
+  } else if (Array.isArray(src)) {
+    for (let i = 0; i < count; i++) {
+      dst[i] = src[i]
+    }
+  }
+  return count
+}
+
+/**
+ * Helper: Copy from Uint8Array to Slice<T>
+ */
+function copyFromUint8Array<T>(dst: Slice<T>, src: Uint8Array, count: number): number {
+  if (isComplexSlice(dst)) {
+    const dstMeta = dst.__meta__
+    for (let i = 0; i < count; i++) {
+      dstMeta.backing[dstMeta.offset + i] = src[i] as unknown as T
+      ;(dst as any)[i] = src[i]
+    }
+  } else if (Array.isArray(dst)) {
+    for (let i = 0; i < count; i++) {
+      dst[i] = src[i] as unknown as T
+    }
+  }
+  return count
+}
+
+/**
+ * Helper: Copy between two Slice<T> instances
+ */
+function copyBetweenSlices<T>(dst: Slice<T>, src: Slice<T>, count: number): number {
+  if (isComplexSlice(dst)) {
+    const dstMeta = dst.__meta__
+    
     if (isComplexSlice(src)) {
-      const srcMeta = (src as SliceProxy<number>).__meta__
+      const srcMeta = src.__meta__
       for (let i = 0; i < count; i++) {
-        dstUint8[i] = srcMeta.backing[srcMeta.offset + i]
+        dstMeta.backing[dstMeta.offset + i] = srcMeta.backing[srcMeta.offset + i]
+        ;(dst as any)[i] = srcMeta.backing[srcMeta.offset + i]
       }
-    } else {
-      // src is number[]
-      const srcArray = src as number[]
+    } else if (Array.isArray(src)) {
       for (let i = 0; i < count; i++) {
-        dstUint8[i] = srcArray[i]
+        dstMeta.backing[dstMeta.offset + i] = src[i]
+        ;(dst as any)[i] = src[i]
       }
     }
-  } else if (isSrcUint8Array) {
-    // src is Uint8Array, dst is Slice<number> or number[]
-    const srcUint8 = src as Uint8Array
-    if (isComplexSlice(dst)) {
-      const dstMeta = (dst as SliceProxy<number>).__meta__
-      const dstBacking = dstMeta.backing
-      const dstOffset = dstMeta.offset
+  } else if (Array.isArray(dst)) {
+    if (isComplexSlice(src)) {
+      const srcMeta = src.__meta__
       for (let i = 0; i < count; i++) {
-        dstBacking[dstOffset + i] = srcUint8[i]
-        // Also update the proxy view if dst is a proxy
-        ;(dst as any)[i] = srcUint8[i]
+        dst[i] = srcMeta.backing[srcMeta.offset + i]
       }
-    } else {
-      // dst is number[]
-      const dstArray = dst as number[]
+    } else if (Array.isArray(src)) {
       for (let i = 0; i < count; i++) {
-        dstArray[i] = srcUint8[i]
-      }
-    }
-  } else {
-    // Both are Slice<T> or T[] (original logic)
-    if (isComplexSlice(dst)) {
-      const dstOffset = (dst as SliceProxy<T>).__meta__.offset
-      const dstBacking = (dst as SliceProxy<T>).__meta__.backing
-
-      if (isComplexSlice(src)) {
-        const srcOffset = (src as SliceProxy<T>).__meta__.offset
-        const srcBacking = (src as SliceProxy<T>).__meta__.backing
-        for (let i = 0; i < count; i++) {
-          dstBacking[dstOffset + i] = srcBacking[srcOffset + i]
-          ;(dst as any)[i] = srcBacking[srcOffset + i] // Update proxy
-        }
-      } else {
-        // src is T[]
-        const srcArray = src as T[]
-        for (let i = 0; i < count; i++) {
-          dstBacking[dstOffset + i] = srcArray[i]
-          ;(dst as any)[i] = srcArray[i] // Update proxy
-        }
-      }
-    } else {
-      // dst is T[]
-      const dstArray = dst as T[]
-      if (isComplexSlice(src)) {
-        const srcOffset = (src as SliceProxy<T>).__meta__.offset
-        const srcBacking = (src as SliceProxy<T>).__meta__.backing
-        for (let i = 0; i < count; i++) {
-          dstArray[i] = srcBacking[srcOffset + i]
-        }
-      } else {
-        // src is T[]
-        const srcArray = src as T[]
-        for (let i = 0; i < count; i++) {
-          dstArray[i] = srcArray[i]
-        }
+        dst[i] = src[i]
       }
     }
   }

package/gs/bytes/buffer.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 const { copy, recover } = $;
 
 import { IndexByte } from "./bytes.gs.js";

package/gs/bytes/bytes.gs.ts

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

package/gs/bytes/iter.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Index, IndexByte, asciiSpace } from "./bytes.gs.js";
 
 import * as iter from "@goscript/iter/index.js"

package/gs/bytes/reader.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 const { copy } = $;
 
 import * as errors from "@goscript/errors/index.js"

package/gs/context/context.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 export const Canceled = new Error('context canceled')
 Canceled.name = 'CanceledError'

package/gs/errors/errors.ts

@@ -1,22 +1,9 @@
-import * as $ from '@goscript/builtin/builtin.js'
-
-// GoScriptError implements the Go error interface
-class GoScriptError {
-  constructor(private message: string) {}
-
-  Error(): string {
-    return this.message
-  }
-
-  toString(): string {
-    return this.message
-  }
-}
+import * as $ from '@goscript/builtin/index.js'
 
 // New returns an error that formats as the given text.
 // Each call to New returns a distinct error value even if the text is identical.
 export function New(text: string): $.GoError {
-  return new GoScriptError(text)
+  return $.newError(text)
 }
 
 // ErrUnsupported indicates that a requested operation cannot be performed,
@@ -212,7 +199,7 @@ export function Join(...errs: $.GoError[]): $.GoError {
   }
 
   const message = nonNilErrs.map((err) => err!.Error()).join('\n')
-  const joinedError = new GoScriptError(message)
+  const joinedError = $.newError(message)
 
   // Add Unwrap method that returns the array of errors
   ;(joinedError as any).Unwrap = function (): $.GoError[] {

package/gs/github.com/pkg/errors/errors.ts

@@ -1,4 +1,4 @@
-import * as $ from '../../../builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { callers } from './stack.js'
 
 // Type definitions

package/gs/github.com/pkg/errors/go113.ts

@@ -1,6 +1,6 @@
-import * as $ from '../../../builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
-import * as stderrors from '../../../errors/index.js'
+import * as stderrors from '@goscript/errors/index.js'
 
 // Is reports whether any error in err's chain matches target.
 //

package/gs/github.com/pkg/errors/stack.ts

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

package/gs/internal/byteorder/index.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 // Stub implementations for internal/byteorder package
 export function LittleEndian(): boolean {

package/gs/internal/oserror/errors.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 import * as errors from '@goscript/errors/index.js'
 

package/gs/io/fs/format.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { FileInfo, DirEntry, fileModeString } from './fs.js'
 
 import * as time from '@goscript/time/index.js'

package/gs/io/fs/fs.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 import * as time from '@goscript/time/index.js'
 

package/gs/io/fs/glob.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { Stat } from './stat.js'
 import { ReadDir } from './readdir.js'
 import { FS } from './fs.js'

package/gs/io/fs/readdir.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { FormatDirEntry } from './format.js'
 import {
   FS,

package/gs/io/fs/readfile.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { FS } from './fs.js'
 
 import * as io from '@goscript/io/index.js'

package/gs/io/fs/stat.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { FS, FileInfo } from './fs.js'
 
 export type StatFS =

package/gs/io/fs/sub.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { ValidPath, FS, PathError, ErrInvalid, File, DirEntry } from './fs.js'
 import { ReadDir } from './readdir.js'
 import { ReadFile } from './readfile.js'

package/gs/io/fs/walk.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { FileInfoToDirEntry, ReadDir } from './readdir.js'
 import { Stat } from './stat.js'
 import { FS, DirEntry } from './fs.js'

package/gs/io/io.ts

@@ -3,7 +3,7 @@
 // such as those in package os, into shared public interfaces that abstract
 // the functionality, plus some other related primitives.
 
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 // Simple error implementation for io package
 class IOError {

package/gs/maps/iter.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 import * as iter from '@goscript/iter/index.js'
 

package/gs/maps/maps.ts

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

package/gs/math/abs.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Float64bits, Float64frombits } from "./unsafe.gs.js";
 
 // Abs returns the absolute value of x.

package/gs/math/acosh.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { IsNaN, NaN } from "./bits.gs.js";
 import { Log } from "./log.gs.js";
 import { Log1p } from "./log1p.gs.js";

package/gs/math/asinh.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { IsInf, IsNaN } from "./bits.gs.js";
 import { Log } from "./log.gs.js";
 import { Log1p } from "./log1p.gs.js";

package/gs/math/atan.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 // xatan evaluates a series valid in the range [0, 0.66].
 export function xatan(x: number): number {

package/gs/math/atan2.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Atan } from "./atan.gs.js";
 import { IsInf, IsNaN, NaN } from "./bits.gs.js";
 import { Copysign } from "./copysign.gs.js";

package/gs/math/atanh.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Inf, IsNaN, NaN } from "./bits.gs.js";
 import { Log1p } from "./log1p.gs.js";
 

package/gs/math/bits.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Abs } from "./abs.gs.js";
 import { Float64frombits } from "./unsafe.gs.js";
 

package/gs/math/cbrt.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { IsInf, IsNaN } from "./bits.gs.js";
 
 import { Float64bits, Float64frombits } from "./unsafe.gs.js";

package/gs/math/const.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 
 // https://oeis.org/A001113
 export let E: number = Math.E

package/gs/math/copysign.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Float64bits, Float64frombits } from "./unsafe.gs.js";
 
 // Copysign returns a value with the magnitude of f

package/gs/math/dim.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Inf, IsInf, IsNaN, NaN } from "./bits.gs.js";
 // archMax and archMin imports removed - using optimized implementation
 import { Signbit } from "./signbit.gs.js";

package/gs/math/erf.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { IsInf, IsNaN, NaN } from "./bits.gs.js";
 import { Exp } from "./exp.gs.js";
 

package/gs/math/erfinv.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Inf, IsNaN, NaN } from "./bits.gs.js";
 import { Log } from "./log.gs.js";
 import { Sqrt } from "./sqrt.gs.js";

package/gs/math/exp.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Inf, IsInf, IsNaN } from "./bits.gs.js";
 // archExp2 and archExp imports removed - using optimized implementation
 import { Ldexp } from "./ldexp.gs.js";

package/gs/math/expm1.gs.ts

@@ -1,4 +1,4 @@
-import * as $ from "@goscript/builtin/builtin.js";
+import * as $ from "@goscript/builtin/index.js";
 import { Inf, IsInf, IsNaN } from "./bits.gs.js";
 
 import { Float64bits, Float64frombits } from "./unsafe.gs.js";