goscript 0.1.1 → 0.1.3

package/gs/crypto/sha256/index.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { New, New224, Size, Size224, Sum224, Sum256 } from './index.js'
+
+describe('crypto/sha256 override', () => {
+  test('sums with WebCrypto', async () => {
+    const sum = await Sum256($.stringToBytes('abc'))
+    expect(Array.from(sum)).toEqual([
+      186, 120, 22, 191, 143, 1, 207, 234, 65, 65, 64, 222, 93, 174, 34, 35,
+      176, 3, 97, 163, 150, 23, 122, 156, 180, 16, 255, 97, 242, 0, 21, 173,
+    ])
+  })
+
+  test('streaming digest appends to prefix', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('a'))).toEqual([1, null])
+    expect(digest.Write($.stringToBytes('bc'))).toEqual([2, null])
+
+    const out = await digest.Sum(new Uint8Array([1, 2]))
+    expect(Array.from(out).slice(0, 2)).toEqual([1, 2])
+    expect(out.length).toBe(Size + 2)
+    expect(Array.from(out).slice(2)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+  })
+
+  test('sums SHA-224 with host crypto', async () => {
+    const sum = await Sum224($.stringToBytes('abc'))
+    expect(Array.from(sum)).toEqual([
+      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179,
+      42, 173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
+    ])
+  })
+
+  test('streaming SHA-224 digest appends to prefix', async () => {
+    const digest = New224()
+    expect(digest.Write($.stringToBytes('a'))).toEqual([1, null])
+    expect(digest.Write($.stringToBytes('bc'))).toEqual([2, null])
+
+    const out = await digest.Sum(new Uint8Array([1, 2]))
+    expect(Array.from(out).slice(0, 2)).toEqual([1, 2])
+    expect(out.length).toBe(Size224 + 2)
+    expect(Array.from(out).slice(2)).toEqual(
+      Array.from(await Sum224($.stringToBytes('abc'))),
+    )
+  })
+
+  test('streaming Sum does not finalize the digest', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('abc'))).toEqual([3, null])
+
+    const first = await digest.Sum(null)
+    expect(Array.from(first)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+
+    expect(digest.Write($.stringToBytes('d'))).toEqual([1, null])
+    const second = await digest.Sum(null)
+    expect(Array.from(second)).toEqual(
+      Array.from(await Sum256($.stringToBytes('abcd'))),
+    )
+  })
+
+  test('streaming digest handles many small writes', async () => {
+    const digest = New()
+    let data = ''
+    for (let i = 0; i < 4096; i++) {
+      const part = `key-${i};`
+      data += part
+      expect(digest.Write($.stringToBytes(part))).toEqual([part.length, null])
+    }
+
+    expect(Array.from(await digest.Sum(null))).toEqual(
+      Array.from(await Sum256($.stringToBytes(data))),
+    )
+  })
+})

package/gs/crypto/sha256/index.ts

@@ -0,0 +1,150 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 32
+export const Size224 = 28
+export const BlockSize = 64
+
+type ShaAlgorithm = 'sha224' | 'sha256'
+
+class Sha256Error {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    return this.algorithm === 'sha224' ? Size224 : Size
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha256')
+}
+
+export function New224(): any {
+  return new Digest('sha224')
+}
+
+export async function Sum224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha224', data)
+}
+
+export async function Sum256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  if (algorithm === 'sha224') {
+    throw new Error(
+      new Sha256Error('crypto/sha256: SHA-224 digest is unavailable').Error(),
+    )
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null) {
+    throw new Error(
+      new Sha256Error('crypto/sha256: WebCrypto digest is unavailable').Error(),
+    )
+  }
+
+  const digest = await subtle.digest(
+    'SHA-256',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
+  const out = new Uint8Array(prefix.length + digest.length)
+  out.set(prefix)
+  out.set(digest, prefix.length)
+  return out
+}
+
+function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha256/meta.json

@@ -0,0 +1,9 @@
+{
+  "asyncFunctions": {
+    "Sum224": true,
+    "Sum256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/crypto/sha512/index.test.ts

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+
+import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+
+describe('crypto/sha512 override', () => {
+  it('matches Node digests', async () => {
+    const data = new TextEncoder().encode('goscript sha512')
+
+    expect(toHex(await Sum512(data))).toBe(nodeHash('sha512', data))
+    expect(toHex(await Sum384(data))).toBe(nodeHash('sha384', data))
+    expect(toHex(await Sum512_224(data))).toBe(nodeHash('sha512-224', data))
+    expect(toHex(await Sum512_256(data))).toBe(nodeHash('sha512-256', data))
+  })
+
+  it('supports incremental hash.Hash use', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('go'))
+    h.Write(new TextEncoder().encode('script'))
+
+    expect(toHex(await h.Sum(null))).toBe(nodeHash('sha512', new TextEncoder().encode('goscript')))
+  })
+})
+
+function nodeHash(algorithm: string, data: Uint8Array): string {
+  return createHash(algorithm).update(data).digest('hex')
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/gs/crypto/sha512/index.ts

@@ -0,0 +1,161 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 64
+export const Size224 = 28
+export const Size256 = 32
+export const Size384 = 48
+export const BlockSize = 128
+
+type ShaAlgorithm = 'sha384' | 'sha512' | 'sha512-224' | 'sha512-256'
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    switch (this.algorithm) {
+      case 'sha384':
+        return Size384
+      case 'sha512-224':
+        return Size224
+      case 'sha512-256':
+        return Size256
+      default:
+        return Size
+    }
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha512')
+}
+
+export function New384(): any {
+  return new Digest('sha384')
+}
+
+export function New512_224(): any {
+  return new Digest('sha512-224')
+}
+
+export function New512_256(): any {
+  return new Digest('sha512-256')
+}
+
+export async function Sum384(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha384', data)
+}
+
+export async function Sum512(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512', data)
+}
+
+export async function Sum512_224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-224', data)
+}
+
+export async function Sum512_256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null || (algorithm !== 'sha384' && algorithm !== 'sha512')) {
+    throw new Error(`crypto/sha512: ${algorithm} digest is unavailable`)
+  }
+
+  const digest = await subtle.digest(
+    algorithm === 'sha384' ? 'SHA-384' : 'SHA-512',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
+  const out = new Uint8Array(prefix.length + digest.length)
+  out.set(prefix)
+  out.set(digest, prefix.length)
+  return out
+}
+
+function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha512/meta.json

@@ -0,0 +1,11 @@
+{
+  "asyncFunctions": {
+    "Sum384": true,
+    "Sum512": true,
+    "Sum512_224": true,
+    "Sum512_256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/encoding/json/index.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Marshal, MarshalIndent, Unmarshal } from './index.js'
+import { Marshal, MarshalIndent, Unmarshal, type Unmarshaler } from './index.js'
 
 class Person {
   public _fields = {
@@ -17,14 +17,36 @@ class Person {
     [],
     Person,
     {
-      Name: { type: { kind: $.TypeKind.Basic, name: 'string' }, tag: 'json:"name"' },
+      Name: {
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+        tag: 'json:"name"',
+      },
       Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
-      Active: { type: { kind: $.TypeKind.Basic, name: 'bool' }, tag: 'json:"active"' },
+      Active: {
+        type: { kind: $.TypeKind.Basic, name: 'bool' },
+        tag: 'json:"active"',
+      },
     },
   )
 }
 
 describe('encoding/json override', () => {
+  it('registers the Unmarshaler interface shape', () => {
+    class CustomUnmarshaler implements Unmarshaler {
+      UnmarshalJSON(_data: $.Slice<number>): $.GoError {
+        return null
+      }
+    }
+
+    const [value, ok] = $.typeAssertTuple<Unmarshaler>(
+      new CustomUnmarshaler(),
+      'json.Unmarshaler',
+    )
+
+    expect(ok).toBe(true)
+    expect(value.UnmarshalJSON($.stringToBytes('{}'))).toBeNull()
+  })
+
   it('marshals struct fields through json tags', () => {
     const person = new Person()
     person._fields.Name.value = 'Alice'

package/gs/encoding/json/index.ts

@@ -1,5 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
 
+export interface Unmarshaler {
+  UnmarshalJSON(data: $.Slice<number>): $.GoError
+}
+
+$.registerInterfaceType('json.Unmarshaler', null, [
+  {
+    name: 'UnmarshalJSON',
+    args: [
+      {
+        name: 'data',
+        type: {
+          kind: $.TypeKind.Slice,
+          elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+        },
+      },
+    ],
+    returns: [{ type: 'GoError' }],
+  },
+])
+
 export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   try {
     return [$.stringToBytes(JSON.stringify(marshalValue(v))), null]
@@ -147,9 +167,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   )
 }
 
-function structFieldMetadata(
-  value: unknown,
-): Record<string, { tag?: string }> {
+function structFieldMetadata(value: unknown): Record<string, { tag?: string }> {
   if (value === null || typeof value !== 'object') {
     return {}
   }

package/gs/errors/errors.test.ts

@@ -43,7 +43,10 @@ describe('errors.AsType', () => {
 
   it('walks wrapped errors depth first', () => {
     const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
-    const wrapped = $.interfaceValue<$.GoError>(new Wrapper(dns), '*main.Wrapper')
+    const wrapped = $.interfaceValue<$.GoError>(
+      new Wrapper(dns),
+      '*main.Wrapper',
+    )
 
     const [matched, ok] = AsType(dnsTypeArgs, Join(null, wrapped))
 

package/gs/errors/errors.ts

@@ -191,10 +191,7 @@ export function As(err: $.GoError, target: any): boolean {
     throw new Error('errors: target cannot be nil')
   }
 
-  // Check if err matches target type
-  if (err.constructor === target.constructor) {
-    // Copy properties from err to target
-    Object.assign(target, err)
+  if (assignAsTarget(err, target)) {
     return true
   }
 
@@ -230,6 +227,36 @@ export function As(err: $.GoError, target: any): boolean {
   return false
 }
 
+function assignAsTarget(err: Exclude<$.GoError, null>, target: any): boolean {
+  const targetType = asTargetType(target)
+  if (targetType !== undefined) {
+    const [matched, ok] = $.typeAssertTuple<any>(err, targetType)
+    if (!ok) {
+      return false
+    }
+    if ($.isVarRef(target)) {
+      target.value = matched
+      return true
+    }
+    Object.assign(target, matched)
+    return true
+  }
+
+  if (err.constructor === target.constructor) {
+    Object.assign(target, err)
+    return true
+  }
+  return false
+}
+
+function asTargetType(target: any): string | undefined {
+  const goType = target?.__goType
+  if (typeof goType !== 'string' || !goType.startsWith('*')) {
+    return undefined
+  }
+  return goType.slice(1)
+}
+
 // AsType finds the first error in err's tree that matches the generic error
 // type E, returning the matching error and true. Otherwise it returns E's zero
 // value and false.
@@ -263,10 +290,7 @@ function asType(
     const result = (err as any).Unwrap()
     if (Array.isArray(result)) {
       for (const wrappedErr of result) {
-        if (
-          wrappedErr &&
-          typeof wrappedErr.Error === 'function'
-        ) {
+        if (wrappedErr && typeof wrappedErr.Error === 'function') {
           const [matched, matchedOK] = asType(wrappedErr, typeInfo, zero)
           if (matchedOK) {
             return [matched, true]

package/gs/fmt/fmt.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
+import * as $ from '@goscript/builtin/index.js'
 import * as fmt from './fmt.js'
 
 const originalDeno = (globalThis as any).Deno
@@ -36,7 +37,9 @@ function captureStdout(run: () => void): string {
           length?: number,
           _position?: number | null,
         ) => {
-          buf += new TextDecoder().decode(chunk.subarray(0, length ?? chunk.length))
+          buf += new TextDecoder().decode(
+            chunk.subarray(0, length ?? chunk.length),
+          )
           return length ?? chunk.length
         },
       ),
@@ -185,3 +188,22 @@ describe('fmt parseFormat basic cases', () => {
     expect(fmt.Sprintf('%c', 65)).toBe('A')
   })
 })
+
+describe('fmt scanning', () => {
+  it('scans decimal fields separated by literals', () => {
+    const start = $.varRef(0)
+    const end = $.varRef(0)
+
+    const [n, err] = fmt.Sscanf(
+      'bytes=12-34',
+      'bytes=%d-%d',
+      $.interfaceValue(start, '*int64'),
+      $.interfaceValue(end, '*int64'),
+    )
+
+    expect(err).toBeNull()
+    expect(n).toBe(2)
+    expect(start.value).toBe(12)
+    expect(end.value).toBe(34)
+  })
+})