goscript 0.2.2 → 0.2.4

package/gs/crypto/ed25519/index.ts

@@ -14,8 +14,8 @@ export const SignatureSize = 64
 export const SeedSize = 32
 
 const pkcs8Prefix = new Uint8Array([
-  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70,
-  0x04, 0x22, 0x04, 0x20,
+  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04,
+  0x22, 0x04, 0x20,
 ])
 
 export class Options {
@@ -32,7 +32,10 @@ export class Options {
   }
 }
 
-export function PublicKey_Equal(pub: PublicKey, x: PublicKeyInterface | null): boolean {
+export function PublicKey_Equal(
+  pub: PublicKey,
+  x: PublicKeyInterface | null,
+): boolean {
   const [xx, ok] = $.typeAssertTuple<PublicKey>(x, 'ed25519.PublicKey')
   return ok && bytesEqual(pub, xx)
 }
@@ -47,7 +50,10 @@ export function PrivateKey_Public(priv: PrivateKey): PublicKeyInterface | null {
   )
 }
 
-export function PrivateKey_Equal(priv: PrivateKey, x: PrivateKeyInterface | null): boolean {
+export function PrivateKey_Equal(
+  priv: PrivateKey,
+  x: PrivateKeyInterface | null,
+): boolean {
   const [xx, ok] = $.typeAssertTuple<PrivateKey>(x, 'ed25519.PrivateKey')
   return ok && bytesEqual(priv, xx)
 }
@@ -68,7 +74,9 @@ export async function PrivateKey_Sign(
   return [await Sign(priv, message), null]
 }
 
-export async function GenerateKey(random: io.Reader | null): Promise<[PublicKey, PrivateKey, $.GoError]> {
+export async function GenerateKey(
+  random: io.Reader | null,
+): Promise<[PublicKey, PrivateKey, $.GoError]> {
   const seed = new Uint8Array(SeedSize)
   if (random == null) {
     const subtle = subtleCrypto()
@@ -124,7 +132,10 @@ export async function NewKeyFromSeed(seed: $.Bytes): Promise<PrivateKey> {
   return privateKey
 }
 
-export async function Sign(privateKey: PrivateKey, message: $.Bytes): Promise<$.Bytes> {
+export async function Sign(
+  privateKey: PrivateKey,
+  message: $.Bytes,
+): Promise<$.Bytes> {
   const priv = $.bytesToUint8Array(privateKey)
   if (priv.length !== PrivateKeySize) {
     throw new Error(`ed25519: bad private key length: ${priv.length}`)
@@ -150,7 +161,9 @@ export async function Verify(
   message: $.Bytes,
   sig: $.Bytes,
 ): Promise<boolean> {
-  return (await VerifyWithOptions(publicKey, message, sig, new Options())) == null
+  return (
+    (await VerifyWithOptions(publicKey, message, sig, new Options())) == null
+  )
 }
 
 export async function VerifyWithOptions(

package/gs/crypto/rand/index.ts

@@ -71,7 +71,10 @@ export async function Prime(
   bits: number,
 ): Promise<[any, $.GoError]> {
   if (bits < 2) {
-    return [null, new RandError('crypto/rand: prime size must be at least 2-bit')]
+    return [
+      null,
+      new RandError('crypto/rand: prime size must be at least 2-bit'),
+    ]
   }
 
   const bitOffset = bits % 8
@@ -123,8 +126,8 @@ function newBigInt(): any {
     | { zeroValue?: unknown; ctor?: new () => unknown }
     | undefined
   if (info?.zeroValue !== undefined) {
-    return typeof info.zeroValue === 'function'
-      ? (info.zeroValue as () => unknown)()
+    return typeof info.zeroValue === 'function' ?
+        (info.zeroValue as () => unknown)()
       : info.zeroValue
   }
   if (info?.ctor != null) {

package/gs/embed/index.test.ts

@@ -19,7 +19,7 @@ describe('embed.FS', () => {
     expect(Array.from(data)).toEqual([1, 2, 3])
   })
 
-  it('supports io/fs read, stat, and directory APIs', () => {
+  it('supports io/fs read, stat, and directory APIs', async () => {
     const fsys = markAsStructValue(
       new FS(
         new Map([
@@ -37,18 +37,18 @@ describe('embed.FS', () => {
     expect(readAgainErr).toBeNull()
     expect(Array.from(dataAgain)).toEqual([1, 2, 3])
 
-    const [rootEntries, rootErr] = ReadDir(fsys, '.')
+    const [rootEntries, rootErr] = await ReadDir(fsys, '.')
     expect(rootErr).toBeNull()
     expect(rootEntries!.map((entry) => entry!.Name())).toEqual([
       'assets',
       'config-set.bin',
     ])
 
-    const [assetInfo, statErr] = Stat(fsys, 'assets')
+    const [assetInfo, statErr] = await Stat(fsys, 'assets')
     expect(statErr).toBeNull()
     expect(assetInfo!.IsDir()).toBe(true)
 
-    const [assetEntries, assetErr] = ReadDir(fsys, 'assets')
+    const [assetEntries, assetErr] = await ReadDir(fsys, 'assets')
     expect(assetErr).toBeNull()
     expect(assetEntries!.map((entry) => entry!.Name())).toEqual(['config.json'])
   })

package/gs/embed/index.ts

@@ -166,9 +166,15 @@ class embedFile {
 
   Stat(): [fs.FileInfo, $.GoError] {
     if (this.data === null) {
-      return [new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555), null]
-    }
-    return [new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444), null]
+      return [
+        new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555),
+        null,
+      ]
+    }
+    return [
+      new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444),
+      null,
+    ]
   }
 }
 

package/gs/fmt/fmt.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
 import * as $ from '@goscript/builtin/index.js'
+import * as os from '@goscript/os/index.js'
 import * as fmt from './fmt.js'
 
 const originalDeno = (globalThis as any).Deno
@@ -61,10 +62,15 @@ describe('fmt basic value formatting', () => {
     expect(
       fmt.Sprintf(
         'Type: %T',
-        $.namedValueInterfaceValue(123, 'int', {}, {
-          kind: $.TypeKind.Basic,
-          name: 'int',
-        }),
+        $.namedValueInterfaceValue(
+          123,
+          'int',
+          {},
+          {
+            kind: $.TypeKind.Basic,
+            name: 'int',
+          },
+        ),
       ),
     ).toBe('Type: int')
   })
@@ -187,6 +193,25 @@ describe('fmt spacing rules', () => {
     expect(new TextDecoder().decode(chunks[1])).toBe('hi there 1 2\n')
   })
 
+  it('Fprintln writes Stderr through console.log in browser-like hosts', async () => {
+    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    delete (globalThis as any).Deno
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    try {
+      const [n, err] = await fmt.Fprintln(os.Stderr!, 'err')
+      expect(err).toBeNull()
+      expect(n).toBe(4)
+      expect(consoleLog).toHaveBeenCalledWith('err')
+      expect(consoleError).not.toHaveBeenCalled()
+    } finally {
+      consoleLog.mockRestore()
+      consoleError.mockRestore()
+    }
+  })
+
   it('Fprintf awaits async writers', async () => {
     const chunks: Uint8Array[] = []
     const writer = {

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.test.ts

@@ -258,6 +258,104 @@ class TimestampParentBoundMessage {
   timestamp: TimestampBoundMessage,
 }
 
+const oneofLeafMessageType = {
+  typeName: 'test.OneofLeafBoundMessage',
+  fields: {
+    list: () => [{ localName: 'label', kind: 'scalar' }],
+  },
+}
+
+class OneofLeafBoundMessage {
+  public get Label(): string {
+    return this._fields.Label.value
+  }
+  public set Label(value: string) {
+    this._fields.Label.value = value
+  }
+
+  public _fields: {
+    Label: $.VarRef<string>
+  }
+
+  constructor(init?: Partial<{ Label?: string }>) {
+    this._fields = {
+      Label: $.varRef(init?.Label ?? ''),
+    }
+  }
+}
+
+;(OneofLeafBoundMessage as any).__protobufTypeScriptMessage =
+  oneofLeafMessageType
+;(OneofLeafBoundMessage as any).__protobufTypeScriptFields = {}
+
+class OneofBoundMessage_TabSet {
+  public get TabSet(): OneofLeafBoundMessage | null {
+    return this._fields.TabSet.value
+  }
+  public set TabSet(value: OneofLeafBoundMessage | null) {
+    this._fields.TabSet.value = value
+  }
+
+  public _fields: {
+    TabSet: $.VarRef<OneofLeafBoundMessage | null>
+  }
+
+  constructor(init?: Partial<{ TabSet?: OneofLeafBoundMessage | null }>) {
+    this._fields = {
+      TabSet: $.varRef(init?.TabSet ?? null),
+    }
+  }
+}
+
+class OneofBoundMessage {
+  public get Node(): OneofBoundMessage_TabSet | null {
+    return this._fields.Node.value
+  }
+  public set Node(value: OneofBoundMessage_TabSet | null) {
+    this._fields.Node.value = value
+  }
+
+  public _fields: {
+    Node: $.VarRef<OneofBoundMessage_TabSet | null>
+  }
+
+  constructor(init?: Partial<{ Node?: OneofBoundMessage_TabSet | null }>) {
+    this._fields = {
+      Node: $.varRef(init?.Node ?? null),
+    }
+  }
+}
+
+;(OneofBoundMessage as any).__protobufTypeScriptMessage = {
+  typeName: 'test.OneofBoundMessage',
+  fields: {
+    list: () => [
+      {
+        localName: 'tabSet',
+        kind: 'message',
+        T: oneofLeafMessageType,
+        oneof: { localName: 'node' },
+      },
+    ],
+  },
+  fromBinary: () => ({
+    node: { case: 'tabSet', value: { label: 'files' } },
+  }),
+  toBinary: (value: {
+    node?: { case: string; value?: { label?: string } }
+  }) => {
+    expect(value.node?.case).toBe('tabSet')
+    expect(value.node?.value?.label).toBe('files')
+    return new Uint8Array([7])
+  },
+}
+;(OneofBoundMessage as any).__protobufTypeScriptFields = {
+  tabSet: OneofLeafBoundMessage,
+}
+;(OneofBoundMessage as any).__protobufTypeScriptOneofFields = {
+  node: { tabSet: OneofBoundMessage_TabSet },
+}
+
 describe('protobuf-go-lite EqualVT helpers', () => {
   it('accepts compiler-emitted runtime type arguments', () => {
     const equal = CompareEqualVT<TestValue>({
@@ -405,6 +503,34 @@ describe('protobuf-go-lite TypeScript binding helpers', () => {
     expect(target.Timestamp?.Seconds).toBe(1780230896)
     expect(target.Timestamp?.Nanos).toBe(789000000)
   })
+
+  it('preserves protobuf oneof branches in bound binary helpers', () => {
+    const source = new OneofBoundMessage({
+      Node: new OneofBoundMessage_TabSet({
+        TabSet: new OneofLeafBoundMessage({ Label: 'files' }),
+      }),
+    })
+
+    const [bytes, marshalErr] = MarshalBoundMessageVT(
+      OneofBoundMessage as any,
+      source,
+    )
+
+    expect(marshalErr).toBeNull()
+    expect(Array.from(bytes ?? [])).toEqual([7])
+
+    const target = new OneofBoundMessage()
+    const unmarshalErr = UnmarshalBoundMessageVT(
+      OneofBoundMessage as any,
+      target,
+      new Uint8Array([7]),
+    )
+
+    expect(unmarshalErr).toBeNull()
+    expect(target.Node).toBeInstanceOf(OneofBoundMessage_TabSet)
+    expect(target.Node?.TabSet).toBeInstanceOf(OneofLeafBoundMessage)
+    expect(target.Node?.TabSet?.Label).toBe('files')
+  })
 })
 
 describe('protobuf-go-lite wire helpers', () => {

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.ts

@@ -369,6 +369,10 @@ type BoundFieldInfo = {
 type BoundMessageCtor<T = any> = {
   new (init?: any): T
   __protobufTypeScriptFields?: Record<string, BoundMessageCtor>
+  __protobufTypeScriptOneofFields?: Record<
+    string,
+    Record<string, BoundMessageCtor>
+  >
   __protobufTypeScriptMessage?: BoundMessageType
 }
 
@@ -404,6 +408,10 @@ function boundFieldValue(source: any, field: BoundFieldInfo): any {
   return source[boundFieldGoName(field)]
 }
 
+function boundOneofGroupGoName(field: BoundFieldInfo): string {
+  return boundFieldGoName({ ...field, localName: field.oneof?.localName ?? '' })
+}
+
 function toTypeScriptScalarValue(value: any, field?: BoundFieldInfo): any {
   const unwrapped = $.pointerValueOrNil(value)
   if (
@@ -471,6 +479,27 @@ function toTypeScriptMessage(
   const out: Record<string, unknown> = {}
   for (const field of fields) {
     if (field.oneof != null) {
+      const groupName = field.oneof.localName
+      const group = boundFieldValue(value, {
+        ...field,
+        localName: groupName,
+        oneof: undefined,
+      })
+      if (group == null || out[groupName] !== undefined) {
+        continue
+      }
+      const raw = boundFieldValue(group, field)
+      if (raw === undefined || raw === null) {
+        continue
+      }
+      out[groupName] = {
+        case: field.localName,
+        value: toTypeScriptFieldValue(
+          field,
+          raw,
+          fieldCtors[field.localName] ?? raw?.constructor,
+        ),
+      }
       continue
     }
     const raw = boundFieldValue(value, field)
@@ -566,8 +595,25 @@ function fromTypeScriptMessage(
     return Object.assign(out, value)
   }
   const fieldCtors = ctor.__protobufTypeScriptFields ?? {}
+  const oneofCtors = ctor.__protobufTypeScriptOneofFields ?? {}
   for (const field of fields) {
     if (field.oneof != null) {
+      const groupName = field.oneof.localName
+      const raw = value[groupName]
+      if (raw?.case !== field.localName) {
+        continue
+      }
+      const branchCtor = oneofCtors[groupName]?.[field.localName]
+      const branchValue = fromTypeScriptFieldValue(
+        field,
+        raw.value,
+        fieldCtors[field.localName],
+      )
+      const branchFieldName = boundFieldGoName(field)
+      out[boundOneofGroupGoName(field)] =
+        branchCtor == null ?
+          { [branchFieldName]: branchValue }
+        : new branchCtor({ [branchFieldName]: branchValue })
       continue
     }
     const raw = value[field.localName]

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

@@ -1,7 +1,8 @@
 import * as $ from '@goscript/builtin/index.js'
 
 const btcAlphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const flickrAlphabet = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+const flickrAlphabet =
+  '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
 
 export class Alphabet {
   decode: Int8Array
@@ -130,7 +131,9 @@ export function DecodeAlphabet(
   return FastBase58DecodingAlphabet(str, alphabet)
 }
 
-export function FastBase58Decoding(str: string): [Uint8Array | null, $.GoError] {
+export function FastBase58Decoding(
+  str: string,
+): [Uint8Array | null, $.GoError] {
   return FastBase58DecodingAlphabet(str, BTCAlphabet)
 }
 
@@ -187,7 +190,10 @@ export function FastBase58DecodingAlphabet(
     }
 
     if (c > 0) {
-      return [null, $.newError('Output number too big (carry to the next int32)')]
+      return [
+        null,
+        $.newError('Output number too big (carry to the next int32)'),
+      ]
     }
     if ((outi[0] & zmask) !== 0) {
       return [

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

@@ -20,14 +20,8 @@ import {
 describe('blake3 consts override', () => {
   test('uses portable constants for GoScript', () => {
     expect(IV).toEqual([
-      0x6a09e667,
-      0xbb67ae85,
-      0x3c6ef372,
-      0xa54ff53a,
-      0x510e527f,
-      0x9b05688c,
-      0x1f83d9ab,
-      0x5be0cd19,
+      0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+      0x1f83d9ab, 0x5be0cd19,
     ])
     expect(IV[0]).toBe(IV0)
     expect(BlockLen).toBe(64)

package/gs/golang.org/x/crypto/scrypt/index.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Key } from './index.js'
+
+describe('scrypt override', () => {
+  test('matches Go scrypt vectors', async () => {
+    const vectors = [
+      {
+        password: 'password',
+        salt: 'salt',
+        N: 2,
+        r: 10,
+        p: 10,
+        output:
+          '482c858e229055e62f41e0ec819a5ee18bdb87251a534f75acd95ac5e50aa15f',
+      },
+      {
+        password: 'p',
+        salt: 's',
+        N: 2,
+        r: 1,
+        p: 1,
+        output: '48b0d2a8a3272611984c50ebd630af52',
+      },
+      {
+        password: '',
+        salt: '',
+        N: 16,
+        r: 1,
+        p: 1,
+        output:
+          '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906',
+      },
+    ]
+
+    for (const vector of vectors) {
+      const [key, err] = await Key(
+        $.stringToBytes(vector.password),
+        $.stringToBytes(vector.salt),
+        vector.N,
+        vector.r,
+        vector.p,
+        vector.output.length / 2,
+      )
+      expect(err).toBeNull()
+      expect(toHex(key)).toBe(vector.output)
+    }
+  })
+
+  test('validates invalid parameters like Go', async () => {
+    const invalid = [
+      [0, 1, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [1, 1, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [7, 8, 1, 'scrypt: N must be > 1 and a power of 2'],
+      [2, 0, 1, 'scrypt: parameters must be > 0'],
+      [2, 1, 0, 'scrypt: parameters must be > 0'],
+      [2, -1, 1, 'scrypt: parameters must be > 0'],
+      [2, 1, -1, 'scrypt: parameters must be > 0'],
+    ] as const
+
+    for (const [N, r, p, message] of invalid) {
+      const [key, err] = await Key(
+        $.stringToBytes('p'),
+        $.stringToBytes('s'),
+        N,
+        r,
+        p,
+        32,
+      )
+      expect(key).toBeNull()
+      expect(err?.Error()).toBe(message)
+    }
+  })
+})
+
+function toHex(input: Uint8Array | number[] | null): string {
+  return Array.from(input ?? [])
+    .map((value) => value.toString(16).padStart(2, '0'))
+    .join('')
+}

package/gs/golang.org/x/crypto/scrypt/index.ts

@@ -0,0 +1,54 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import { scryptAsync } from '@noble/hashes/scrypt.js'
+
+const maxInt = Number.MAX_SAFE_INTEGER
+
+export async function Key(
+  password: $.Bytes,
+  salt: $.Bytes,
+  N: number,
+  r: number,
+  p: number,
+  keyLen: number,
+): Promise<[$.Bytes, $.GoError]> {
+  if (N <= 1 || (N & (N - 1)) !== 0) {
+    return [null, errors.New('scrypt: N must be > 1 and a power of 2')]
+  }
+  if (r <= 0 || p <= 0) {
+    return [null, errors.New('scrypt: parameters must be > 0')]
+  }
+  if (
+    r * p >= 1 << 30 ||
+    r > maxInt / 128 / p ||
+    r > maxInt / 256 ||
+    N > maxInt / 128 / r
+  ) {
+    return [null, errors.New('scrypt: parameters are too large')]
+  }
+
+  try {
+    const derived = await scryptAsync(
+      $.bytesToUint8Array(password),
+      $.bytesToUint8Array(salt),
+      {
+        N,
+        r,
+        p,
+        dkLen: keyLen,
+        asyncTick: 8,
+        maxmem: maxInt,
+      },
+    )
+    return [new Uint8Array(derived), null]
+  } catch (err) {
+    return [null, errors.New(`scrypt: ${errorMessage(err)}`)]
+  }
+}
+
+function errorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    return err.message
+  }
+  return String(err)
+}

package/gs/golang.org/x/crypto/scrypt/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncFunctions": {
+    "Key": true
+  }
+}

package/gs/hash/fnv/index.test.ts

@@ -1,14 +1,7 @@
 import { describe, expect, it } from 'vitest'
 
 import * as $ from '../../builtin/index.js'
-import {
-  New128,
-  New128a,
-  New32,
-  New32a,
-  New64,
-  New64a,
-} from './index.js'
+import { New128, New128a, New32, New32a, New64, New64a } from './index.js'
 
 describe('hash/fnv override', () => {
   it('matches Go FNV sums for hello', async () => {