goscript 0.1.1 → 0.1.2

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/token/index.ts

@@ -368,7 +368,10 @@ export class File {
 
   public AddLine(offset: number): void {
     const last = this.linesValue[this.linesValue.length - 1]
-    if ((this.linesValue.length === 0 || last < offset) && offset < this.sizeValue) {
+    if (
+      (this.linesValue.length === 0 || last < offset) &&
+      offset < this.sizeValue
+    ) {
       this.linesValue.push(offset)
     }
   }
@@ -428,8 +431,16 @@ export class File {
     column: number,
   ): void {
     const last = this.infosValue[this.infosValue.length - 1]
-    if ((this.infosValue.length === 0 || last.Offset < offset) && offset < this.sizeValue) {
-      this.infosValue.push({ Offset: offset, Filename: filename, Line: line, Column: column })
+    if (
+      (this.infosValue.length === 0 || last.Offset < offset) &&
+      offset < this.sizeValue
+    ) {
+      this.infosValue.push({
+        Offset: offset,
+        Filename: filename,
+        Line: line,
+        Column: column,
+      })
     }
   }
 
@@ -567,7 +578,9 @@ export class FileSet {
     if (pos === NoPos) {
       return null
     }
-    return this.files.find((file) => file.Base() <= pos && pos <= file.End()) ?? null
+    return (
+      this.files.find((file) => file.Base() <= pos && pos <= file.End()) ?? null
+    )
   }
 
   public PositionFor(pos: Pos, adjusted: boolean): Position {

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

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '../../builtin/index.js'
+import {
+  New128,
+  New128a,
+  New32,
+  New32a,
+  New64,
+  New64a,
+} from './index.js'
+
+describe('hash/fnv override', () => {
+  it('matches Go FNV sums for hello', async () => {
+    const h32 = New32()
+    h32.Write($.stringToBytes('hello'))
+    expect(h32.Sum32()).toBe(0xb6fa7167)
+    expect(hex(await h32.Sum($.stringToBytes('prefix')))).toBe(
+      '707265666978b6fa7167',
+    )
+    expect(h32.Size()).toBe(4)
+
+    const h32a = New32a()
+    h32a.Write($.stringToBytes('hello'))
+    expect(h32a.Sum32()).toBe(0x4f9f2cab)
+    expect(hex(await h32a.Sum(null))).toBe('4f9f2cab')
+
+    const h64 = New64()
+    h64.Write($.stringToBytes('hello'))
+    expect(h64.Sum64()).toBe(0x7b495389bdbdd4c7n)
+    expect(hex(await h64.Sum(null))).toBe('7b495389bdbdd4c7')
+
+    const h64a = New64a()
+    h64a.Write($.stringToBytes('hello'))
+    expect(h64a.Sum64()).toBe(0xa430d84680aabd0bn)
+    expect(hex(await h64a.Sum(null))).toBe('a430d84680aabd0b')
+
+    const h128 = New128()
+    h128.Write($.stringToBytes('hello'))
+    expect(hex(await h128.Sum(null))).toBe('f14b58486483d94f708038798c29697f')
+
+    const h128a = New128a()
+    h128a.Write($.stringToBytes('hello'))
+    expect(hex(await h128a.Sum(null))).toBe('e3e1efd54283d94f7081314b599d31b3')
+  })
+
+  it('marshals and restores state', async () => {
+    const hash = New128a()
+    hash.Write($.stringToBytes('hello'))
+    const [state, marshalErr] = hash.MarshalBinary()
+    expect(marshalErr).toBeNull()
+
+    const restored = New128a()
+    expect(restored.UnmarshalBinary(state)).toBeNull()
+    restored.Write($.stringToBytes(' world'))
+
+    const expected = New128a()
+    expected.Write($.stringToBytes('hello world'))
+    expect(hex(await restored.Sum(null))).toBe(hex(await expected.Sum(null)))
+  })
+})
+
+function hex(bytes: $.Bytes): string {
+  return Array.from($.bytesToUint8Array(bytes), (b) =>
+    b.toString(16).padStart(2, '0'),
+  ).join('')
+}

package/gs/hash/fnv/index.ts

@@ -0,0 +1,351 @@
+import * as $ from '@goscript/builtin/index.js'
+
+const offset32 = 0x811c9dc5
+const offset64 = 0xcbf29ce484222325n
+const offset128Lower = 0x62b821756295c58dn
+const offset128Higher = 0x6c62272e07bb0142n
+const offset128 = (offset128Higher << 64n) | offset128Lower
+const prime32 = 0x01000193
+const prime64 = 0x00000100000001b3n
+const prime128 = (1n << 88n) | 0x13bn
+const uint64Mask = 0xffffffffffffffffn
+const uint128Mask = 0xffffffffffffffffffffffffffffffffn
+
+const magic32 = bytes('fnv\x01')
+const magic32a = bytes('fnv\x02')
+const magic64 = bytes('fnv\x03')
+const magic64a = bytes('fnv\x04')
+const magic128 = bytes('fnv\x05')
+const magic128a = bytes('fnv\x06')
+
+class FNV32 {
+  private hash = offset32
+
+  constructor(
+    private readonly alternate: boolean,
+    private readonly magic: Uint8Array,
+  ) {}
+
+  Write(data: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(data)
+    let hash = this.hash >>> 0
+    if (this.alternate) {
+      for (const c of bytes) {
+        hash ^= c
+        hash = Math.imul(hash, prime32) >>> 0
+      }
+    } else {
+      for (const c of bytes) {
+        hash = Math.imul(hash, prime32) >>> 0
+        hash ^= c
+      }
+    }
+    this.hash = hash >>> 0
+    return [bytes.length, null]
+  }
+
+  async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
+    return appendBytes($.bytesToUint8Array(prefix), be32(this.hash))
+  }
+
+  Sum32(): number {
+    return this.hash >>> 0
+  }
+
+  Reset(): void {
+    this.hash = offset32
+  }
+
+  Size(): number {
+    return 4
+  }
+
+  BlockSize(): number {
+    return 1
+  }
+
+  AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
+    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)), null]
+  }
+
+  MarshalBinary(): [$.Bytes, $.GoError] {
+    return this.AppendBinary(null)
+  }
+
+  UnmarshalBinary(data: $.Bytes): $.GoError {
+    const state = $.bytesToUint8Array(data)
+    const err = validateState(state, this.magic, 8)
+    if (err != null) {
+      return err
+    }
+    this.hash = readBE32(state, 4)
+    return null
+  }
+
+  Clone(): [FNV32, $.GoError] {
+    const clone = new FNV32(this.alternate, this.magic)
+    clone.hash = this.hash
+    return [clone, null]
+  }
+}
+
+class FNV64 {
+  private hash = offset64
+
+  constructor(
+    private readonly alternate: boolean,
+    private readonly magic: Uint8Array,
+  ) {}
+
+  Write(data: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(data)
+    let hash = this.hash
+    if (this.alternate) {
+      for (const c of bytes) {
+        hash ^= BigInt(c)
+        hash = (hash * prime64) & uint64Mask
+      }
+    } else {
+      for (const c of bytes) {
+        hash = (hash * prime64) & uint64Mask
+        hash ^= BigInt(c)
+      }
+    }
+    this.hash = hash
+    return [bytes.length, null]
+  }
+
+  async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
+    return appendBytes($.bytesToUint8Array(prefix), be64(this.hash))
+  }
+
+  Sum64(): bigint {
+    return this.hash
+  }
+
+  Reset(): void {
+    this.hash = offset64
+  }
+
+  Size(): number {
+    return 8
+  }
+
+  BlockSize(): number {
+    return 1
+  }
+
+  AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
+    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)), null]
+  }
+
+  MarshalBinary(): [$.Bytes, $.GoError] {
+    return this.AppendBinary(null)
+  }
+
+  UnmarshalBinary(data: $.Bytes): $.GoError {
+    const state = $.bytesToUint8Array(data)
+    const err = validateState(state, this.magic, 12)
+    if (err != null) {
+      return err
+    }
+    this.hash = readBE64(state, 4)
+    return null
+  }
+
+  Clone(): [FNV64, $.GoError] {
+    const clone = new FNV64(this.alternate, this.magic)
+    clone.hash = this.hash
+    return [clone, null]
+  }
+}
+
+class FNV128 {
+  private hash = offset128
+
+  constructor(
+    private readonly alternate: boolean,
+    private readonly magic: Uint8Array,
+  ) {}
+
+  Write(data: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(data)
+    let hash = this.hash
+    for (const c of bytes) {
+      if (this.alternate) {
+        hash ^= BigInt(c)
+      }
+      hash = (hash * prime128) & uint128Mask
+      if (!this.alternate) {
+        hash ^= BigInt(c)
+      }
+    }
+    this.hash = hash
+    return [bytes.length, null]
+  }
+
+  async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
+    return appendBytes($.bytesToUint8Array(prefix), be64(this.high()), be64(this.low()))
+  }
+
+  Reset(): void {
+    this.hash = offset128
+  }
+
+  Size(): number {
+    return 16
+  }
+
+  BlockSize(): number {
+    return 1
+  }
+
+  AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.high()), be64(this.low())),
+      null,
+    ]
+  }
+
+  MarshalBinary(): [$.Bytes, $.GoError] {
+    return this.AppendBinary(null)
+  }
+
+  UnmarshalBinary(data: $.Bytes): $.GoError {
+    const state = $.bytesToUint8Array(data)
+    const err = validateState(state, this.magic, 20)
+    if (err != null) {
+      return err
+    }
+    this.hash = ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
+    return null
+  }
+
+  Clone(): [FNV128, $.GoError] {
+    const clone = new FNV128(this.alternate, this.magic)
+    clone.hash = this.hash
+    return [clone, null]
+  }
+
+  private high(): bigint {
+    return (this.hash >> 64n) & uint64Mask
+  }
+
+  private low(): bigint {
+    return this.hash & uint64Mask
+  }
+}
+
+export function New32(): FNV32 {
+  return $.interfaceValue<FNV32>(new FNV32(false, magic32), '*fnv.sum32')
+}
+
+export function New32a(): FNV32 {
+  return $.interfaceValue<FNV32>(new FNV32(true, magic32a), '*fnv.sum32a')
+}
+
+export function New64(): FNV64 {
+  return $.interfaceValue<FNV64>(new FNV64(false, magic64), '*fnv.sum64')
+}
+
+export function New64a(): FNV64 {
+  return $.interfaceValue<FNV64>(new FNV64(true, magic64a), '*fnv.sum64a')
+}
+
+export function New128(): FNV128 {
+  return $.interfaceValue<FNV128>(new FNV128(false, magic128), '*fnv.sum128')
+}
+
+export function New128a(): FNV128 {
+  return $.interfaceValue<FNV128>(new FNV128(true, magic128a), '*fnv.sum128a')
+}
+
+function bytes(value: string): Uint8Array {
+  return $.stringToBytes(value)
+}
+
+function appendBytes(prefix: Uint8Array, ...chunks: Uint8Array[]): Uint8Array {
+  let size = prefix.length
+  for (const chunk of chunks) {
+    size += chunk.length
+  }
+  const out = new Uint8Array(size)
+  out.set(prefix)
+  let offset = prefix.length
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function be32(value: number): Uint8Array {
+  return new Uint8Array([
+    (value >>> 24) & 0xff,
+    (value >>> 16) & 0xff,
+    (value >>> 8) & 0xff,
+    value & 0xff,
+  ])
+}
+
+function be64(value: bigint): Uint8Array {
+  const word = value & uint64Mask
+  return new Uint8Array([
+    Number((word >> 56n) & 0xffn),
+    Number((word >> 48n) & 0xffn),
+    Number((word >> 40n) & 0xffn),
+    Number((word >> 32n) & 0xffn),
+    Number((word >> 24n) & 0xffn),
+    Number((word >> 16n) & 0xffn),
+    Number((word >> 8n) & 0xffn),
+    Number(word & 0xffn),
+  ])
+}
+
+function readBE32(bytes: Uint8Array, offset: number): number {
+  return (
+    ((bytes[offset] << 24) >>> 0) |
+    (bytes[offset + 1] << 16) |
+    (bytes[offset + 2] << 8) |
+    bytes[offset + 3]
+  ) >>> 0
+}
+
+function readBE64(bytes: Uint8Array, offset: number): bigint {
+  return (
+    (BigInt(bytes[offset]) << 56n) |
+    (BigInt(bytes[offset + 1]) << 48n) |
+    (BigInt(bytes[offset + 2]) << 40n) |
+    (BigInt(bytes[offset + 3]) << 32n) |
+    (BigInt(bytes[offset + 4]) << 24n) |
+    (BigInt(bytes[offset + 5]) << 16n) |
+    (BigInt(bytes[offset + 6]) << 8n) |
+    BigInt(bytes[offset + 7])
+  )
+}
+
+function validateState(
+  state: Uint8Array,
+  magic: Uint8Array,
+  size: number,
+): $.GoError {
+  if (!startsWith(state, magic)) {
+    return $.newError('hash/fnv: invalid hash state identifier')
+  }
+  if (state.length !== size) {
+    return $.newError('hash/fnv: invalid hash state size')
+  }
+  return null
+}
+
+function startsWith(value: Uint8Array, prefix: Uint8Array): boolean {
+  if (value.length < prefix.length) {
+    return false
+  }
+  for (let i = 0; i < prefix.length; i++) {
+    if (value[i] !== prefix[i]) {
+      return false
+    }
+  }
+  return true
+}

package/gs/hash/fnv/meta.json

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

package/gs/hash/index.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '../builtin/index.js'
+
+import './index.js'
+
+class FakeHash {
+  Write(p: $.Bytes): [number, $.GoError] {
+    return [$.len(p), null]
+  }
+
+  Sum(b: $.Bytes): $.Bytes {
+    return b
+  }
+
+  Reset(): void {}
+
+  Size(): number {
+    return 20
+  }
+
+  BlockSize(): number {
+    return 64
+  }
+}
+
+describe('hash runtime contracts', () => {
+  it('registers Hash for runtime type assertions', () => {
+    const [value, ok] = $.typeAssertTuple<FakeHash>(
+      new FakeHash(),
+      'hash.Hash',
+    )
+
+    expect(ok).toBe(true)
+    expect(value).toBeInstanceOf(FakeHash)
+  })
+})

package/gs/hash/index.ts

@@ -0,0 +1,118 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export interface Hash {
+  Write(p: $.Bytes): [number, $.GoError]
+  Sum(b: $.Bytes): Promise<$.Bytes>
+  Reset(): void
+  Size(): number
+  BlockSize(): number
+}
+
+export interface Hash32 extends Hash {
+  Sum32(): number
+}
+
+export interface Hash64 extends Hash {
+  Sum64(): bigint
+}
+
+export interface Cloner {
+  Clone(): [Hash, $.GoError]
+}
+
+const bytesType: $.SliceTypeInfo = {
+  kind: $.TypeKind.Slice,
+  elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+}
+const intType: $.BasicTypeInfo = { kind: $.TypeKind.Basic, name: 'int' }
+const uint32Type: $.BasicTypeInfo = {
+  kind: $.TypeKind.Basic,
+  name: 'uint32',
+}
+const uint64Type: $.BasicTypeInfo = {
+  kind: $.TypeKind.Basic,
+  name: 'uint64',
+}
+const errorType: $.InterfaceTypeInfo = {
+  kind: $.TypeKind.Interface,
+  name: 'error',
+  methods: [],
+}
+
+$.registerInterfaceType('hash.Hash', null, [
+  {
+    name: 'Write',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  {
+    name: 'Sum',
+    args: [{ name: 'b', type: bytesType }],
+    returns: [{ name: '_r0', type: bytesType }],
+  },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'Size', args: [], returns: [{ name: '_r0', type: intType }] },
+  { name: 'BlockSize', args: [], returns: [{ name: '_r0', type: intType }] },
+])
+
+$.registerInterfaceType('hash.Hash32', null, [
+  {
+    name: 'Write',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  {
+    name: 'Sum',
+    args: [{ name: 'b', type: bytesType }],
+    returns: [{ name: '_r0', type: bytesType }],
+  },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'Size', args: [], returns: [{ name: '_r0', type: intType }] },
+  { name: 'BlockSize', args: [], returns: [{ name: '_r0', type: intType }] },
+  {
+    name: 'Sum32',
+    args: [],
+    returns: [{ name: '_r0', type: uint32Type }],
+  },
+])
+
+$.registerInterfaceType('hash.Hash64', null, [
+  {
+    name: 'Write',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  {
+    name: 'Sum',
+    args: [{ name: 'b', type: bytesType }],
+    returns: [{ name: '_r0', type: bytesType }],
+  },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'Size', args: [], returns: [{ name: '_r0', type: intType }] },
+  { name: 'BlockSize', args: [], returns: [{ name: '_r0', type: intType }] },
+  {
+    name: 'Sum64',
+    args: [],
+    returns: [{ name: '_r0', type: uint64Type }],
+  },
+])
+
+$.registerInterfaceType('hash.Cloner', null, [
+  {
+    name: 'Clone',
+    args: [],
+    returns: [
+      { name: '_r0', type: 'hash.Hash' },
+      { name: 'err', type: errorType },
+    ],
+  },
+])

package/gs/hash/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncMethods": {
+    "Hash.Sum": true
+  }
+}

package/gs/internal/byteorder/index.test.ts

@@ -29,11 +29,11 @@ describe('internal/byteorder uint64', () => {
   })
 
   test('appends uint64 values', () => {
-    expect(Array.from(BEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual([
-      0xaa, 0, 0, 0, 0, 0, 0, 1, 2,
-    ])
-    expect(Array.from(LEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual([
-      0xaa, 2, 1, 0, 0, 0, 0, 0, 0,
-    ])
+    expect(Array.from(BEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual(
+      [0xaa, 0, 0, 0, 0, 0, 0, 1, 2],
+    )
+    expect(Array.from(LEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual(
+      [0xaa, 2, 1, 0, 0, 0, 0, 0, 0],
+    )
   })
 })