goscript 0.1.1 → 0.1.2

package/gs/sort/slice.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Slice, SliceIsSorted, SliceStable } from './slice.gs.js'
+
+describe('sort.Slice override', () => {
+  it('sorts slices with logarithmic comparator growth', async () => {
+    const values = $.arrayToSlice<number>(
+      Array.from({ length: 128 }, (_, i) => 128 - i),
+    )
+    let calls = 0
+
+    await Slice(values, (i, j) => {
+      calls++
+      return values![i] < values![j]
+    })
+
+    expect(values).toEqual(Array.from({ length: 128 }, (_, i) => i + 1))
+    expect(calls).toBeLessThan(1200)
+  })
+
+  it('keeps equal values stable for SliceStable', async () => {
+    const values = $.arrayToSlice([
+      { group: 1, name: 'a' },
+      { group: 0, name: 'b' },
+      { group: 1, name: 'c' },
+      { group: 0, name: 'd' },
+    ])
+
+    await SliceStable(values, (i, j) => values![i].group < values![j].group)
+
+    expect(values?.map((value) => value.name)).toEqual(['b', 'd', 'a', 'c'])
+    expect(
+      await SliceIsSorted(
+        values,
+        (i, j) => values![i].group < values![j].group,
+      ),
+    ).toBe(true)
+  })
+})

package/gs/strings/builder.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { Builder } from './builder.js'
+import { varRef } from '../builtin/varRef.js'
 
 describe('strings/Builder', () => {
   describe('Builder', () => {
@@ -89,6 +90,13 @@ describe('strings/Builder', () => {
       expect(b.Len()).toBe(11)
     })
 
+    it('should accept VarRef pointer receivers', () => {
+      const b = varRef(new Builder())
+      Builder.prototype.WriteString.call(b, 'hello')
+      expect(Builder.prototype.Len.call(b)).toBe(5)
+      expect(Builder.prototype.String.call(b)).toBe('hello')
+    })
+
     it('should handle empty writes', () => {
       const b = new Builder()
       const [n, err] = b.WriteString('')

package/gs/strings/builder.ts

@@ -1,5 +1,11 @@
 import * as $ from '@goscript/builtin/index.js'
 
+function builderValue(
+  builder: Builder | $.VarRef<Builder> | null | undefined,
+): Builder {
+  return $.pointerValue<Builder>(builder)
+}
+
 export class Builder {
   private _content: string = ''
   private _addr: Builder | null = null
@@ -16,21 +22,22 @@ export class Builder {
   }
 
   private copyCheck(): void {
-    if (this._addr == null) {
-      this._addr = this
-    } else if (this._addr !== this) {
+    const builder = builderValue(this)
+    if (builder._addr == null) {
+      builder._addr = builder
+    } else if (builder._addr !== builder) {
       $.panic('strings: illegal use of non-zero Builder copied by value')
     }
   }
 
   // String returns the accumulated string.
   public String(): string {
-    return this._content
+    return builderValue(this)._content
   }
 
   // Len returns the number of accumulated bytes; b.Len() == len(b.String()).
   public Len(): number {
-    return this._content.length
+    return builderValue(this)._content.length
   }
 
   // Cap returns the capacity of the builder's underlying byte slice. It is the
@@ -38,20 +45,21 @@ export class Builder {
   // already written.
   public Cap(): number {
     // For simplicity, return the current length since JavaScript strings are dynamic
-    return this._content.length
+    return builderValue(this)._content.length
   }
 
   // Reset resets the Builder to be empty.
   public Reset(): void {
-    this._addr = null
-    this._content = ''
+    const builder = builderValue(this)
+    builder._addr = null
+    builder._content = ''
   }
 
   // Grow grows b's capacity, if necessary, to guarantee space for
   // another n bytes. After Grow(n), at least n bytes can be written to b
   // without another allocation. If n is negative, Grow panics.
   public Grow(n: number): void {
-    this.copyCheck()
+    builderValue(this).copyCheck()
     if (n < 0) {
       $.panic('strings.Builder.Grow: negative count')
     }
@@ -61,28 +69,31 @@ export class Builder {
   // Write appends the contents of p to b's buffer.
   // Write always returns len(p), nil.
   public Write(p: $.Bytes): [number, $.GoError] {
-    this.copyCheck()
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
     // Convert byte array to string
     const bytes = $.bytesToUint8Array(p)
     const str = new TextDecoder('utf-8').decode(bytes)
-    this._content += str
+    builder._content += str
     return [$.len(p), null]
   }
 
   // WriteByte appends the byte c to b's buffer.
   // The returned error is always nil.
   public WriteByte(c: number): $.GoError {
-    this.copyCheck()
-    this._content += String.fromCharCode(c)
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
+    builder._content += String.fromCharCode(c)
     return null
   }
 
   // WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
   // It returns the length of r and a nil error.
   public WriteRune(r: number): [number, $.GoError] {
-    this.copyCheck()
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
     const str = String.fromCodePoint(r)
-    this._content += str
+    builder._content += str
     // Return the byte length of the UTF-8 encoding
     const byteLength = new TextEncoder().encode(str).length
     return [byteLength, null]
@@ -91,8 +102,9 @@ export class Builder {
   // WriteString appends the contents of s to b's buffer.
   // It returns the length of s and a nil error.
   public WriteString(s: string): [number, $.GoError] {
-    this.copyCheck()
-    this._content += s
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
+    builder._content += s
     return [s.length, null]
   }
 

package/gs/strings/iter.test.ts

@@ -124,13 +124,11 @@ describe('strings/iter', () => {
     it('should handle unicode', () => {
       const parts: string[] = []
       const seq = SplitSeq('世界,你好', ',')
-      // This test expects an error due to UTF-8 slicing limitations in JavaScript
-      expect(() => {
-        seq((part: string) => {
-          parts.push(part)
-          return true
-        })
-      }).toThrow('Cannot slice string at byte indices')
+      seq((part: string) => {
+        parts.push(part)
+        return true
+      })
+      expect(parts).toEqual(['世界', '你好'])
     })
   })
 

package/gs/strings/iter.ts

@@ -23,38 +23,64 @@ const asciiSpace: { [key: number]: boolean } = {
 // If s does not end in a newline, the final yielded line will not end in a newline.
 // It returns a single-use iterator.
 export function Lines(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (; $.len(s) > 0; ) {
-      let line: string
-      {
-        let i = IndexByte(s, 10)
-        if (i >= 0) {
-          ;[line, s] = [
-            $.sliceString(s, undefined, i + 1),
-            $.sliceString(s, i + 1, undefined),
-          ]
-        } else {
-          ;[line, s] = [s, '']
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (; $.len(s) > 0; ) {
+        let line: string
+        {
+          let i = IndexByte(s, 10)
+          if (i >= 0) {
+            ;[line, s] = [
+              $.sliceString(s, undefined, i + 1),
+              $.sliceString(s, i + 1, undefined),
+            ]
+          } else {
+            ;[line, s] = [s, '']
+          }
+        }
+        const keepGoing = _yield!(line)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
         }
-      }
-      if (!_yield!(line)) {
-        return
       }
     }
-    return
+    return walk()
   }
 }
 
 // explodeSeq returns an iterator over the runes in s.
 export function explodeSeq(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (; $.len(s) > 0; ) {
-      let [, size] = utf8.DecodeRuneInString(s)
-      if (!_yield!($.sliceString(s, undefined, size))) {
-        return
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (; $.len(s) > 0; ) {
+        let [, size] = utf8.DecodeRuneInString(s)
+        const keepGoing = _yield!($.sliceString(s, undefined, size))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              s = $.sliceString(s, size, undefined)
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
+        }
+        s = $.sliceString(s, size, undefined)
       }
-      s = $.sliceString(s, size, undefined)
     }
+    return walk()
   }
 }
 
@@ -68,19 +94,36 @@ export function splitSeq(
   if ($.len(sep) == 0) {
     return explodeSeq(s)
   }
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (;;) {
-      let i = Index(s, sep)
-      if (i < 0) {
-        break
-      }
-      let frag = $.sliceString(s, undefined, i + sepSave)
-      if (!_yield!(frag)) {
-        return
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (;;) {
+        let i = Index(s, sep)
+        if (i < 0) {
+          const keepGoing = _yield!(s)
+          if (keepGoing instanceof Promise) {
+            return keepGoing.then(() => {})
+          }
+          return
+        }
+        let frag = $.sliceString(s, undefined, i + sepSave)
+        const keepGoing = _yield!(frag)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              s = $.sliceString(s, i + $.len(sep), undefined)
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
+        }
+        s = $.sliceString(s, i + $.len(sep), undefined)
       }
-      s = $.sliceString(s, i + $.len(sep), undefined)
     }
-    _yield!(s)
+    return walk()
   }
 }
 
@@ -105,31 +148,47 @@ export function SplitAfterSeq(s: string, sep: string): iter.Seq<string> {
 // The iterator yields the same strings that would be returned by [Fields](s),
 // but without constructing the slice.
 export function FieldsSeq(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
     let start = -1
-    for (let i = 0; i < $.len(s); ) {
-      let size = 1
-      let r = $.indexString(s, i) as number
-      let isSpace = asciiSpace[$.indexString(s, i)] === true
-      if (r >= utf8.RuneSelf) {
-        ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
-        isSpace = unicode.IsSpace(r)
-      }
-      if (isSpace) {
-        if (start >= 0) {
-          if (!_yield!($.sliceString(s, start, i))) {
-            return
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i < $.len(s); ) {
+        let size = 1
+        let r = $.indexString(s, i) as number
+        let isSpace = asciiSpace[$.indexString(s, i)] === true
+        if (r >= utf8.RuneSelf) {
+          ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
+          isSpace = unicode.IsSpace(r)
+        }
+        if (isSpace) {
+          if (start >= 0) {
+            const keepGoing = _yield!($.sliceString(s, start, i))
+            start = -1
+            if (keepGoing instanceof Promise) {
+              return keepGoing.then((next) => {
+                if (next) {
+                  return walk(i + size)
+                }
+              })
+            }
+            if (!keepGoing) {
+              return
+            }
           }
-          start = -1
+        } else if (start < 0) {
+          start = i
+        }
+        i += size
+      }
+      if (start >= 0) {
+        const keepGoing = _yield!($.sliceString(s, start, undefined))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then(() => {})
         }
-      } else if (start < 0) {
-        start = i
       }
-      i += size
-    }
-    if (start >= 0) {
-      _yield!($.sliceString(s, start, undefined))
     }
+    return walk(0)
   }
 }
 
@@ -141,31 +200,47 @@ export function FieldsFuncSeq(
   s: string,
   f: ((p0: number) => boolean) | null,
 ): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
     if (f === null) {
       return
     }
     let start = -1
-    for (let i = 0; i < $.len(s); ) {
-      let size = 1
-      let r = $.indexString(s, i) as number
-      if (r >= utf8.RuneSelf) {
-        ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
-      }
-      if (f(r)) {
-        if (start >= 0) {
-          if (!_yield!($.sliceString(s, start, i))) {
-            return
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i < $.len(s); ) {
+        let size = 1
+        let r = $.indexString(s, i) as number
+        if (r >= utf8.RuneSelf) {
+          ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
+        }
+        if (f(r)) {
+          if (start >= 0) {
+            const keepGoing = _yield!($.sliceString(s, start, i))
+            start = -1
+            if (keepGoing instanceof Promise) {
+              return keepGoing.then((next) => {
+                if (next) {
+                  return walk(i + size)
+                }
+              })
+            }
+            if (!keepGoing) {
+              return
+            }
           }
-          start = -1
+        } else if (start < 0) {
+          start = i
+        }
+        i += size
+      }
+      if (start >= 0) {
+        const keepGoing = _yield!($.sliceString(s, start, undefined))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then(() => {})
         }
-      } else if (start < 0) {
-        start = i
       }
-      i += size
-    }
-    if (start >= 0) {
-      _yield!($.sliceString(s, start, undefined))
     }
+    return walk(0)
   }
 }

package/gs/strings/replace.test.ts

@@ -124,10 +124,7 @@ describe('strings/Replacer', () => {
     it('should handle unicode strings', () => {
       const r = NewReplacer('世界', '世界!')
       if (r) {
-        // This test expects an error due to UTF-8 slicing limitations in JavaScript
-        expect(() => r.Replace('Hello 世界')).toThrow(
-          'Cannot slice string at byte indices',
-        )
+        expect(r.Replace('Hello 世界')).toBe('Hello 世界!')
       }
     })
 

package/gs/strings/replace.ts

@@ -396,12 +396,12 @@ class trieNode {
         // what is currently t.prefix[0] will lead to prefixNode, and
         // looking up key[0] will lead to keyNode.
         const prefixNode =
-          $.len(t!.prefix) == 1
-            ? t!.next
-            : new trieNode({
-                next: t!.next,
-                prefix: $.sliceString(t!.prefix, 1, undefined),
-              })
+          $.len(t!.prefix) == 1 ?
+            t!.next
+          : new trieNode({
+              next: t!.next,
+              prefix: $.sliceString(t!.prefix, 1, undefined),
+            })
         let keyNode = new trieNode()
         t!.table = $.makeSlice<trieNode | null>(r!.tableSize)
         t!.table![r!.mapping![$.indexString(t!.prefix, 0)]] = prefixNode

package/gs/strings/strings.test.ts

@@ -203,6 +203,7 @@ describe('strings', () => {
       expect(Index('hello world', 'xyz')).toBe(-1)
       expect(Index('hello', 'hello')).toBe(0)
       expect(Index('', '')).toBe(0)
+      expect(Index('世界,你好', ',')).toBe(6)
     })
   })
 
@@ -219,6 +220,7 @@ describe('strings', () => {
       expect(IndexByte('hello', 101)).toBe(1) // 'e'
       expect(IndexByte('hello', 120)).toBe(-1) // 'x'
       expect(IndexByte('', 97)).toBe(-1) // 'a'
+      expect(IndexByte('世界,你好', 44)).toBe(6)
     })
   })
 
@@ -257,6 +259,7 @@ describe('strings', () => {
       expect(LastIndex('hello world hello', 'hello')).toBe(12)
       expect(LastIndex('hello world', 'xyz')).toBe(-1)
       expect(LastIndex('hello', 'hello')).toBe(0)
+      expect(LastIndex('世界,你好', '你好')).toBe(7)
     })
   })
 
@@ -273,6 +276,7 @@ describe('strings', () => {
       expect(LastIndexByte('hello', 108)).toBe(3) // 'l'
       expect(LastIndexByte('hello', 120)).toBe(-1) // 'x'
       expect(LastIndexByte('', 97)).toBe(-1) // 'a'
+      expect(LastIndexByte('世界,你好', 44)).toBe(6)
     })
   })
 

package/gs/strings/strings.ts

@@ -56,18 +56,31 @@ export function ContainsFunc(
 
 // Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
 export function Index(s: string, substr: string): number {
-  return s.indexOf(substr)
+  if (substr === '') {
+    return 0
+  }
+  return indexBytes($.stringToBytes(s), $.stringToBytes(substr))
 }
 
 // LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
 export function LastIndex(s: string, substr: string): number {
-  return s.lastIndexOf(substr)
+  const haystack = $.stringToBytes(s)
+  const needle = $.stringToBytes(substr)
+  if (needle.length === 0) {
+    return haystack.length
+  }
+  return lastIndexBytes(haystack, needle)
 }
 
 // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
 export function IndexByte(s: string, c: number): number {
-  const char = String.fromCharCode(c)
-  return s.indexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === (c & 0xff)) {
+      return i
+    }
+  }
+  return -1
 }
 
 // IndexRune returns the index of the first instance of the Unicode code point r, or -1 if rune is not present in s.
@@ -98,8 +111,43 @@ export function LastIndexAny(s: string, chars: string): number {
 
 // LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s.
 export function LastIndexByte(s: string, c: number): number {
-  const char = String.fromCharCode(c)
-  return s.lastIndexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] === (c & 0xff)) {
+      return i
+    }
+  }
+  return -1
+}
+
+function indexBytes(haystack: Uint8Array, needle: Uint8Array): number {
+  if (needle.length === 0) {
+    return 0
+  }
+  outer: for (let i = 0; i <= haystack.length - needle.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        continue outer
+      }
+    }
+    return i
+  }
+  return -1
+}
+
+function lastIndexBytes(haystack: Uint8Array, needle: Uint8Array): number {
+  if (needle.length === 0) {
+    return haystack.length
+  }
+  outer: for (let i = haystack.length - needle.length; i >= 0; i--) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        continue outer
+      }
+    }
+    return i
+  }
+  return -1
 }
 
 // IndexFunc returns the index into s of the first Unicode code point satisfying f(c), or -1 if none do.