goscript 0.2.4 → 0.2.5

package/gs/encoding/binary/meta.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": ["io"],
+  "asyncFunctions": {
+    "Read": true,
+    "ReadUvarint": true,
+    "ReadVarint": true,
+    "Write": true
+  }
+}

package/gs/encoding/binary/parity.json

@@ -0,0 +1,72 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Append": {
+      "status": "real"
+    },
+    "AppendByteOrder": {
+      "status": "real"
+    },
+    "AppendUvarint": {
+      "status": "real"
+    },
+    "AppendVarint": {
+      "status": "real"
+    },
+    "BigEndian": {
+      "status": "real"
+    },
+    "ByteOrder": {
+      "status": "real"
+    },
+    "Decode": {
+      "status": "real"
+    },
+    "Encode": {
+      "status": "real"
+    },
+    "LittleEndian": {
+      "status": "real"
+    },
+    "MaxVarintLen16": {
+      "status": "real"
+    },
+    "MaxVarintLen32": {
+      "status": "real"
+    },
+    "MaxVarintLen64": {
+      "status": "real"
+    },
+    "NativeEndian": {
+      "status": "real"
+    },
+    "PutUvarint": {
+      "status": "real"
+    },
+    "PutVarint": {
+      "status": "real"
+    },
+    "Read": {
+      "status": "real"
+    },
+    "ReadUvarint": {
+      "status": "real"
+    },
+    "ReadVarint": {
+      "status": "real"
+    },
+    "Size": {
+      "status": "real"
+    },
+    "Uvarint": {
+      "status": "real"
+    },
+    "Varint": {
+      "status": "real"
+    },
+    "Write": {
+      "status": "real"
+    }
+  }
+}

package/gs/fmt/fmt.test.ts

@@ -144,6 +144,34 @@ describe('fmt basic value formatting', () => {
     }
     expect(fmt.Sprintf('value=%s', stringer)).toBe('value=string-value')
   })
+
+  it('uses only fmt.Formatter-shaped Format methods', () => {
+    const formatter = {
+      Format(state: fmt.State, verb: number) {
+        state.Write($.stringToBytes(`${String.fromCharCode(verb)}:ok`))
+      },
+    }
+    expect(fmt.Sprintf('%s', formatter)).toBe('s:ok')
+
+    const nodeLike = {
+      Format(_buf: unknown) {
+        throw new Error('domain Format should not be called by fmt')
+      },
+      String() {
+        return 'node-string'
+      },
+    }
+    expect(fmt.Sprintf('%s', nodeLike)).toBe('node-string')
+  })
+
+  it('allows Sprintf callers to await async stringers', async () => {
+    const stringer = {
+      async String() {
+        return 'async-string'
+      },
+    }
+    expect(await fmt.Sprintf('value=%s', stringer)).toBe('value=async-string')
+  })
 })
 
 describe('fmt spacing rules', () => {

package/gs/fmt/fmt.ts

@@ -98,13 +98,52 @@ function hasGoTypeName(value: unknown): value is { __goType: string } {
   )
 }
 
+type MaybeString = string | PromiseLike<string>
+
+function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T> {
+  return (
+    value !== null &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof (value as { then?: unknown }).then === 'function'
+  )
+}
+
+function toMaybeString(value: unknown): MaybeString {
+  if (isPromiseLike(value)) {
+    return value.then((resolved) => String(resolved))
+  }
+  return String(value)
+}
+
+function joinMaybe(
+  parts: MaybeString[],
+  separator: string,
+  prefix = '',
+  suffix = '',
+): MaybeString {
+  if (parts.some(isPromiseLike)) {
+    return Promise.all(parts.map((part) => Promise.resolve(part))).then(
+      (resolved) => `${prefix}${resolved.join(separator)}${suffix}`,
+    )
+  }
+  return `${prefix}${(parts as string[]).join(separator)}${suffix}`
+}
+
 function defaultFormat(value: any): string {
+  const formatted = defaultFormatMaybe(value)
+  if (isPromiseLike(formatted)) {
+    return String(formatted)
+  }
+  return formatted
+}
+
+function defaultFormatMaybe(value: any): MaybeString {
   if (value === null || value === undefined) return '<nil>'
   if (typeof value === 'boolean') return value ? 'true' : 'false'
   if (typeof value === 'number') return value.toString()
   if (typeof value === 'string') return value
   if (Array.isArray(value))
-    return '[' + value.map(defaultFormat).join(' ') + ']'
+    return joinMaybe(value.map(defaultFormatMaybe), ' ', '[', ']')
   if (typeof value === 'object') {
     // Prefer GoStringer if present
     if (
@@ -112,7 +151,7 @@ function defaultFormat(value: any): string {
       typeof (value as any).GoString === 'function'
     ) {
       try {
-        return (value as any).GoString()
+        return toMaybeString((value as any).GoString())
       } catch {
         // Ignore error by continuing to next case.
       }
@@ -120,7 +159,7 @@ function defaultFormat(value: any): string {
     // Prefer error interface if present
     if ((value as any).Error && typeof (value as any).Error === 'function') {
       try {
-        return (value as any).Error()
+        return toMaybeString((value as any).Error())
       } catch {
         // Ignore error by continuing to next case.
       }
@@ -128,37 +167,54 @@ function defaultFormat(value: any): string {
     // Check for Stringer interface
     if ((value as any).String && typeof (value as any).String === 'function') {
       try {
-        return (value as any).String()
+        return toMaybeString((value as any).String())
       } catch {
         // Ignore error by continuing to next case.
       }
     }
     if ('__goValue' in value) {
-      return defaultFormat((value as { __goValue: unknown }).__goValue)
+      return defaultFormatMaybe((value as { __goValue: unknown }).__goValue)
     }
     // Basic Map/Set rendering
     if (value instanceof Map) {
-      const parts: string[] = []
+      const parts: MaybeString[] = []
       for (const [k, v] of (value as Map<any, any>).entries()) {
-        parts.push(`${defaultFormat(k)}:${defaultFormat(v)}`)
+        const key = defaultFormatMaybe(k)
+        const elem = defaultFormatMaybe(v)
+        if (isPromiseLike(key) || isPromiseLike(elem)) {
+          parts.push(
+            Promise.all([Promise.resolve(key), Promise.resolve(elem)]).then(
+              ([resolvedKey, resolvedElem]) => `${resolvedKey}:${resolvedElem}`,
+            ),
+          )
+        } else {
+          parts.push(`${key}:${elem}`)
+        }
       }
-      return `{${parts.join(' ')}}`
+      return joinMaybe(parts, ' ', '{', '}')
     }
     if (value instanceof Set) {
-      const parts: string[] = []
+      const parts: MaybeString[] = []
       for (const v of (value as Set<any>).values()) {
-        parts.push(defaultFormat(v))
+        parts.push(defaultFormatMaybe(v))
       }
-      return '[' + parts.join(' ') + ']'
+      return joinMaybe(parts, ' ', '[', ']')
     }
     // Default object representation
     if (
       (value as any).constructor?.name &&
       (value as any).constructor.name !== 'Object'
     ) {
-      return `{${Object.entries(value as Record<string, any>)
-        .map(([k, v]) => `${k}:${defaultFormat(v)}`)
-        .join(' ')}}`
+      const parts = Object.entries(value as Record<string, any>).map(
+        ([k, v]) => {
+          const formatted = defaultFormatMaybe(v)
+          if (isPromiseLike(formatted)) {
+            return formatted.then((resolved) => `${k}:${resolved}`)
+          }
+          return `${k}:${formatted}`
+        },
+      )
+      return joinMaybe(parts, ' ', '{', '}')
     }
     try {
       return JSON.stringify(value)
@@ -170,7 +226,79 @@ function defaultFormat(value: any): string {
 }
 
 function parseFormat(format: string, args: any[]): string {
-  let result = ''
+  const formatted = parseFormatMaybe(format, args, false)
+  if (isPromiseLike(formatted)) {
+    return String(formatted)
+  }
+  return formatted
+}
+
+function formatValueMaybe(value: any, verb: string): MaybeString {
+  switch (verb) {
+    case 'v':
+    case 'w':
+    case 's':
+      if (verb === 's') {
+        if (typeof value === 'string') return value
+        if (value instanceof Uint8Array) return $.bytesToString(value)
+      }
+      return defaultFormatMaybe(value)
+    default:
+      return formatValue(value, verb)
+  }
+}
+
+function applyFormatOptions(
+  formatted: MaybeString,
+  arg: any,
+  verb: string,
+  flags: string,
+  width: string,
+  precision: string,
+): MaybeString {
+  const apply = (text: string): string => {
+    let result = text
+    if (width && !precision) {
+      const w = parseInt(width)
+      if (flags.includes('-')) {
+        result = result.padEnd(w)
+      } else {
+        result = result.padStart(w, flags.includes('0') ? '0' : ' ')
+      }
+    } else if (precision && (verb === 'f' || verb === 'e' || verb === 'g')) {
+      const p = parseInt(precision)
+      const num = Number(arg)
+      if (verb === 'f') {
+        result = num.toFixed(p)
+      } else if (verb === 'e') {
+        result = num.toExponential(p)
+      } else if (verb === 'g') {
+        result = num.toPrecision(p)
+      }
+
+      if (width) {
+        const w = parseInt(width)
+        if (flags.includes('-')) {
+          result = result.padEnd(w)
+        } else {
+          result = result.padStart(w)
+        }
+      }
+    }
+    return result
+  }
+  if (isPromiseLike(formatted)) {
+    return formatted.then(apply)
+  }
+  return apply(formatted)
+}
+
+function parseFormatMaybe(
+  format: string,
+  args: any[],
+  allowAsync = true,
+): MaybeString {
+  const parts: MaybeString[] = []
   let argIndex = 0
 
   for (let i = 0; i < format.length; i++) {
@@ -178,7 +306,7 @@ function parseFormat(format: string, args: any[]): string {
       if (i + 1 < format.length) {
         const nextChar = format[i + 1]
         if (nextChar === '%') {
-          result += '%'
+          parts.push('%')
           i++ // skip the next %
           continue
         }
@@ -216,65 +344,38 @@ function parseFormat(format: string, args: any[]): string {
 
           if (argIndex < args.length) {
             const arg = args[argIndex]
-            let formatted = formatWithState(arg, verb, flags, width, precision)
+            let formatted: MaybeString | null =
+              allowAsync ?
+                formatWithStateMaybe(arg, verb, flags, width, precision)
+              : formatWithState(arg, verb, flags, width, precision)
             if (formatted === null) {
-              formatted = formatValue(arg, verb)
-            }
-
-            // Apply width and precision formatting
-            if (width && !precision) {
-              const w = parseInt(width)
-              if (flags.includes('-')) {
-                formatted = formatted.padEnd(w)
-              } else {
-                formatted = formatted.padStart(
-                  w,
-                  flags.includes('0') ? '0' : ' ',
-                )
-              }
-            } else if (
-              precision &&
-              (verb === 'f' || verb === 'e' || verb === 'g')
-            ) {
-              const p = parseInt(precision)
-              const num = Number(arg)
-              if (verb === 'f') {
-                formatted = num.toFixed(p)
-              } else if (verb === 'e') {
-                formatted = num.toExponential(p)
-              } else if (verb === 'g') {
-                formatted = num.toPrecision(p)
-              }
-
-              if (width) {
-                const w = parseInt(width)
-                if (flags.includes('-')) {
-                  formatted = formatted.padEnd(w)
-                } else {
-                  formatted = formatted.padStart(w)
-                }
-              }
+              formatted =
+                allowAsync ?
+                  formatValueMaybe(arg, verb)
+                : formatValue(arg, verb)
             }
 
-            result += formatted
+            parts.push(
+              applyFormatOptions(formatted, arg, verb, flags, width, precision),
+            )
             argIndex++
           } else {
-            result += `%!${verb}(MISSING)`
+            parts.push(`%!${verb}(MISSING)`)
           }
 
           i = j
         } else {
-          result += format[i]
+          parts.push(format[i])
         }
       } else {
-        result += format[i]
+        parts.push(format[i])
       }
     } else {
-      result += format[i]
+      parts.push(format[i])
     }
   }
 
-  return result
+  return joinMaybe(parts, '')
 }
 
 function formatWithState(
@@ -284,7 +385,7 @@ function formatWithState(
   width: string,
   precision: string,
 ): string | null {
-  if (!value || typeof value.Format !== 'function') {
+  if (!value || typeof value.Format !== 'function' || value.Format.length < 2) {
     return null
   }
 
@@ -310,6 +411,42 @@ function formatWithState(
   return out
 }
 
+function formatWithStateMaybe(
+  value: any,
+  verb: string,
+  flags: string,
+  width: string,
+  precision: string,
+): MaybeString | null {
+  if (!value || typeof value.Format !== 'function' || value.Format.length < 2) {
+    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]
+    },
+  }
+
+  const result = value.Format(state, verb.codePointAt(0) ?? 0)
+  if (isPromiseLike(result)) {
+    return result.then(() => out)
+  }
+  return out
+}
+
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
@@ -366,7 +503,7 @@ export function Sprint(...a: any[]): string {
 }
 
 export function Sprintf(format: string, ...a: any[]): string {
-  return parseFormat(format, a)
+  return parseFormatMaybe(format, a) as string
 }
 
 export function Sprintln(...a: any[]): string {

package/gs/fmt/meta.json

@@ -2,7 +2,8 @@
   "asyncFunctions": {
     "Fprint": true,
     "Fprintf": true,
-    "Fprintln": true
+    "Fprintln": true,
+    "Sprintf": true
   },
   "dependencies": [
     "errors"

package/gs/github.com/klauspost/cpuid/v2/index.ts

@@ -0,0 +1,38 @@
+import * as $ from '@goscript/builtin/index.js'
+
+// FeatureID is the identifier for a single CPU feature.
+export type FeatureID = number
+
+// UNKNOWN is the sentinel for an unrecognized feature.
+export const UNKNOWN: FeatureID = -1
+
+// AVX2 identifies AVX2 SIMD support. Matches the upstream iota value.
+export const AVX2: FeatureID = 19
+
+// AVX512F identifies AVX-512 Foundation support. Matches the upstream iota value.
+export const AVX512F: FeatureID = 26
+
+// CPUInfo reports detected CPU capabilities. The browser/wasm target has no
+// SIMD instruction set to detect, so this override reports no features and
+// callers fall back to portable Go implementations.
+export class CPUInfo {
+  constructor(_init?: Partial<{}>) {}
+
+  public clone(): CPUInfo {
+    return $.markAsStructValue(new CPUInfo())
+  }
+
+  // Supports reports whether all listed features are available. The wasm
+  // target never exposes native SIMD features, so this always reports false.
+  public Supports(..._ids: FeatureID[]): boolean {
+    return false
+  }
+}
+
+// CPU holds the detected capabilities of the current CPU. On wasm there is no
+// native CPU feature set, so it reports nothing.
+export let CPU: CPUInfo = $.markAsStructValue(new CPUInfo())
+
+export function __goscript_set_CPU(value: CPUInfo): void {
+  CPU = value
+}

package/gs/github.com/klauspost/cpuid/v2/meta.json

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

package/gs/github.com/pkg/errors/errors.ts

@@ -1,9 +1,8 @@
 import * as $ from '@goscript/builtin/index.js'
 import { callers } from './stack.js'
+import type { StackTrace } from './stack.js'
 
 // Type definitions
-export type Frame = any // Simplified frame type
-export type StackTrace = Frame[] | null
 export type stack = any // Simplified stack type
 export type uintptr = number
 

package/gs/github.com/pkg/errors/index.ts

@@ -9,4 +9,5 @@ export {
   Wrapf,
 } from './errors.js'
 export { As, Is, Unwrap } from './go113.js'
-export { Frame, StackTrace } from './stack.js'
+export type { Frame, StackTrace } from './stack.js'
+export { Frame_MarshalText, StackTrace_Format } from './stack.js'

package/gs/github.com/pkg/errors/stack.ts

@@ -2,72 +2,44 @@ import * as $ from '@goscript/builtin/index.js'
 
 // Type definitions
 export type uintptr = number
+export type Frame = uintptr
+export type StackTrace = $.Slice<Frame>
 
-export class Frame {
-  constructor(private _value: uintptr) {}
-
-  valueOf(): uintptr {
-    return this._value
-  }
-
-  toString(): string {
-    return String(this._value)
-  }
-
-  static from(value: uintptr): Frame {
-    return new Frame(value)
-  }
-
-  // pc returns the program counter for this frame;
-  // multiple frames may have the same PC value.
-  public pc(): uintptr {
-    return this._value - 1
-  }
-
-  // file returns the full path to the file that contains the
-  // function for this Frame's pc.
-  public file(): string {
-    return 'unknown'
-  }
-
-  // line returns the line number of source code of the
-  // function for this Frame's pc.
-  public line(): number {
-    return 0
-  }
-
-  // name returns the name of this function, if known.
-  public name(): string {
-    return 'unknown'
-  }
+export function Frame_pc(receiver: Frame): uintptr {
+  return receiver - 1
+}
 
-  // MarshalText formats a stacktrace Frame as a text string.
-  public MarshalText(): [$.Bytes, $.GoError] {
-    const name = this.name()
-    if (name == 'unknown') {
-      return [new TextEncoder().encode(name), null]
-    }
-    return [
-      new TextEncoder().encode(`${name} ${this.file()}:${this.line()}`),
-      null,
-    ]
-  }
+export function Frame_file(_receiver: Frame): string {
+  return 'unknown'
 }
 
-export class StackTrace {
-  constructor(private _value: Frame[] | null) {}
+export function Frame_line(_receiver: Frame): number {
+  return 0
+}
 
-  valueOf(): Frame[] | null {
-    return this._value
-  }
+export function Frame_name(_receiver: Frame): string {
+  return 'unknown'
+}
 
-  toString(): string {
-    return String(this._value)
-  }
+export function Frame_MarshalText(receiver: Frame): [$.Bytes, $.GoError] {
+  const name = Frame_name(receiver)
+  if (name == 'unknown') {
+    return [new TextEncoder().encode(name), null]
+  }
+  return [
+    new TextEncoder().encode(
+      `${name} ${Frame_file(receiver)}:${Frame_line(receiver)}`,
+    ),
+    null,
+  ]
+}
 
-  static from(value: Frame[] | null): StackTrace {
-    return new StackTrace(value)
-  }
+export function StackTrace_Format(
+  _receiver: StackTrace,
+  _state: any,
+  _verb: number,
+): void {
+  // Stack frame formatting is informational in the JavaScript target.
 }
 
 class stack {
@@ -88,14 +60,14 @@ class stack {
   public StackTrace(): StackTrace {
     const s = this._value
     if (!s || s.length === 0) {
-      return new StackTrace(null)
+      return null
     }
 
     const frames: Frame[] = []
     for (let i = 0; i < s.length; i++) {
-      frames.push(new Frame(s[i]))
+      frames.push(s[i])
     }
-    return new StackTrace(frames)
+    return $.arrayToSlice(frames)
   }
 }