goscript 0.1.0 → 0.1.2

package/gs/github.com/mr-tron/base58/base58/index.ts

@@ -0,0 +1,231 @@
+import * as $ from '@goscript/builtin/index.js'
+
+const btcAlphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+const flickrAlphabet = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+
+export class Alphabet {
+  decode: Int8Array
+  encode: Uint8Array
+
+  constructor(init?: Partial<{ decode?: Int8Array; encode?: Uint8Array }>) {
+    this.decode = init?.decode?.slice() ?? new Int8Array(128)
+    this.encode = init?.encode?.slice() ?? new Uint8Array(58)
+  }
+
+  clone(): Alphabet {
+    return new Alphabet({ decode: this.decode, encode: this.encode })
+  }
+}
+
+export function NewAlphabet(s: string): Alphabet {
+  const bytes = $.stringToBytes(s)
+  if (bytes.length !== 58) {
+    $.panic('base58 alphabets must be 58 bytes long')
+  }
+
+  const alphabet = new Alphabet()
+  alphabet.decode.fill(-1)
+  for (let i = 0; i < bytes.length; i++) {
+    const code = bytes[i]
+    if (code > 127) {
+      $.panic('base58 alphabets must be valid ASCII')
+    }
+    alphabet.encode[i] = code
+    alphabet.decode[code] = i
+  }
+  return alphabet
+}
+
+export let BTCAlphabet: Alphabet | $.VarRef<Alphabet> | null =
+  NewAlphabet(btcAlphabet)
+
+export function __goscript_set_BTCAlphabet(
+  value: Alphabet | $.VarRef<Alphabet> | null,
+): void {
+  BTCAlphabet = value
+}
+
+export let FlickrAlphabet: Alphabet | $.VarRef<Alphabet> | null =
+  NewAlphabet(flickrAlphabet)
+
+export function __goscript_set_FlickrAlphabet(
+  value: Alphabet | $.VarRef<Alphabet> | null,
+): void {
+  FlickrAlphabet = value
+}
+
+export function Encode(bin: $.Bytes): string {
+  return FastBase58Encoding(bin)
+}
+
+export function EncodeAlphabet(
+  bin: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+export function FastBase58Encoding(bin: $.Bytes): string {
+  return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+export function FastBase58EncodingAlphabet(
+  bin: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  const bytes = $.bytesToUint8Array(bin)
+  const alpha = $.pointerValue(alphabet)
+  if (alpha == null) {
+    $.panic('base58 alphabet is nil')
+  }
+
+  const zero = alpha.encode[0]
+  const binsz = bytes.length
+  let zcount = 0
+  while (zcount < binsz && bytes[zcount] === 0) {
+    zcount++
+  }
+
+  const size = Math.trunc(((binsz - zcount) * 138) / 100) + 1
+  let value = 0n
+  for (let i = zcount; i < binsz; i++) {
+    value = (value << 8n) + BigInt(bytes[i])
+  }
+
+  const out = new Uint8Array(size + zcount)
+  let offset = out.length
+  while (value > 0n) {
+    const digit = Number(value % 58n)
+    value /= 58n
+    offset--
+    out[offset] = alpha.encode[digit]
+  }
+  for (let i = 0; i < zcount; i++) {
+    offset--
+    out[offset] = zero
+  }
+
+  return $.bytesToString(out.subarray(offset))
+}
+
+export function TrivialBase58Encoding(a: $.Bytes): string {
+  return FastBase58Encoding(a)
+}
+
+export function TrivialBase58EncodingAlphabet(
+  a: $.Bytes,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): string {
+  return FastBase58EncodingAlphabet(a, alphabet)
+}
+
+export function Decode(str: string): [Uint8Array | null, $.GoError] {
+  return FastBase58Decoding(str)
+}
+
+export function DecodeAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+export function FastBase58Decoding(str: string): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+export function FastBase58DecodingAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  if (str.length === 0) {
+    return [null, $.newError('zero length string')]
+  }
+
+  const alpha = $.pointerValue(alphabet)
+  if (alpha == null) {
+    $.panic('base58 alphabet is nil')
+  }
+
+  const b58sz = str.length
+  const outisz = Math.trunc((b58sz + 3) / 4)
+  const binu = new Uint8Array((b58sz + 3) * 3)
+  let bytesleft = b58sz % 4
+  const zero = alpha.encode[0]
+
+  let zmask = 0
+  if (bytesleft > 0) {
+    zmask = (0xffffffff << (bytesleft * 8)) >>> 0
+  } else {
+    bytesleft = 4
+  }
+
+  const outi = new Uint32Array(outisz)
+  let zcount = 0
+  while (zcount < b58sz && str.charCodeAt(zcount) === zero) {
+    zcount++
+  }
+
+  for (let i = 0; i < b58sz; i++) {
+    const r = str.charCodeAt(i)
+    if (r > 127) {
+      return [null, $.newError('High-bit set on invalid digit')]
+    }
+    const decoded = alpha.decode[r]
+    if (decoded === -1) {
+      return [
+        null,
+        $.newError(`Invalid base58 digit ('${String.fromCodePoint(r)}')`),
+      ]
+    }
+
+    let c = decoded >>> 0
+    for (let j = outisz - 1; j >= 0; j--) {
+      const t = outi[j] * 58 + c
+      c = Math.floor(t / 0x100000000)
+      outi[j] = t >>> 0
+    }
+
+    if (c > 0) {
+      return [null, $.newError('Output number too big (carry to the next int32)')]
+    }
+    if ((outi[0] & zmask) !== 0) {
+      return [
+        null,
+        $.newError('Output number too big (last int32 filled too far)'),
+      ]
+    }
+  }
+
+  let cnt = 0
+  for (let j = 0; j < outisz; j++) {
+    for (let mask = (bytesleft - 1) * 8; mask >= 0; mask -= 8) {
+      binu[cnt] = (outi[j] >>> mask) & 0xff
+      cnt++
+    }
+    if (j === 0) {
+      bytesleft = 4
+    }
+  }
+
+  for (let n = 0; n < binu.length; n++) {
+    if (binu[n] > 0) {
+      const start = Math.max(n - zcount, 0)
+      return [binu.subarray(start, cnt), null]
+    }
+  }
+  return [binu.subarray(0, cnt), null]
+}
+
+export function TrivialBase58Decoding(
+  str: string,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58Decoding(str)
+}
+
+export function TrivialBase58DecodingAlphabet(
+  str: string,
+  alphabet: Alphabet | $.VarRef<Alphabet> | null,
+): [Uint8Array | null, $.GoError] {
+  return FastBase58DecodingAlphabet(str, alphabet)
+}

package/gs/github.com/mr-tron/base58/base58/meta.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": []
+}

package/gs/github.com/zeebo/blake3/internal/consts/index.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  BlockLen,
+  ChunkLen,
+  Flag_ChunkEnd,
+  Flag_ChunkStart,
+  Flag_DeriveKeyContext,
+  Flag_DeriveKeyMaterial,
+  Flag_Keyed,
+  Flag_Parent,
+  Flag_Root,
+  HasAVX2,
+  HasSSE41,
+  IV,
+  IV0,
+  OptimizeLittleEndian,
+} from './index.js'
+
+describe('blake3 consts override', () => {
+  test('uses portable constants for GoScript', () => {
+    expect(IV).toEqual([
+      0x6a09e667,
+      0xbb67ae85,
+      0x3c6ef372,
+      0xa54ff53a,
+      0x510e527f,
+      0x9b05688c,
+      0x1f83d9ab,
+      0x5be0cd19,
+    ])
+    expect(IV[0]).toBe(IV0)
+    expect(BlockLen).toBe(64)
+    expect(ChunkLen).toBe(1024)
+    expect(Flag_ChunkStart).toBe(1)
+    expect(Flag_ChunkEnd).toBe(2)
+    expect(Flag_Parent).toBe(4)
+    expect(Flag_Root).toBe(8)
+    expect(Flag_Keyed).toBe(16)
+    expect(Flag_DeriveKeyContext).toBe(32)
+    expect(Flag_DeriveKeyMaterial).toBe(64)
+    expect(HasAVX2).toBe(false)
+    expect(HasSSE41).toBe(false)
+    expect(OptimizeLittleEndian).toBe(false)
+  })
+})

package/gs/github.com/zeebo/blake3/internal/consts/index.ts

@@ -0,0 +1,26 @@
+export const IV0 = 0x6a09e667
+export const IV1 = 0xbb67ae85
+export const IV2 = 0x3c6ef372
+export const IV3 = 0xa54ff53a
+export const IV4 = 0x510e527f
+export const IV5 = 0x9b05688c
+export const IV6 = 0x1f83d9ab
+export const IV7 = 0x5be0cd19
+
+export const IV: number[] = [IV0, IV1, IV2, IV3, IV4, IV5, IV6, IV7]
+
+export const Flag_ChunkStart = 1 << 0
+export const Flag_ChunkEnd = 1 << 1
+export const Flag_Parent = 1 << 2
+export const Flag_Root = 1 << 3
+export const Flag_Keyed = 1 << 4
+export const Flag_DeriveKeyContext = 1 << 5
+export const Flag_DeriveKeyMaterial = 1 << 6
+
+export const BlockLen = 64
+export const ChunkLen = 1024
+
+export const HasAVX2 = false
+export const HasSSE41 = false
+
+export const OptimizeLittleEndian = false

package/gs/go/internal/scannerhooks/index.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+
+import { StringEnd, __goscript_set_StringEnd } from './index.js'
+
+describe('go/internal/scannerhooks override', () => {
+  it('stores a synchronous StringEnd hook', () => {
+    __goscript_set_StringEnd(() => 12)
+
+    expect(StringEnd?.({})).toBe(12)
+
+    __goscript_set_StringEnd(null)
+    expect(StringEnd).toBeNull()
+  })
+})

package/gs/go/internal/scannerhooks/index.ts

@@ -0,0 +1,9 @@
+import type * as token from '@goscript/go/token/index.js'
+
+export let StringEnd: ((scanner: any) => token.Pos) | null = null
+
+export function __goscript_set_StringEnd(
+  value: ((scanner: any) => token.Pos) | null,
+): void {
+  StringEnd = value
+}

package/gs/go/scanner/index.test.ts

@@ -5,9 +5,11 @@ import * as token from '@goscript/go/token/index.js'
 
 import {
   ErrorList_Add,
+  ErrorList_Err,
   ErrorList_Error,
   ErrorList_Len,
   ErrorList_RemoveMultiples,
+  Scanner,
   type ErrorList,
 } from './index.js'
 
@@ -47,4 +49,24 @@ describe('go/scanner override', () => {
 
     expect(ErrorList_Len(list.value)).toBe(1)
   })
+
+  it('returns nil Err for an empty list and an error for non-empty lists', () => {
+    const empty: ErrorList = null
+    expect(ErrorList_Err(empty)).toBeNull()
+
+    const list: $.VarRef<ErrorList> = $.varRef(null)
+    ErrorList_Add(list, new token.Position({ Line: 1 }), 'first')
+    expect(ErrorList_Err(list.value)?.Error()).toBe('1: first')
+  })
+
+  it('provides a Scanner surface for generated go/parser code', () => {
+    const fset = token.NewFileSet()
+    const file = fset.AddFile('test.go', -1, 0)
+    const scanner = new Scanner()
+
+    scanner.Init(file, null, null, 0)
+
+    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+  })
 })

package/gs/go/scanner/index.ts

@@ -62,9 +62,49 @@ export class Error {
 }
 
 export type ErrorList = $.Slice<Error | null>
+export type ErrorHandler = (pos: token.Position, msg: string) => void
+export type Mode = number
 
 export const ScanComments = 1
 
+export class Scanner {
+  public ErrorCount = 0
+  private file: token.File | null = null
+  private src: $.Slice<number> = null
+  private err: ErrorHandler | null = null
+  private done = false
+
+  public clone(): Scanner {
+    const scanner = new Scanner()
+    scanner.ErrorCount = this.ErrorCount
+    scanner.file = this.file
+    scanner.src = this.src
+    scanner.err = this.err
+    scanner.done = this.done
+    return scanner
+  }
+
+  public Init(
+    file: token.File | $.VarRef<token.File> | null,
+    src: $.Slice<number>,
+    err: ErrorHandler | null,
+    _mode: Mode,
+  ): void {
+    this.file = file === null ? null : $.pointerValue<token.File>(file)
+    this.src = src
+    this.err = err
+    this.done = false
+  }
+
+  public Scan(): [token.Pos, token.Token, string] {
+    if (this.done) {
+      return [this.file?.Pos($.len(this.src)) ?? token.NoPos, token.EOF, '']
+    }
+    this.done = true
+    return [this.file?.Pos(0) ?? token.NoPos, token.EOF, '']
+  }
+}
+
 export function Error_Error(err: Error): string {
   if (!err.Pos.IsValid()) {
     return err.Msg
@@ -155,3 +195,10 @@ export function ErrorList_Error(list: ErrorList): string {
   }
   return `${errors[0]!.Error()} (and ${errors.length - 1} more errors)`
 }
+
+export function ErrorList_Err(list: ErrorList): $.GoError {
+  if ($.len(list) === 0) {
+    return null
+  }
+  return $.newError(ErrorList_Error(list))
+}

package/gs/go/token/index.test.ts

@@ -2,7 +2,24 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Position, Position_IsValid, Position_String } from './index.js'
+import {
+  ADD,
+  COMMENT,
+  FileSet,
+  IDENT,
+  IF,
+  IsIdentifier,
+  IsKeyword,
+  Lookup,
+  NewFileSet,
+  Position,
+  Position_IsValid,
+  Position_String,
+  Token_IsKeyword,
+  Token_IsLiteral,
+  Token_Precedence,
+  Token_String,
+} from './index.js'
 
 describe('go/token override', () => {
   it('models Position values', () => {
@@ -18,4 +35,33 @@ describe('go/token override', () => {
     expect(Position_String(pos)).toBe('test.go:3:9')
     expect(pos.clone().String()).toBe('test.go:3:9')
   })
+
+  it('exports Go token constants and predicates', () => {
+    expect(Token_String(ADD)).toBe('+')
+    expect(Token_String(COMMENT)).toBe('COMMENT')
+    expect(Token_Precedence(ADD)).toBe(4)
+    expect(Token_IsLiteral(IDENT)).toBe(true)
+    expect(Token_IsKeyword(IF)).toBe(true)
+    expect(Lookup('if')).toBe(IF)
+    expect(Lookup('value')).toBe(IDENT)
+    expect(IsKeyword('func')).toBe(true)
+    expect(IsIdentifier('value42')).toBe(true)
+    expect(IsIdentifier('func')).toBe(false)
+  })
+
+  it('tracks files and source positions', () => {
+    const fset = NewFileSet()
+    expect(fset).toBeInstanceOf(FileSet)
+
+    const file = fset.AddFile('test.go', -1, 12)
+    file.SetLinesForContent($.stringToBytes('one\ntwo\nthree'))
+    file.AddLineColumnInfo(4, 'other.go', 20, 3)
+
+    const pos = file.Pos(5)
+    expect(file.Offset(pos)).toBe(5)
+    expect(file.Line(pos)).toBe(20)
+    expect(Position_String(file.Position(pos))).toBe('other.go:20:4')
+    expect(Position_String(fset.Position(pos))).toBe('other.go:20:4')
+    expect(fset.File(pos)).toBe(file)
+  })
 })