goscript 0.0.84 → 0.1.1

package/gs/errors/errors.ts

@@ -6,6 +6,57 @@ export function New(text: string): $.GoError {
   return $.newError(text)
 }
 
+export function Errorf(format: string, ...args: any[]): $.GoError {
+  return New(formatText(format, args))
+}
+
+export function Wrap(err: $.GoError, message: string): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, message)
+}
+
+export function Wrapf(
+  err: $.GoError,
+  format: string,
+  ...args: any[]
+): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, formatText(format, args))
+}
+
+function wrapError(err: Exclude<$.GoError, null>, message: string): $.GoError {
+  const wrapped = $.newError(`${message}: ${err.Error()}`)
+  ;(wrapped as any).Unwrap = function (): $.GoError {
+    return err
+  }
+  return wrapped
+}
+
+function formatText(format: string, args: any[]): string {
+  let argIndex = 0
+  return format.replace(/%[sdqv%]/g, (match) => {
+    if (match === '%%') {
+      return '%'
+    }
+    if (argIndex >= args.length) {
+      return match
+    }
+    const arg = args[argIndex++]
+    switch (match) {
+      case '%d':
+        return String(Number(arg))
+      case '%q':
+        return JSON.stringify(String(arg))
+      default:
+        return String(arg)
+    }
+  })
+}
+
 // ErrUnsupported indicates that a requested operation cannot be performed,
 // because it is unsupported. For example, a call to os.Link when using a
 // file system that does not support hard links.
@@ -179,6 +230,59 @@ export function As(err: $.GoError, target: any): boolean {
   return false
 }
 
+// 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.
+export function AsType(
+  typeArgs: $.GenericTypeArgs | undefined,
+  err: $.GoError,
+): [any, boolean] {
+  const descriptor = typeArgs?.E
+  const zero = (): any => descriptor?.zero?.() ?? null
+  if (err === null || descriptor?.type === undefined) {
+    return [zero(), false]
+  }
+  return asType(err, descriptor.type, zero)
+}
+
+function asType(
+  err: $.GoError,
+  typeInfo: $.TypeInfo | string,
+  zero: () => any,
+): [any, boolean] {
+  if (err === null) {
+    return [zero(), false]
+  }
+
+  const [asserted, ok] = $.typeAssertTuple<any>(err, typeInfo)
+  if (ok) {
+    return [asserted, true]
+  }
+
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (Array.isArray(result)) {
+      for (const wrappedErr of result) {
+        if (
+          wrappedErr &&
+          typeof wrappedErr.Error === 'function'
+        ) {
+          const [matched, matchedOK] = asType(wrappedErr, typeInfo, zero)
+          if (matchedOK) {
+            return [matched, true]
+          }
+        }
+      }
+      return [zero(), false]
+    }
+    if (result && typeof result.Error === 'function') {
+      return asType(result, typeInfo, zero)
+    }
+  }
+
+  return [zero(), false]
+}
+
 // Join returns an error that wraps the given errors.
 // Any nil error values are discarded.
 // Join returns nil if every value in errs is nil.

package/gs/fmt/fmt.ts

@@ -22,7 +22,7 @@ export interface State {
   Flag(c: number): boolean
   Precision(): [number, boolean]
   Width(): [number, boolean]
-  Write(b: Uint8Array): [number, $.GoError | null]
+  Write(b: $.Bytes): [number, $.GoError | null]
 }
 
 // Simple printf-style formatting implementation
@@ -199,7 +199,11 @@ function parseFormat(format: string, args: any[]): string {
           const verb = format[j]
 
           if (argIndex < args.length) {
-            let formatted = formatValue(args[argIndex], verb)
+            const arg = args[argIndex]
+            let formatted = formatWithState(arg, verb, flags, width, precision)
+            if (formatted === null) {
+              formatted = formatValue(arg, verb)
+            }
 
             // Apply width and precision formatting
             if (width && !precision) {
@@ -217,7 +221,7 @@ function parseFormat(format: string, args: any[]): string {
               (verb === 'f' || verb === 'e' || verb === 'g')
             ) {
               const p = parseInt(precision)
-              const num = Number(args[argIndex])
+              const num = Number(arg)
               if (verb === 'f') {
                 formatted = num.toFixed(p)
               } else if (verb === 'e') {
@@ -257,6 +261,39 @@ function parseFormat(format: string, args: any[]): string {
   return result
 }
 
+function formatWithState(
+  value: any,
+  verb: string,
+  flags: string,
+  width: string,
+  precision: string,
+): string | null {
+  if (!value || typeof value.Format !== 'function') {
+    return null
+  }
+
+  let out = ''
+  const state: State = {
+    Flag(c: number): boolean {
+      return flags.includes(String.fromCharCode(c))
+    },
+    Precision(): [number, boolean] {
+      return precision === '' ? [0, false] : [parseInt(precision), true]
+    },
+    Width(): [number, boolean] {
+      return width === '' ? [0, false] : [parseInt(width), true]
+    },
+    Write(b: $.Bytes): [number, $.GoError | null] {
+      const text = $.bytesToString(b)
+      out += text
+      return [text.length, null]
+    },
+  }
+
+  value.Format(state, verb.codePointAt(0) ?? 0)
+  return out
+}
+
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
@@ -361,34 +398,37 @@ export function Fprintln(w: any, ...a: any[]): [number, $.GoError | null] {
 }
 
 // Append functions (append to byte slice)
-export function Append(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Append(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ')
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
 export function Appendf(
-  b: Uint8Array,
+  b: $.Bytes,
   format: string,
   ...a: any[]
-): Uint8Array {
+): $.Bytes {
   const result = parseFormat(format, a)
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
-export function Appendln(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Appendln(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ') + '\n'
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 

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

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  AppendVarint,
+  CompareEqualVT,
+  DecodeFixed32,
+  DecodeFixed64,
+  DecodeVarint,
+  DecodeVarintInt32,
+  DecodeVarintInt64,
+  DecodeVarintUint32,
+  EncodeVarint,
+  ErrIntOverflow,
+  ErrInvalidLength,
+  ErrUnexpectedEndOfGroup,
+  SizeOfVarint,
+  Skip,
+} from './index.js'
+
+class TestValue {
+  constructor(private readonly value: string) {}
+
+  EqualVT(other: TestValue): boolean {
+    return this.value == other.value
+  }
+}
+
+describe('protobuf-go-lite EqualVT helpers', () => {
+  it('accepts compiler-emitted runtime type arguments', () => {
+    const equal = CompareEqualVT<TestValue>({
+      T: { zero: () => null },
+    })
+
+    expect(equal(new TestValue('a'), new TestValue('a'))).toBe(true)
+    expect(equal(new TestValue('a'), new TestValue('b'))).toBe(false)
+    expect(equal(null, null)).toBe(true)
+  })
+})
+
+describe('protobuf-go-lite wire helpers', () => {
+  it('encodes and decodes varints', () => {
+    const buf = new Uint8Array(4)
+
+    const offset = EncodeVarint(buf, 4, 300)
+
+    expect(offset).toBe(2)
+    expect(Array.from(buf.slice(offset))).toEqual([0xac, 0x02])
+    expect(SizeOfVarint(300)).toBe(2)
+    expect(DecodeVarint(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt32(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt64(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintUint32(buf, offset)).toEqual([300, 4, null])
+    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([
+      0xac,
+      0x02,
+    ])
+  })
+
+  it('decodes fixed64 values', () => {
+    expect(DecodeFixed32(new Uint8Array([0x44, 0x33, 0x22, 0x11]), 0)).toEqual([
+      0x11223344,
+      4,
+      null,
+    ])
+
+    expect(
+      DecodeFixed64(
+        new Uint8Array([0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11]),
+        0,
+      ),
+    ).toEqual([0x1122334455667800, 8, null])
+
+    const [, , err] = DecodeFixed64(new Uint8Array([1, 2, 3]), 0)
+    expect(err?.Error()).toBe('unexpected EOF')
+  })
+
+  it('skips protobuf records', () => {
+    expect(Skip(new Uint8Array([0x08, 0x96, 0x01]))).toEqual([3, null])
+    expect(Skip(new Uint8Array([0x12, 0x03, 0x61, 0x62, 0x63]))).toEqual([
+      5,
+      null,
+    ])
+    expect(Skip(new Uint8Array([0x0c]))).toEqual([
+      0,
+      ErrUnexpectedEndOfGroup,
+    ])
+  })
+
+  it('reports protobuf wire errors as Go errors', () => {
+    expect(ErrInvalidLength?.Error()).toContain('negative length')
+    expect(ErrIntOverflow?.Error()).toContain('integer overflow')
+    const [, eof] = Skip(new Uint8Array([0x08, 0x80]))
+    expect(eof?.Error()).toBe('unexpected EOF')
+  })
+})

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

@@ -1,14 +1,312 @@
+import * as $ from '../../../builtin/index.js'
+
+export const ErrInvalidLength = $.newError(
+  'proto: negative length found during unmarshaling',
+)
+export const ErrIntOverflow = $.newError('proto: integer overflow')
+export const ErrUnexpectedEndOfGroup = $.newError(
+  'proto: unexpected end of group',
+)
+
+export interface Message {
+  SizeVT(): number
+  MarshalToSizedBufferVT(dAtA: $.Slice<number>): [number, $.GoError]
+  MarshalVT(): [$.Slice<number>, $.GoError]
+  UnmarshalVT(data: $.Slice<number>): $.GoError
+  Reset(): void
+}
+
+export interface JSONMessage {
+  MarshalJSON(): [$.Slice<number>, $.GoError]
+  UnmarshalJSON(data: $.Slice<number>): $.GoError
+}
+
+export interface CloneMessage extends Message {
+  CloneMessageVT(): CloneMessage | null
+}
+
+export interface CloneVT<T> extends CloneMessage {
+  CloneVT(): T
+}
+
 export interface EqualVT<T> {
   EqualVT(other: T): boolean
 }
 
-export function IsEqualVT<T extends EqualVT<T>>(t1: T | null, t2: T | null): boolean {
+export function CompareComparable<T>(): (t1: T, t2: T) => boolean {
+  return (t1, t2) => t1 === t2
+}
+
+export function IsEqualVT<T extends EqualVT<T>>(
+  t1: T | null,
+  t2: T | null,
+): boolean
+export function IsEqualVT<T extends EqualVT<T>>(
+  _typeArgs: unknown,
+  t1: T | null,
+  t2: T | null,
+): boolean
+export function IsEqualVT<T extends EqualVT<T>>(
+  arg0: unknown,
+  arg1: T | null,
+  arg2?: T | null,
+): boolean {
+  const t1 = arg2 === undefined ? (arg0 as T | null) : arg1
+  const t2 = arg2 === undefined ? arg1 : arg2
   if (t1 == null || t2 == null) {
     return t1 == t2
   }
   return t1.EqualVT(t2)
 }
 
-export function CompareEqualVT<T extends EqualVT<T>>(): (t1: T | null, t2: T | null) => boolean {
+export function CompareEqualVT<T extends EqualVT<T>>(
+  _typeArgs?: unknown,
+): (t1: T | null, t2: T | null) => boolean {
   return (t1, t2) => IsEqualVT(t1, t2)
 }
+
+export function IsEqualVTSlice<T extends EqualVT<T>>(
+  s1: $.Slice<T>,
+  s2: $.Slice<T>,
+): boolean {
+  if ($.len(s1) !== $.len(s2)) {
+    return false
+  }
+  for (let i = 0; i < $.len(s1); i++) {
+    if (!IsEqualVT((s1 as any)[i] as T, (s2 as any)[i] as T)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function EncodeVarint(
+  dAtA: $.Slice<number>,
+  offset: number,
+  v: number,
+): number {
+  offset -= SizeOfVarint(v)
+  const base = offset
+  while (v >= 0x80) {
+    setByte(dAtA, offset, (v % 0x80) | 0x80)
+    v = Math.floor(v / 0x80)
+    offset++
+  }
+  setByte(dAtA, offset, v)
+  return base
+}
+
+export function AppendVarint(b: $.Slice<number>, v: number): $.Slice<number> {
+  const bytes: number[] = []
+  while (v >= 0x80) {
+    bytes.push((v % 0x80) | 0x80)
+    v = Math.floor(v / 0x80)
+  }
+  bytes.push(v)
+  return $.append(b, ...bytes)
+}
+
+export function ConsumeVarint(b: $.Slice<number>): [number, number] {
+  let v = 0
+  let shift = 0
+  for (let i = 0; i < 10; i++) {
+    if (i >= $.len(b)) {
+      return [0, -1]
+    }
+    const value = byteSliceValue(b, i)
+    if (shift === 63 && value > 1) {
+      return [0, -2]
+    }
+    v += (value & 0x7f) * 2 ** shift
+    if (value < 0x80) {
+      return [v, i + 1]
+    }
+    shift += 7
+  }
+  return [0, -2]
+}
+
+export function SizeOfVarint(x: number): number {
+  let n = 1
+  while (x >= 0x80) {
+    x = Math.floor(x / 0x80)
+    n++
+  }
+  return n
+}
+
+export function DecodeVarint(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  const [v, n] = ConsumeVarint($.goSlice(b, idx, undefined))
+  if (n < 0) {
+    return [0, 0, n === -1 ? ioUnexpectedEOF() : ErrIntOverflow]
+  }
+  return [v, idx + n, null]
+}
+
+export function DecodeVarintInt32(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  const [v, next, err] = DecodeVarint(b, idx)
+  return [toInt32(v), next, err]
+}
+
+export function DecodeVarintInt64(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  return DecodeVarint(b, idx)
+}
+
+export function DecodeVarintUint32(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  const [v, next, err] = DecodeVarint(b, idx)
+  return [v >>> 0, next, err]
+}
+
+export function DecodeFixed32(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  if (idx + 4 > $.len(b)) {
+    return [0, 0, ioUnexpectedEOF()]
+  }
+  const value =
+    byteSliceValue(b, idx) +
+    byteSliceValue(b, idx + 1) * 2 ** 8 +
+    byteSliceValue(b, idx + 2) * 2 ** 16 +
+    byteSliceValue(b, idx + 3) * 2 ** 24
+  return [value >>> 0, idx + 4, null]
+}
+
+export function DecodeFixed64(
+  b: $.Slice<number>,
+  idx: number,
+): [number, number, $.GoError] {
+  if (idx + 8 > $.len(b)) {
+    return [0, 0, ioUnexpectedEOF()]
+  }
+  const low =
+    byteSliceValue(b, idx) +
+    byteSliceValue(b, idx + 1) * 2 ** 8 +
+    byteSliceValue(b, idx + 2) * 2 ** 16 +
+    byteSliceValue(b, idx + 3) * 2 ** 24
+  const high =
+    byteSliceValue(b, idx + 4) +
+    byteSliceValue(b, idx + 5) * 2 ** 8 +
+    byteSliceValue(b, idx + 6) * 2 ** 16 +
+    byteSliceValue(b, idx + 7) * 2 ** 24
+  return [low + high * 2 ** 32, idx + 8, null]
+}
+
+export function Skip(dAtA: $.Slice<number>): [number, $.GoError] {
+  const l = $.len(dAtA)
+  let iNdEx = 0
+  let depth = 0
+  while (iNdEx < l) {
+    let wire = 0
+    for (let shift = 0; ; shift += 7) {
+      if (shift >= 64) {
+        return [0, ErrIntOverflow]
+      }
+      if (iNdEx >= l) {
+        return [0, ioUnexpectedEOF()]
+      }
+      const b = byteSliceValue(dAtA, iNdEx)
+      iNdEx++
+      wire += (b & 0x7f) * 2 ** shift
+      if (b < 0x80) {
+        break
+      }
+    }
+
+    const wireType = wire & 0x7
+    switch (wireType) {
+      case 0:
+        for (let shift = 0; ; shift += 7) {
+          if (shift >= 64) {
+            return [0, ErrIntOverflow]
+          }
+          if (iNdEx >= l) {
+            return [0, ioUnexpectedEOF()]
+          }
+          const b = byteSliceValue(dAtA, iNdEx)
+          iNdEx++
+          if (b < 0x80) {
+            break
+          }
+        }
+        break
+      case 1:
+        iNdEx += 8
+        break
+      case 2: {
+        let length = 0
+        for (let shift = 0; ; shift += 7) {
+          if (shift >= 64) {
+            return [0, ErrIntOverflow]
+          }
+          if (iNdEx >= l) {
+            return [0, ioUnexpectedEOF()]
+          }
+          const b = byteSliceValue(dAtA, iNdEx)
+          iNdEx++
+          length += (b & 0x7f) * 2 ** shift
+          if (b < 0x80) {
+            break
+          }
+        }
+        if (length < 0) {
+          return [0, ErrInvalidLength]
+        }
+        iNdEx += length
+        break
+      }
+      case 3:
+        depth++
+        break
+      case 4:
+        if (depth === 0) {
+          return [0, ErrUnexpectedEndOfGroup]
+        }
+        depth--
+        break
+      case 5:
+        iNdEx += 4
+        break
+      default:
+        return [0, $.newError(`proto: illegal wireType ${wireType}`)]
+    }
+    if (iNdEx < 0) {
+      return [0, ErrInvalidLength]
+    }
+    if (depth === 0) {
+      return [iNdEx, null]
+    }
+  }
+  return [0, ioUnexpectedEOF()]
+}
+
+function byteSliceValue(b: $.Slice<number>, idx: number): number {
+  return $.indexStringOrBytes(b, idx)
+}
+
+function setByte(b: $.Slice<number>, idx: number, value: number): void {
+  if (b == null) {
+    throw new Error('assignment to nil byte slice')
+  }
+  b[idx] = value & 0xff
+}
+
+function toInt32(v: number): number {
+  return v | 0
+}
+
+function ioUnexpectedEOF(): $.GoError {
+  return $.newError('unexpected EOF')
+}