goscript 0.0.37 → 0.0.39

package/gs/builtin/builtin.ts

@@ -209,3 +209,222 @@ export function sortSlice<T extends string | number>(s: Slice<T>): void {
     return
   }
 }
+
+/**
+ * bytesEqual efficiently compares two byte slices for equality.
+ * Optimized for different byte representations.
+ */
+export function bytesEqual(a: Bytes | null, b: Bytes | null): boolean {
+  // Handle null cases
+  if (a === null && b === null) return true
+  if (a === null || b === null) return false
+
+  // Convert to arrays for comparison
+  const aArr = bytesToArray(a)
+  const bArr = bytesToArray(b)
+
+  if (aArr.length !== bArr.length) return false
+
+  for (let i = 0; i < aArr.length; i++) {
+    if (aArr[i] !== bArr[i]) return false
+  }
+
+  return true
+}
+
+/**
+ * bytesCompare compares two byte slices lexicographically.
+ * Returns -1 if a < b, 0 if a == b, +1 if a > b.
+ */
+export function bytesCompare(a: Bytes | null, b: Bytes | null): number {
+  // Handle null cases
+  if (a === null && b === null) return 0
+  if (a === null) return -1
+  if (b === null) return 1
+
+  const aArr = bytesToArray(a)
+  const bArr = bytesToArray(b)
+
+  const minLen = Math.min(aArr.length, bArr.length)
+
+  for (let i = 0; i < minLen; i++) {
+    if (aArr[i] < bArr[i]) return -1
+    if (aArr[i] > bArr[i]) return 1
+  }
+
+  if (aArr.length < bArr.length) return -1
+  if (aArr.length > bArr.length) return 1
+  return 0
+}
+
+/**
+ * bytesToArray converts any Bytes representation to a number array.
+ */
+export function bytesToArray(bytes: Bytes | null): number[] {
+  if (bytes === null) return []
+
+  if (bytes instanceof Uint8Array) {
+    return Array.from(bytes)
+  }
+
+  if (Array.isArray(bytes)) {
+    return bytes
+  }
+
+  // Handle SliceProxy
+  if (isSliceProxy(bytes)) {
+    const proxy = bytes as SliceProxy<number>
+    const meta = proxy.__meta__
+    return meta.backing.slice(meta.offset, meta.offset + meta.length)
+  }
+
+  throw new Error(`Cannot convert bytes of type ${typeof bytes} to array`)
+}
+
+/**
+ * bytesToUint8Array converts any Bytes representation to a Uint8Array.
+ */
+export function bytesToUint8Array(bytes: Bytes | null): Uint8Array {
+  if (bytes === null) return new Uint8Array(0)
+
+  if (bytes instanceof Uint8Array) {
+    return bytes
+  }
+
+  return new Uint8Array(bytesToArray(bytes))
+}
+
+/**
+ * bytesIndexOf finds the first occurrence of subslice in bytes.
+ * Returns -1 if not found.
+ */
+export function bytesIndexOf(
+  bytes: Bytes | null,
+  subslice: Bytes | null,
+): number {
+  if (bytes === null || subslice === null) return -1
+
+  const haystack = bytesToArray(bytes)
+  const needle = bytesToArray(subslice)
+
+  if (needle.length === 0) return 0
+  if (needle.length > haystack.length) return -1
+
+  for (let i = 0; i <= haystack.length - needle.length; i++) {
+    let found = true
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+
+  return -1
+}
+
+/**
+ * bytesLastIndexOf finds the last occurrence of subslice in bytes.
+ * Returns -1 if not found.
+ */
+export function bytesLastIndexOf(
+  bytes: Bytes | null,
+  subslice: Bytes | null,
+): number {
+  if (bytes === null || subslice === null) return -1
+
+  const haystack = bytesToArray(bytes)
+  const needle = bytesToArray(subslice)
+
+  if (needle.length === 0) return haystack.length
+  if (needle.length > haystack.length) return -1
+
+  for (let i = haystack.length - needle.length; i >= 0; i--) {
+    let found = true
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+
+  return -1
+}
+
+/**
+ * bytesIndexByte finds the first occurrence of byte c in bytes.
+ * Returns -1 if not found.
+ */
+export function bytesIndexByte(bytes: Bytes | null, c: number): number {
+  if (bytes === null) return -1
+
+  const arr = bytesToArray(bytes)
+  return arr.indexOf(c)
+}
+
+/**
+ * bytesLastIndexByte finds the last occurrence of byte c in bytes.
+ * Returns -1 if not found.
+ */
+export function bytesLastIndexByte(bytes: Bytes | null, c: number): number {
+  if (bytes === null) return -1
+
+  const arr = bytesToArray(bytes)
+  return arr.lastIndexOf(c)
+}
+
+/**
+ * bytesCount counts non-overlapping instances of sep in bytes.
+ */
+export function bytesCount(bytes: Bytes | null, sep: Bytes | null): number {
+  if (bytes === null || sep === null) return 0
+
+  const haystack = bytesToArray(bytes)
+  const needle = bytesToArray(sep)
+
+  if (needle.length === 0) {
+    // Special case: empty separator counts code points + 1
+    // For now, just return length + 1 (ASCII assumption)
+    return haystack.length + 1
+  }
+
+  let count = 0
+  let pos = 0
+
+  while (pos <= haystack.length - needle.length) {
+    let found = true
+    for (let i = 0; i < needle.length; i++) {
+      if (haystack[pos + i] !== needle[i]) {
+        found = false
+        break
+      }
+    }
+    if (found) {
+      count++
+      pos += needle.length
+    } else {
+      pos++
+    }
+  }
+
+  return count
+}
+
+// Math functions needed by various packages
+export function min(a: number, b: number): number {
+  return Math.min(a, b)
+}
+
+export function max(a: number, b: number): number {
+  return Math.max(a, b)
+}
+
+// Panic recovery function (simplified implementation)
+export function recover(): any {
+  // In a real implementation, this would interact with Go's panic/recover mechanism
+  // For now, return null to indicate no panic was recovered
+  return null
+}

package/gs/builtin/slice.ts

@@ -1041,7 +1041,8 @@ export const sliceString = (
     // Attempt to decode with strict UTF-8 validation
     const result = new TextDecoder('utf-8', { fatal: true }).decode(slicedBytes)
     return result
-  } catch (_e) { //eslint-disable-line @typescript-eslint/no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (_e) {
     // If we get here, the slice would create invalid UTF-8
     // This is a fundamental limitation of JavaScript string handling
     throw new Error(