goscript 0.2.5 → 0.2.7

package/gs/encoding/json/index.ts

@@ -43,6 +43,28 @@ export class SyntaxError extends jsonError {
   }
 }
 
+// Register *json.SyntaxError so a Go `err.(*json.SyntaxError)` assertion in
+// compiled code resolves to this class and exposes the Offset field.
+$.registerStructType(
+  'json.SyntaxError',
+  new SyntaxError(),
+  [
+    {
+      name: 'Error',
+      args: [],
+      returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    },
+  ],
+  SyntaxError,
+  [
+    {
+      name: 'Offset',
+      key: 'Offset',
+      type: { kind: $.TypeKind.Basic, name: 'int64' },
+    },
+  ],
+)
+
 export class InvalidUTF8Error extends jsonError {
   public S: string
 
@@ -145,23 +167,53 @@ export class Decoder {
   private disallowUnknownFields = false
   private inputOffset = 0
   private useNumber = false
+  // buf holds the fully buffered input; pos is the index of the next unread
+  // character, so successive Decode/Token calls consume one value at a time and
+  // leave the remainder buffered, like Go's streaming Decoder.
+  private buf = ''
+  private pos = 0
+  private filled = false
+  private readErr: $.GoError = null
 
   public constructor(private readonly reader: io.Reader) {}
 
-  public Decode(v: unknown): $.GoError {
+  private fill(): void {
+    if (this.filled) {
+      return
+    }
+    this.filled = true
     const [data, err] = readAllSync(this.reader)
     if (err !== null) {
-      return err
+      this.readErr = err
+      return
     }
-    this.inputOffset += $.len(data)
-    return decode(data, v, {
+    this.buf = $.bytesToString(data)
+  }
+
+  public Decode(v: unknown): $.GoError {
+    this.fill()
+    this.pos = skipJSONWhitespace(this.buf, this.pos)
+    if (this.pos >= this.buf.length) {
+      return this.readErr ?? $.newError('EOF')
+    }
+    let end: number
+    try {
+      ;[, end] = scanJSONValue(this.buf, this.pos, this.useNumber)
+    } catch (err) {
+      return goError(err)
+    }
+    const raw = $.stringToBytes(this.buf.slice(this.pos, end))
+    this.pos = end
+    this.inputOffset = jsonByteOffset(this.buf, end)
+    return decode(raw, v, {
       disallowUnknownFields: this.disallowUnknownFields,
       useNumber: this.useNumber,
     })
   }
 
   public Buffered(): io.Reader {
-    return new bytes.Buffer()
+    this.fill()
+    return bytes.NewBufferString(this.buf.slice(this.pos))!
   }
 
   public DisallowUnknownFields(): void {
@@ -173,11 +225,46 @@ export class Decoder {
   }
 
   public More(): boolean {
-    return false
+    this.fill()
+    const next = skipJSONWhitespace(this.buf, this.pos)
+    if (next >= this.buf.length) {
+      return false
+    }
+    const c = this.buf[next]
+    return c !== ']' && c !== '}'
   }
 
   public Token(): [Token, $.GoError] {
-    return [null, $.newError('json: token streaming is unsupported')]
+    this.fill()
+    let cursor = skipJSONWhitespace(this.buf, this.pos)
+    // Object/array separators are implicit in Go's token stream; skip them.
+    while (cursor < this.buf.length) {
+      const sep = this.buf[cursor]
+      if (sep === ',' || sep === ':') {
+        cursor++
+        cursor = skipJSONWhitespace(this.buf, cursor)
+        continue
+      }
+      break
+    }
+    this.pos = cursor
+    if (this.pos >= this.buf.length) {
+      return [null, this.readErr ?? $.newError('EOF')]
+    }
+    const c = this.buf[this.pos]
+    if (c === '{' || c === '[' || c === '}' || c === ']') {
+      this.pos++
+      this.inputOffset = jsonByteOffset(this.buf, this.pos)
+      return [c.charCodeAt(0), null]
+    }
+    try {
+      const [value, end] = scanJSONValue(this.buf, this.pos, this.useNumber)
+      this.pos = end
+      this.inputOffset = jsonByteOffset(this.buf, end)
+      return [value, null]
+    } catch (err) {
+      return [null, goError(err)]
+    }
   }
 
   public UseNumber(): void {
@@ -262,6 +349,282 @@ $.registerInterfaceType('json.Unmarshaler', null, [
   },
 ])
 
+// RawJSON wraps a pre-serialized JSON fragment (from a Marshaler or RawMessage)
+// so the encoder can emit its exact token spelling instead of round-tripping it
+// through JSON.parse/stringify, which would normalize numbers like 1e+00 to 1.
+class RawJSON {
+  constructor(public raw: string) {}
+}
+
+// stripJSONWhitespace removes insignificant whitespace from a JSON document
+// while leaving string contents and every number/literal token byte-for-byte
+// intact, matching Go's json.Compact.
+function stripJSONWhitespace(text: string): string {
+  let out = ''
+  let inStr = false
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]
+    if (inStr) {
+      out += c
+      if (c === '\\') {
+        out += text[++i] ?? ''
+      } else if (c === '"') {
+        inStr = false
+      }
+      continue
+    }
+    if (c === '"') {
+      inStr = true
+      out += c
+      continue
+    }
+    if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+      continue
+    }
+    out += c
+  }
+  return out
+}
+
+// indentJSON pretty-prints a compact JSON document, preserving every token
+// spelling, matching Go's json.Indent layout: a space after a colon, newlines
+// with prefix + indent*depth after structural characters, and empty {} / []
+// left inline.
+function indentJSON(compact: string, prefix: string, indent: string): string {
+  let out = ''
+  let depth = 0
+  let inStr = false
+  const newline = (d: number) => '\n' + prefix + indent.repeat(d)
+  for (let i = 0; i < compact.length; i++) {
+    const c = compact[i]
+    if (inStr) {
+      out += c
+      if (c === '\\') {
+        out += compact[++i] ?? ''
+      } else if (c === '"') {
+        inStr = false
+      }
+      continue
+    }
+    switch (c) {
+      case '"':
+        inStr = true
+        out += c
+        break
+      case '{':
+      case '[':
+        if (compact[i + 1] === '}' || compact[i + 1] === ']') {
+          out += c
+        } else {
+          depth++
+          out += c + newline(depth)
+        }
+        break
+      case '}':
+      case ']':
+        if (compact[i - 1] === '{' || compact[i - 1] === '[') {
+          out += c
+        } else {
+          depth--
+          out += newline(depth) + c
+        }
+        break
+      case ',':
+        out += c + newline(depth)
+        break
+      case ':':
+        out += ': '
+        break
+      default:
+        out += c
+    }
+  }
+  return out
+}
+
+// encodeJSON serializes a marshal-prepared value to compact JSON. RawJSON
+// fragments are emitted verbatim; all other values use plain token forms. The
+// caller applies HTML escaping and indentation afterward, matching Go's
+// Marshal-then-indent pipeline.
+function encodeJSON(v: unknown): string {
+  if (v instanceof RawJSON) {
+    return v.raw
+  }
+  if (v === null || v === undefined) {
+    return 'null'
+  }
+  const t = typeof v
+  if (t === 'boolean') {
+    return v ? 'true' : 'false'
+  }
+  if (t === 'number') {
+    return JSON.stringify(v)
+  }
+  if (t === 'bigint') {
+    return (v as bigint).toString()
+  }
+  if (t === 'string') {
+    return JSON.stringify(v)
+  }
+  if (Array.isArray(v)) {
+    return '[' + v.map(encodeJSON).join(',') + ']'
+  }
+  if (t === 'object') {
+    const parts: string[] = []
+    for (const [key, value] of Object.entries(v as Record<string, unknown>)) {
+      parts.push(JSON.stringify(key) + ':' + encodeJSON(value))
+    }
+    return '{' + parts.join(',') + '}'
+  }
+  return JSON.stringify(v)
+}
+
+const JSON_WHITESPACE = ' \t\n\r'
+
+// jsonByteOffset returns the Go byte offset (UTF-8) of character index i, so a
+// SyntaxError reports the same Offset Go would for multibyte input.
+function jsonByteOffset(text: string, i: number): number {
+  return $.len($.stringToBytes(text.slice(0, i)))
+}
+
+function jsonSyntaxError(text: string, i: number, msg: string): SyntaxError {
+  return new SyntaxError({ Offset: jsonByteOffset(text, i), Message: msg })
+}
+
+function skipJSONWhitespace(text: string, i: number): number {
+  while (i < text.length && JSON_WHITESPACE.includes(text[i])) {
+    i++
+  }
+  return i
+}
+
+// scanJSONValue parses one JSON value beginning at the first non-whitespace
+// character at or after start, returning the decoded value and the index just
+// past it. Numbers decode to JS numbers, or to their exact json.Number source
+// literal when useNumber is set. Malformed input throws a SyntaxError whose
+// Offset is the Go byte offset of the offending character.
+function scanJSONValue(
+  text: string,
+  start: number,
+  useNumber: boolean,
+): [unknown, number] {
+  let i = start
+  const skipWs = () => {
+    i = skipJSONWhitespace(text, i)
+  }
+  const fail = (msg = 'invalid character'): never => {
+    // Go's Offset counts bytes read up to and including the offending byte.
+    const at = Math.min(i + 1, text.length)
+    throw jsonSyntaxError(text, at, msg)
+  }
+  const parseString = (): string => {
+    let raw = text[i++] // opening quote
+    while (i < text.length) {
+      const c = text[i++]
+      raw += c
+      if (c === '\\') {
+        raw += text[i++] ?? ''
+      } else if (c === '"') {
+        try {
+          return JSON.parse(raw) as string
+        } catch {
+          i -= raw.length
+          return fail('invalid string literal')
+        }
+      }
+    }
+    return fail('unexpected end of JSON input')
+  }
+  const parseValue = (): unknown => {
+    skipWs()
+    if (i >= text.length) {
+      return fail('unexpected end of JSON input')
+    }
+    const c = text[i]
+    if (c === '{') {
+      i++
+      const obj: Record<string, unknown> = {}
+      skipWs()
+      if (text[i] === '}') {
+        i++
+        return obj
+      }
+      for (;;) {
+        skipWs()
+        if (text[i] !== '"') {
+          return fail()
+        }
+        const key = parseString()
+        skipWs()
+        if (text[i++] !== ':') {
+          i--
+          return fail("expected ':' after object key")
+        }
+        obj[key] = parseValue()
+        skipWs()
+        const sep = text[i++]
+        if (sep === '}') {
+          return obj
+        }
+        if (sep !== ',') {
+          i--
+          return fail("expected ',' or '}' after object value")
+        }
+      }
+    }
+    if (c === '[') {
+      i++
+      const arr: unknown[] = []
+      skipWs()
+      if (text[i] === ']') {
+        i++
+        return arr
+      }
+      for (;;) {
+        arr.push(parseValue())
+        skipWs()
+        const sep = text[i++]
+        if (sep === ']') {
+          return arr
+        }
+        if (sep !== ',') {
+          i--
+          return fail("expected ',' or ']' after array element")
+        }
+      }
+    }
+    if (c === '"') {
+      return parseString()
+    }
+    if (text.startsWith('true', i)) {
+      i += 4
+      return true
+    }
+    if (text.startsWith('false', i)) {
+      i += 5
+      return false
+    }
+    if (text.startsWith('null', i)) {
+      i += 4
+      return null
+    }
+    const numStart = i
+    if (c === '-') {
+      i++
+    }
+    while (i < text.length && '0123456789.eE+-'.includes(text[i])) {
+      i++
+    }
+    if (i === numStart) {
+      return fail()
+    }
+    const literal = text.slice(numStart, i)
+    return useNumber ? literal : Number(literal)
+  }
+  const value = parseValue()
+  return [value, i]
+}
+
 export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   return marshalBytes(v, '', '', true)
 }
@@ -273,15 +636,12 @@ function marshalBytes(
   escapeHTML: boolean,
 ): [$.Slice<number>, $.GoError] {
   try {
-    let text = JSON.stringify(marshalValue(v), null, indent)
+    let text = encodeJSON(marshalValue(v))
     if (escapeHTML) {
       text = escapeHTMLString(text)
     }
-    if (prefix !== '') {
-      text = text
-        .split('\n')
-        .map((line, idx) => (idx === 0 ? line : prefix + line))
-        .join('\n')
+    if (indent !== '' || prefix !== '') {
+      text = indentJSON(text, prefix, indent)
     }
     return [$.stringToBytes(text), null]
   } catch (err) {
@@ -294,7 +654,9 @@ export function Compact(
   src: $.Slice<number>,
 ): $.GoError {
   try {
-    const text = JSON.stringify(JSON.parse($.bytesToString(src)))
+    const source = $.bytesToString(src)
+    JSON.parse(source) // validate; Go's Compact rejects malformed input
+    const text = stripJSONWhitespace(source)
     const [, err] = $.pointerValue<bytes.Buffer>(dst).Write(
       $.stringToBytes(text),
     )
@@ -334,16 +696,14 @@ export function Indent(
   indent: string,
 ): $.GoError {
   try {
-    const text = JSON.stringify(JSON.parse($.bytesToString(src)), null, indent)
-    const prefixed =
-      prefix === '' ? text : (
-        text
-          .split('\n')
-          .map((line, idx) => (idx === 0 ? line : prefix + line))
-          .join('\n')
-      )
+    const source = $.bytesToString(src)
+    JSON.parse(source) // validate; Go's Indent rejects malformed input
+    const compact = stripJSONWhitespace(source)
+    // Go's Indent copies trailing whitespace after the value verbatim.
+    const trailing = source.slice(source.trimEnd().length)
+    const text = indentJSON(compact, prefix, indent) + trailing
     const [, err] = $.pointerValue<bytes.Buffer>(dst).Write(
-      $.stringToBytes(prefixed),
+      $.stringToBytes(text),
     )
     return err
   } catch (err) {
@@ -506,11 +866,13 @@ function marshalValue(v: unknown): unknown {
     if (err !== null) {
       throw new MarshalerError({ Err: err })
     }
+    const raw = $.bytesToString(data)
     try {
-      return JSON.parse($.bytesToString(data))
+      JSON.parse(raw) // validate; preserve exact token spelling below
     } catch (parseErr) {
       throw new MarshalerError({ Err: goError(parseErr) })
     }
+    return new RawJSON(stripJSONWhitespace(raw))
   }
   if ($.isVarRef(v)) {
     return marshalValue(v.value)
@@ -565,11 +927,16 @@ function marshalFieldValue(value: unknown, fieldType: unknown): unknown {
     if (target === null || target === undefined) {
       return null
     }
+    const raw = $.bytesToString(target as $.Slice<number>)
+    if (raw === '') {
+      return null
+    }
     try {
-      return JSON.parse($.bytesToString(target as $.Slice<number>))
+      JSON.parse(raw) // validate; preserve exact token spelling below
     } catch (err) {
       throw new MarshalerError({ Err: goError(err) })
     }
+    return new RawJSON(stripJSONWhitespace(raw))
   }
   return marshalValue(value)
 }
@@ -610,12 +977,16 @@ function validUnmarshalTarget(value: unknown): boolean {
 
 function parseJSON(data: $.Slice<number>, opts: decodeOptions): unknown {
   const text = $.bytesToString(data)
-  if (opts.useNumber) {
-    return JSON.parse(text, (_key, value) =>
-      typeof value === 'number' ? String(value) : value,
+  const [value, end] = scanJSONValue(text, 0, !!opts.useNumber)
+  const rest = skipJSONWhitespace(text, end)
+  if (rest !== text.length) {
+    throw jsonSyntaxError(
+      text,
+      rest + 1,
+      'invalid character after top-level value',
     )
   }
-  return JSON.parse(text)
+  return value
 }
 
 function assignDecodedValue(

package/gs/errors/errors.test.ts

@@ -2,7 +2,16 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { AsType, Errorf, Is, Join, Wrap, Wrapf } from './errors.js'
+import {
+  AsType,
+  ErrUnsupported,
+  Errorf,
+  Is,
+  Join,
+  New,
+  Wrap,
+  Wrapf,
+} from './errors.js'
 
 class DNSError {
   public readonly IsNotFound = true
@@ -83,3 +92,37 @@ describe('errors github.com/pkg/errors compatibility helpers', () => {
     expect(Wrapf(null, 'context %d', 7)).toBe(null)
   })
 })
+
+describe('errors.Is identity semantics', () => {
+  it('does not match distinct errors with equal text', () => {
+    expect(Is(New('boom'), New('boom'))).toBe(false)
+  })
+
+  it('does not match ErrUnsupported by message text', () => {
+    expect(Is(New('unsupported operation'), ErrUnsupported)).toBe(false)
+  })
+
+  it('matches the same error value', () => {
+    const e = New('boom')
+    expect(Is(e, e)).toBe(true)
+  })
+
+  it('finds a target in any Join position depth-first', () => {
+    const a = New('a')
+    const b = New('b')
+    expect(Is(Join(a, b), b)).toBe(true)
+    expect(Is(Join(a, b), a)).toBe(true)
+    expect(Is(Join(a, b), New('b'))).toBe(false)
+  })
+
+  it('matches a wrapped sentinel through Wrap', () => {
+    expect(Is(Wrap(ErrUnsupported, 'ctx'), ErrUnsupported)).toBe(true)
+  })
+
+  it('finds a typed error in a later Join position via AsType', () => {
+    const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
+    const [matched, ok] = AsType(dnsTypeArgs, Join(New('first'), dns))
+    expect(ok).toBe(true)
+    expect(matched).toBe(dns)
+  })
+})

package/gs/errors/errors.ts

@@ -123,42 +123,32 @@ export function Is(err: $.GoError, target: $.GoError): boolean {
     return false
   }
 
-  // Check direct equality
+  // Match by identity only. Go's errors.Is never matches by message text:
+  // two distinct errors.New values with the same string are not equal.
   if (err === target) {
     return true
   }
 
-  // Check if error messages are the same
-  if (err.Error() === target.Error()) {
-    return true
-  }
-
-  // Check if err has an Is method
+  // An error may declare equivalence to target via an Is method.
   if (typeof (err as any).Is === 'function') {
     if ((err as any).Is(target)) {
       return true
     }
   }
 
-  // Recursively check wrapped errors
-  const unwrapped = Unwrap(err)
-  if (unwrapped !== null) {
-    return Is(unwrapped, target)
-  }
-
-  // Handle multiple wrapped errors
+  // Depth-first traversal of the wrap tree. A single-error Unwrap recurses into
+  // its child; an Unwrap returning []error (errors.Join) visits every child, so
+  // a target in any position matches, not just the first.
   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' &&
-          Is(wrappedErr, target)
-        ) {
+        if (wrappedErr !== null && Is(wrappedErr, target)) {
           return true
         }
       }
+    } else if (result !== null && typeof result?.Error === 'function') {
+      return Is(result, target)
     }
   }
 
@@ -202,25 +192,19 @@ export function As(err: $.GoError, target: any): boolean {
     }
   }
 
-  // Recursively check wrapped errors
-  const unwrapped = Unwrap(err)
-  if (unwrapped !== null) {
-    return As(unwrapped, target)
-  }
-
-  // Handle multiple wrapped errors
+  // Depth-first traversal of the wrap tree, matching errors.Is: a single-error
+  // Unwrap recurses into its child; an Unwrap returning []error visits every
+  // child so a match in any position is found.
   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' &&
-          As(wrappedErr, target)
-        ) {
+        if (wrappedErr !== null && As(wrappedErr, target)) {
           return true
         }
       }
+    } else if (result !== null && typeof result?.Error === 'function') {
+      return As(result, target)
     }
   }