goscript 0.0.39 → 0.0.41

package/gs/builtin/slice.ts

@@ -192,6 +192,11 @@ export const makeSlice = <T>(
   // The rest of backingArr (from length to actualCapacity-1) remains uninitialized (undefined),
   // representing available capacity.
 
+  // OPTIMIZATION: If length equals capacity, return backing array directly
+  if (length === actualCapacity) {
+    return backingArr as Slice<T>
+  }
+
   // The proxyTargetArray serves as the shell for the proxy.
   // Its elements up to 'length' should reflect the initialized part of the slice.
   const proxyTargetArray = new Array<T>(length)
@@ -252,7 +257,7 @@ export const makeSlice = <T>(
     },
   }
 
-  return new Proxy(proxy, handler) as Slice<T>
+  return new Proxy(proxy, handler) as unknown as SliceProxy<T>
 }
 
 /**
@@ -454,6 +459,11 @@ export const goSlice = <T>( // T can be number for Uint8Array case
   const newLength = high - low
   const newOffset = oldOffset + low
 
+  // OPTIMIZATION: If the result would have offset=0 and length=capacity, return backing directly
+  if (newOffset === 0 && newLength === newCap) {
+    return backing as Slice<T>
+  }
+
   // Create an array-like target with the correct length
   const proxyTargetArray = new Array<T>(newLength)
   // Note: We don't need to initialize the values here since the proxy handler
@@ -487,6 +497,12 @@ export const arrayToSlice = <T>(
 
   if (arr.length === 0) return arr
 
+  // OPTIMIZATION: For arrays where offset=0 and length=capacity, return the array directly
+  // if we're not doing deep conversion
+  if (depth === 1) {
+    return arr as Slice<T>
+  }
+
   const target = {
     __meta__: {
       backing: arr,
@@ -800,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
+  }
+
+  // Handle string source first
+  if (typeof src === 'string') {
+    return copyFromString(dst, src)
+  }
+
+  if (src === null) {
     return 0
   }
 
-  const dstLen = len(dst)
-  const srcLen = len(src)
+  // 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 (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
+}
 
-  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
+/**
+ * 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"
@@ -488,8 +488,36 @@ export function HasSuffix(s: $.Bytes, suffix: $.Bytes): boolean {
 // dropped from the byte slice with no replacement. The characters in s and the
 // output are interpreted as UTF-8-encoded code points.
 export function Map(mapping: ((r: number) => number) | null, s: $.Bytes): $.Bytes {
-	// TODO: Implement Map function with proper UTF-8 handling
-	throw new Error("Map: not implemented")
+	if (s === null || $.len(s) === 0 || mapping === null) {
+		return s === null ? null : new Uint8Array(0)
+	}
+	
+	const result: number[] = []
+	
+	for (let i = 0; i < $.len(s); ) {
+		const [r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
+		if (size <= 0) {
+			// Invalid UTF-8, copy the byte as-is
+			result.push(s![i])
+			i++
+		} else {
+			const mappedR = mapping(r)
+			if (mappedR >= 0) {
+				// Encode the mapped rune back to bytes
+				const runeBytes = new Uint8Array(utf8.UTFMax)
+				const n = utf8.EncodeRune(runeBytes, mappedR)
+				
+				// Add the encoded bytes to result
+				for (let j = 0; j < n; j++) {
+					result.push(runeBytes[j])
+				}
+			}
+			
+			i += size
+		}
+	}
+	
+	return new Uint8Array(result)
 }
 
 // Repeat returns a new byte slice consisting of count copies of b.
@@ -607,29 +635,51 @@ 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 {
-	// TODO: Fix SpecialCase method calls
-	throw new Error("ToUpperSpecial: not implemented")
+	// For now, ignore special case and fall back to regular ToUpper
+	return ToUpper(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 {
-	// TODO: Fix SpecialCase method calls
-	throw new Error("ToLowerSpecial: not implemented")
+	// For now, ignore special case and fall back to regular ToLower
+	return ToLower(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 {
-	// TODO: Fix SpecialCase method calls
-	throw new Error("ToTitleSpecial: not implemented")
+	// For now, ignore special case and fall back to regular ToTitle
+	return ToTitle(s)
 }
 
 // ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes
 // representing invalid UTF-8 replaced with the bytes in replacement, which may be empty.
 export function ToValidUTF8(s: $.Bytes, replacement: $.Bytes): $.Bytes {
-	// TODO: Implement ToValidUTF8 with proper UTF-8 validation
-	throw new Error("ToValidUTF8: not implemented")
+	if (s === null || $.len(s) === 0) {
+		return s === null ? null : new Uint8Array(0)
+	}
+	
+	const result: number[] = []
+	const replacementArr = replacement ? $.bytesToArray(replacement) : []
+	
+	for (let i = 0; i < $.len(s); ) {
+		const [r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
+		if (size <= 0 || r === utf8.RuneError) {
+			// Invalid UTF-8, replace with replacement bytes
+			for (const b of replacementArr) {
+				result.push(b)
+			}
+			i++
+		} else {
+			for (let j = 0; j < size; j++) {
+				result.push(s![i + j])
+			}
+			i += size
+		}
+	}
+	
+	return new Uint8Array(result)
 }
 
 // isSeparator reports whether the rune could mark a word boundary.
@@ -659,8 +709,41 @@ export function isSeparator(r: number): boolean {
 // Deprecated: The rule Title uses for word boundaries does not handle Unicode
 // punctuation properly. Use golang.org/x/text/cases instead.
 export function Title(s: $.Bytes): $.Bytes {
-	// TODO: Implement Title function properly
-	throw new Error("Title: not implemented")
+	if (s === null || $.len(s) === 0) {
+		return s === null ? null : new Uint8Array(0)
+	}
+	
+	const result: number[] = []
+	let prevIsSep = true  // Start of string counts as separator
+	
+	for (let i = 0; i < $.len(s); ) {
+		const [r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
+		if (size <= 0) {
+			// Invalid UTF-8, copy the byte as-is
+			result.push(s![i])
+			i++
+			prevIsSep = true
+		} else {
+			let transformedR = r
+			if (prevIsSep && unicode.IsLetter(r)) {
+				transformedR = unicode.ToTitle(r)
+			}
+			
+			// Encode the (possibly transformed) rune back to bytes
+			const runeBytes = new Uint8Array(utf8.UTFMax)
+			const n = utf8.EncodeRune(runeBytes, transformedR)
+			
+			// Add the encoded bytes to result
+			for (let j = 0; j < n; j++) {
+				result.push(runeBytes[j])
+			}
+			
+			prevIsSep = isSeparator(r)
+			i += size
+		}
+	}
+	
+	return new Uint8Array(result)
 }
 
 // TrimLeftFunc treats s as UTF-8-encoded bytes and returns a subslice of s by slicing off
@@ -1119,8 +1202,33 @@ export function ReplaceAll(s: $.Bytes, old: $.Bytes, _new: $.Bytes): $.Bytes {
 // are equal under simple Unicode case-folding, which is a more general
 // form of case-insensitivity.
 export function EqualFold(s: $.Bytes, t: $.Bytes): boolean {
-	// TODO: Implement EqualFold function properly (complex Unicode folding logic)
-	throw new Error("EqualFold: not implemented")
+	if (s === null && t === null) return true
+	if (s === null || t === null) return false
+	
+	let si = 0, ti = 0
+	
+	while (si < $.len(s) && ti < $.len(t)) {
+		const [sr, ssize] = utf8.DecodeRune($.goSlice(s, si, undefined))
+		const [tr, tsize] = utf8.DecodeRune($.goSlice(t, ti, undefined))
+		
+		if (ssize <= 0 || tsize <= 0) {
+			// Invalid UTF-8, fall back to byte comparison
+			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
+		}
+	}
+	
+	return si === $.len(s) && ti === $.len(t)
 }
 
 // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.

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/metadata.go

@@ -0,0 +1,12 @@
+package bytes
+
+// 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",
+	"unsafe",
+}

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[] {