goscript 0.2.5 → 0.2.7

package/gs/path/match.test.ts

@@ -0,0 +1,32 @@
+import { ErrBadPattern, Match } from './index.js'
+import { describe, expect, test } from 'vitest'
+
+describe('path.Match', () => {
+  test('star consumes the run up to but not including a slash', () => {
+    // Go: path.Match("*/c", "a/c") => (true, nil). The star matches "a" and
+    // the literal "/c" matches the remainder.
+    expect(Match('*/c', 'a/c')).toEqual([true, null])
+    // Go: a star still cannot cross a slash.
+    expect(Match('*c', 'a/c')).toEqual([false, null])
+    // Go: path.Match("a*b", "axxb") => (true, nil).
+    expect(Match('a*b', 'axxb')).toEqual([true, null])
+  })
+
+  test('unterminated character class reports ErrBadPattern', () => {
+    // Go: an escape that consumes the last rune of the class returns
+    // ErrBadPattern rather than indexing past the end of the chunk.
+    const [ok, err] = Match('[a', 'x')
+    expect(ok).toBe(false)
+    expect(err).toBe(ErrBadPattern)
+
+    const [ok2, err2] = Match('[', 'a')
+    expect(ok2).toBe(false)
+    expect(err2).toBe(ErrBadPattern)
+  })
+
+  test('well-formed character class still matches', () => {
+    // Go: path.Match("[a-c]", "b") => (true, nil).
+    expect(Match('[a-c]', 'b')).toEqual([true, null])
+    expect(Match('[^a-c]', 'b')).toEqual([false, null])
+  })
+})

package/gs/path/match.ts

@@ -78,7 +78,7 @@ export function Match(pattern: string, name: string): [boolean, $.GoError] {
         for (let i = 0; i < $.len(name) && $.indexString(name, i) != 47; i++) {
           let [t, ok, err] = matchChunk(
             chunk,
-            $.sliceString(name, i, undefined),
+            $.sliceString(name, i + 1, undefined),
           )
 
           // if we're the last chunk, make sure we exhausted the name
@@ -300,8 +300,11 @@ export function getEsc(chunk: string): [number, string, $.GoError] {
     return [0, '', ErrBadPattern]
   }
   chunk = $.sliceString(chunk, n, undefined)
-  if ($.len(chunk) == 0 || $.indexString(chunk, 0) != 45 || $.len(chunk) == 1) {
-    return [r, chunk, null]
+  // An escape that consumes the last rune of the class leaves no terminator,
+  // so the pattern is malformed (Go reports ErrBadPattern instead of indexing
+  // past the end of the chunk).
+  if ($.len(chunk) == 0) {
+    return [r, chunk, ErrBadPattern]
   }
   return [r, chunk, null]
 }

package/gs/reflect/deepequal.test.ts

@@ -45,6 +45,6 @@ describe('DeepEqual', () => {
       new BasicType(Uint32, 'uint32'),
     )
 
-    expect(v.Uint()).toBe(7)
+    expect(v.Uint()).toBe(7n)
   })
 })

package/gs/reflect/field.test.ts

@@ -63,7 +63,7 @@ describe('reflect struct field access', () => {
       ValueOf(person)
         .FieldByIndex(arrayToSlice([1]))
         .Int(),
-    ).toBe(3)
+    ).toBe(3n)
     expect(ValueOf(person).FieldByName('Missing').IsValid()).toBe(false)
 
     const stringMethod = ValueOf(person).MethodByName('String')

package/gs/reflect/function-types.test.ts

@@ -358,7 +358,7 @@ describe('Function Type Detection', () => {
     })
     const tupleResult = asArray(await ValueOf(tupleFunc).Call(arrayToSlice([])))
     expect(tupleResult).toHaveLength(2)
-    expect(tupleResult[0].Int()).toBe(1)
+    expect(tupleResult[0].Int()).toBe(1n)
     expect(tupleResult[1].String()).toBe('ok')
 
     const sliceFunc = functionValue(() => [1, 2], {
@@ -384,7 +384,7 @@ describe('Function Type Detection', () => {
       await ValueOf(namedResultFunc).Call(arrayToSlice([])),
     )
     expect(namedResult[0].Type().String()).toBe('main.MyInt')
-    expect(namedResult[0].Int()).toBe(7)
+    expect(namedResult[0].Int()).toBe(7n)
 
     const badTupleFunc = functionValue(() => [1], {
       kind: TypeKind.Function,
@@ -459,7 +459,7 @@ describe('Function Type Detection', () => {
     )()
     expect(tuple).toEqual([3, true])
     const reflectedTuple = asArray(await tupleValue.Call(arrayToSlice([])))
-    expect(reflectedTuple[0].Int()).toBe(3)
+    expect(reflectedTuple[0].Int()).toBe(3n)
     expect(reflectedTuple[1].Bool()).toBe(true)
 
     const zeroType = FuncOf(arrayToSlice([]), arrayToSlice([]), false)
@@ -481,7 +481,7 @@ describe('Function Type Detection', () => {
     const variadicValue = MakeFunc(variadicType, (args) => {
       const values = asArray(args)
       expect(values).toHaveLength(2)
-      return arrayToSlice([ValueOf(values[0].Int() + values[1].Len())])
+      return arrayToSlice([ValueOf(Number(values[0].Int()) + values[1].Len())])
     })
     const variadic = variadicValue.Interface() as (
       prefix: number,
@@ -493,13 +493,13 @@ describe('Function Type Detection', () => {
         arrayToSlice([ValueOf(10), ValueOf('a'), ValueOf('b')]),
       ),
     )
-    expect(reflectedVariadic[0].Int()).toBe(12)
+    expect(reflectedVariadic[0].Int()).toBe(12n)
     const reflectedSliceCall = asArray(
       await variadicValue.CallSlice(
         arrayToSlice([ValueOf(10), ValueOf(arrayToSlice(['a', 'b', 'c']))]),
       ),
     )
-    expect(reflectedSliceCall[0].Int()).toBe(13)
+    expect(reflectedSliceCall[0].Int()).toBe(13n)
 
     const badResult = MakeFunc(unaryType, () => arrayToSlice([]))
     await expect(

package/gs/reflect/sliceat.test.ts

@@ -19,18 +19,18 @@ describe('reflect owned pointer handles', () => {
     const values = [1, 2, 3]
     const element = ValueOf(values).Index(1)
 
-    element.SetInt(8)
+    element.SetInt(8n)
     expect(values).toEqual([1, 8, 3])
 
     const address = element.UnsafeAddr()
     expect($.isOwnedPointerHandle(address)).toBe(true)
 
     const pointer = NewAt(element.Type(), address as any)
-    pointer.Elem().SetInt(11)
+    pointer.Elem().SetInt(11n)
     expect(values).toEqual([1, 11, 3])
 
     const refPointer = NewAt(element.Type(), $.indexRef(values, 1) as any)
-    refPointer.Elem().SetInt(14)
+    refPointer.Elem().SetInt(14n)
     expect(values).toEqual([1, 14, 3])
   })
 
@@ -38,14 +38,14 @@ describe('reflect owned pointer handles', () => {
     const bytes = new Uint8Array([4, 5, 6])
     const element = ValueOf(bytes).Index(1)
 
-    element.SetUint(9)
+    element.SetUint(9n)
     expect(Array.from(bytes)).toEqual([4, 9, 6])
 
     const address = element.UnsafeAddr()
     expect($.isOwnedPointerHandle(address)).toBe(true)
 
     const pointer = NewAt(element.Type(), address as any)
-    pointer.Elem().SetUint(12)
+    pointer.Elem().SetUint(12n)
     expect(Array.from(bytes)).toEqual([4, 12, 6])
   })
 
@@ -54,14 +54,14 @@ describe('reflect owned pointer handles', () => {
     const arrayValue = new Value(values, ArrayOf(2, TypeOf(0)))
     const element = arrayValue.Index(0)
 
-    element.SetInt(7)
+    element.SetInt(7n)
     expect(values).toEqual([7, 2])
 
     const address = element.UnsafeAddr()
     expect($.isOwnedPointerHandle(address)).toBe(true)
 
     const pointer = NewAt(element.Type(), address as any)
-    pointer.Elem().SetInt(13)
+    pointer.Elem().SetInt(13n)
     expect(values).toEqual([13, 2])
   })
 
@@ -71,13 +71,13 @@ describe('reflect owned pointer handles', () => {
 
     NewAt(intType, local as any)
       .Elem()
-      .SetInt(4)
+      .SetInt(4n)
     expect(local.value).toBe(4)
 
     const target = { count: 2 }
     NewAt(intType, $.fieldRef(target, 'count') as any)
       .Elem()
-      .SetInt(5)
+      .SetInt(5n)
     expect(target.count).toBe(5)
 
     expect(() => SliceAt(intType, local as any, 1)).toThrow(
@@ -107,8 +107,8 @@ describe('reflect owned pointer handles', () => {
     expect(slice.Cap()).toBe(2)
     expect(slice.Pointer()).toBe($.indexAddress(values, 1))
 
-    slice.Index(0).SetInt(21)
-    slice.Index(1).SetInt(31)
+    slice.Index(0).SetInt(21n)
+    slice.Index(1).SetInt(31n)
     expect(values).toEqual([10, 21, 31, 40])
   })
 
@@ -123,8 +123,8 @@ describe('reflect owned pointer handles', () => {
     expect(slice.Cap()).toBe(2)
     expect(slice.Pointer()).toBe($.indexAddress(bytes, 1))
 
-    slice.Index(0).SetUint(7)
-    slice.Index(1).SetUint(8)
+    slice.Index(0).SetUint(7n)
+    slice.Index(1).SetUint(8n)
     expect(Array.from(bytes)).toEqual([1, 7, 8, 4])
   })
 

package/gs/reflect/structof.test.ts

@@ -41,7 +41,7 @@ describe('StructOf', () => {
 
     const value = New(typ).Elem()
     value.Field(0).SetString('Ada')
-    value.FieldByName('Count').SetInt(3)
+    value.FieldByName('Count').SetInt(3n)
 
     const [data, err] = Marshal(value.Interface())
     expect(err).toBeNull()
@@ -51,7 +51,7 @@ describe('StructOf', () => {
     expect(TypeOf(clone).String()).toBe(typ.String())
     expect(clone.Name).toBe('Ada')
     expect(clone.Count).toBe(3)
-    value.FieldByName('Count').SetInt(4)
+    value.FieldByName('Count').SetInt(4n)
     expect(clone.Count).toBe(3)
   })
 
@@ -348,9 +348,9 @@ describe('StructOf', () => {
     ])
 
     const value = New(outer).Elem()
-    value.FieldByIndex($.arrayToSlice([0, 0])).SetInt(7)
+    value.FieldByIndex($.arrayToSlice([0, 0])).SetInt(7n)
     value.FieldByName('Label').SetString('seven')
-    expect(value.FieldByName('ID').Int()).toBe(7)
+    expect(value.FieldByName('ID').Int()).toBe(7n)
     expect(value.FieldByIndex($.arrayToSlice([0, 1])).String()).toBe('seven')
   })
 

package/gs/reflect/type.ts

@@ -587,9 +587,24 @@ export class Value {
   }
 
   // Methods required by godoc.txt and used throughout the codebase
-  public Int(): number {
+
+  // integerValue reads the underlying value as a bigint regardless of whether it
+  // is stored as a number (int8..int32/uint8..uint32) or a bigint (int64/uint64).
+  private integerValue(): bigint | null {
+    if (typeof this._value === 'bigint') {
+      return this._value
+    }
     const value = this.numericValue()
     if (value !== null && Number.isInteger(value)) {
+      return BigInt(value)
+    }
+    return null
+  }
+
+  // Int returns v's underlying value as an int64, matching reflect.Value.Int.
+  public Int(): bigint {
+    const value = this.integerValue()
+    if (value !== null) {
       return value
     }
     throw new Error(
@@ -599,9 +614,10 @@ export class Value {
     )
   }
 
-  public Uint(): number {
-    const value = this.numericValue()
-    if (value !== null && value >= 0) {
+  // Uint returns v's underlying value as a uint64, matching reflect.Value.Uint.
+  public Uint(): bigint {
+    const value = this.integerValue()
+    if (value !== null && value >= 0n) {
       return value
     }
     throw new Error(
@@ -1159,8 +1175,9 @@ export class Value {
     }
   }
 
-  // SetInt sets v's underlying value to x
-  public SetInt(x: number): void {
+  // SetInt sets v's underlying value to x. x is an int64 (bigint); the stored
+  // value uses the field's representation: bigint for Int64, number otherwise.
+  public SetInt(x: bigint): void {
     if (!this.CanSet()) {
       throw new Error(
         'reflect: call of reflect.Value.SetInt on unaddressable value',
@@ -1172,17 +1189,19 @@ export class Value {
         'reflect: call of reflect.Value.SetInt on ' + k + ' Value',
       )
     }
-    this._value = x
+    const stored: number | bigint = k === Int64 ? x : Number(x)
+    this._value = stored
     if (this._parentVarRef) {
-      this._parentVarRef.value = x
+      this._parentVarRef.value = stored
     }
     if (this._parentStruct && this._fieldName) {
-      this._parentStruct[this._fieldName] = x
+      this._parentStruct[this._fieldName] = stored
     }
   }
 
-  // SetUint sets v's underlying value to x
-  public SetUint(x: number): void {
+  // SetUint sets v's underlying value to x. x is a uint64 (bigint); the stored
+  // value uses the field's representation: bigint for Uint64, number otherwise.
+  public SetUint(x: bigint): void {
     if (!this.CanSet()) {
       throw new Error(
         'reflect: call of reflect.Value.SetUint on unaddressable value',
@@ -1201,12 +1220,13 @@ export class Value {
         'reflect: call of reflect.Value.SetUint on ' + k + ' Value',
       )
     }
-    this._value = x
+    const stored: number | bigint = k === Uint64 ? x : Number(x)
+    this._value = stored
     if (this._parentVarRef) {
-      this._parentVarRef.value = x
+      this._parentVarRef.value = stored
     }
     if (this._parentStruct && this._fieldName) {
-      this._parentStruct[this._fieldName] = x
+      this._parentStruct[this._fieldName] = stored
     }
   }
 

package/gs/reflect/typefor.test.ts

@@ -184,8 +184,8 @@ describe('TypeFor', () => {
 
     const elem = ValueOf(boxed).Elem()
     expect(elem.Kind()).toBe(Uint64)
-    elem.SetUint(15)
-    expect(target.value).toBe(15)
+    elem.SetUint(15n)
+    expect(target.value).toBe(15n)
   })
 
   it('preserves channel type metadata on interface boxes', () => {
@@ -680,9 +680,9 @@ describe('TypeFor', () => {
     const pointer = New(TypeOf(0))
     const value = Indirect(pointer)
 
-    expect(value.Int()).toBe(0)
-    value.SetInt(7)
-    expect(pointer.Elem().Int()).toBe(7)
+    expect(value.Int()).toBe(0n)
+    value.SetInt(7n)
+    expect(pointer.Elem().Int()).toBe(7n)
   })
 
   it('interns runtime type descriptors for reflect.Type map keys', () => {

package/gs/runtime/pprof/index.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it } from 'vitest'
 import {
   Lookup,
   NewProfile,
+  Profiles,
   StartCPUProfile,
   StopCPUProfile,
   WriteHeapProfile,
@@ -61,4 +62,23 @@ describe('runtime/pprof override', () => {
       'pprof: NewProfile name already in use: goscript.test',
     )
   })
+
+  it('lists built-in and custom profiles', () => {
+    const custom =
+      Lookup('goscript.profiles') ?? NewProfile('goscript.profiles')
+    const profiles = Array.from(Profiles() ?? [])
+    const names = profiles.map((profile) => profile?.Name())
+
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'allocs',
+        'block',
+        'goroutine',
+        'heap',
+        'mutex',
+        'threadcreate',
+        custom.Name(),
+      ]),
+    )
+  })
 })

package/gs/runtime/trace/index.test.ts

@@ -5,6 +5,7 @@ import * as context from '@goscript/context/index.js'
 import {
   IsEnabled,
   Log,
+  Logf,
   NewTask,
   Start,
   StartRegion,
@@ -109,6 +110,7 @@ describe('runtime/trace override', () => {
     const [ctx, task] = NewTask(context.Background(), 'proof-task')
     WithRegion(ctx, 'proof-region', () => {
       Log(ctx, 'proof-key', 'proof-value')
+      Logf(ctx, 'proof-format', 'value=%s count=%d', 'ok', 3)
     })
     task.End()
 
@@ -126,6 +128,7 @@ describe('runtime/trace override', () => {
     expect(text).toContain('proof-task')
     expect(text).toContain('proof-region')
     expect(text).toContain('proof-value')
+    expect(text).toContain('value=ok count=3')
   })
 
   it('splits a large capture into batches under the size limit', () => {

package/gs/slices/slices.test.ts

@@ -13,7 +13,9 @@ import {
   CompareFunc,
   Concat,
   DeleteFunc,
+  Equal,
   EqualFunc,
+  Index,
   IndexFunc,
   IsSorted,
   IsSortedFunc,
@@ -27,6 +29,35 @@ import {
   SortStableFunc,
 } from './slices.js'
 
+describe('slices Go comparable equality and lower-bound search', () => {
+  // Go compares comparable elements (arrays/structs) by value with ==, and
+  // BinarySearch returns the earliest index for duplicate targets.
+  it('Compact removes adjacent equal-by-value array elements', () => {
+    expect(Array.from(Compact($.arrayToSlice([[1], [1], [2]])) ?? [])).toEqual([
+      [1],
+      [2],
+    ])
+  })
+
+  it('Equal compares array elements by value', () => {
+    expect(Equal($.arrayToSlice([[1, 2]]), $.arrayToSlice([[1, 2]]))).toBe(true)
+    expect(Equal($.arrayToSlice([[1, 2]]), $.arrayToSlice([[1, 3]]))).toBe(
+      false,
+    )
+  })
+
+  it('Index finds an equal-by-value array element', () => {
+    expect(Index($.arrayToSlice([[1], [2], [3]]), [2])).toBe(1)
+    expect(Index($.arrayToSlice([[1], [2]]), [9])).toBe(-1)
+  })
+
+  it('BinarySearch returns the first index of a duplicate target', () => {
+    expect(BinarySearch($.arrayToSlice([1, 2, 2, 2, 3]), 2)).toEqual([1, true])
+    expect(BinarySearch($.arrayToSlice([1, 2, 2, 2, 3]), 4)).toEqual([5, false])
+    expect(BinarySearch($.arrayToSlice([1, 3, 5]), 0)).toEqual([0, false])
+  })
+})
+
 describe('slices.SortFunc', () => {
   it('awaits async comparison callbacks', async () => {
     const values = $.arrayToSlice([3, 1, 2])

package/gs/slices/slices.ts

@@ -381,7 +381,7 @@ export function Compact<T>(s: $.Slice<T>): $.Slice<T> {
   }
   let w = 1
   for (let i = 1; i < $.len(s); i++) {
-    if ((s as any)[i] !== (s as any)[i - 1]) {
+    if (!$.comparableEqual((s as any)[i], (s as any)[i - 1])) {
       ;(s as any)[w] = (s as any)[i]
       w++
     }
@@ -432,7 +432,7 @@ export function Equal<T>(s1: $.Slice<T>, s2: $.Slice<T>): boolean {
     return false
   }
   for (let i = 0; i < len1; i++) {
-    if ((s1 as any)[i] !== (s2 as any)[i]) {
+    if (!$.comparableEqual((s1 as any)[i], (s2 as any)[i])) {
       return false
     }
   }
@@ -461,7 +461,7 @@ export function EqualFunc<T, U>(
 
 export function Index<T>(s: $.Slice<T>, v: T): number {
   for (let i = 0; i < $.len(s); i++) {
-    if ((s as any)[i] === v) {
+    if ($.comparableEqual((s as any)[i], v)) {
       return i
     }
   }
@@ -688,23 +688,23 @@ export function BinarySearchFunc<E, T>(
   if (cmp == null) {
     throw new Error('slices.BinarySearchFunc: nil comparison function')
   }
+  const n = $.len(x)
   let left = 0
-  let right = $.len(x)
+  let right = n
 
+  // Lower-bound search: narrow to the earliest index not less than target so
+  // duplicate targets return the first match, matching Go's BinarySearchFunc.
   while (left < right) {
     const mid = Math.floor((left + right) / 2)
-    const result = syncNumber(cmp((x as any)[mid] as E, target))
-
-    if (result < 0) {
+    if (syncNumber(cmp((x as any)[mid] as E, target)) < 0) {
       left = mid + 1
-    } else if (result > 0) {
-      right = mid
     } else {
-      return [mid, true]
+      right = mid
     }
   }
 
-  return [left, false]
+  const found = left < n && syncNumber(cmp((x as any)[left] as E, target)) === 0
+  return [left, found]
 }
 
 function syncNumber(value: SyncCallbackResult<number>): number {

package/gs/strconv/append.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { AppendBool } from './atob.gs.js'
+import { AppendFloat } from './ftoa.gs.js'
+import { AppendInt, AppendUint, FormatUint } from './itoa.gs.js'
+import {
+  AppendQuote,
+  AppendQuoteRune,
+  AppendQuoteRuneToASCII,
+  AppendQuoteRuneToGraphic,
+  AppendQuoteToASCII,
+  AppendQuoteToGraphic,
+  IsGraphic,
+  IsPrint,
+  QuoteRuneToASCII,
+  QuoteRuneToGraphic,
+  QuotedPrefix,
+  QuoteToGraphic,
+} from './quote.gs.js'
+
+// Expected outputs are the literal results Go's strconv produces (go1.26.4).
+function appended(dst: $.Bytes): string {
+  return $.bytesToString(dst)
+}
+
+function prefix(s: string): $.Bytes {
+  return $.stringToBytes(s)
+}
+
+describe('strconv append/format coverage (Go semantics)', () => {
+  it('FormatUint renders in the requested base', () => {
+    expect(FormatUint(255, 16)).toBe('ff')
+    expect(FormatUint(10, 2)).toBe('1010')
+  })
+
+  it('AppendInt/AppendUint extend the destination buffer', () => {
+    expect(appended(AppendInt(prefix('x='), -42, 10))).toBe('x=-42')
+    expect(appended(AppendUint(prefix('x='), 255, 16))).toBe('x=ff')
+  })
+
+  it('AppendBool appends true/false', () => {
+    expect(appended(AppendBool(prefix('b='), true))).toBe('b=true')
+    expect(appended(AppendBool(prefix('b='), false))).toBe('b=false')
+  })
+
+  it('AppendFloat formats with the given verb and precision', () => {
+    expect(appended(AppendFloat(prefix('f='), 3.14159, 0x66, 2, 64))).toBe(
+      'f=3.14',
+    )
+  })
+
+  it('AppendQuote escapes like Quote', () => {
+    expect(appended(AppendQuote(prefix('q='), 'a\tb'))).toBe('q="a\\tb"')
+  })
+
+  it('AppendQuoteToASCII escapes non-ASCII to \\u', () => {
+    expect(appended(AppendQuoteToASCII(prefix(''), 'héllo'))).toBe(
+      '"h\\u00e9llo"',
+    )
+  })
+
+  it('AppendQuoteToGraphic keeps graphic Unicode in place', () => {
+    expect(appended(AppendQuoteToGraphic(prefix(''), '背'))).toBe('"背"')
+  })
+
+  it('AppendQuoteRune* quote a single rune', () => {
+    expect(appended(AppendQuoteRune(prefix(''), 0x41))).toBe("'A'")
+    expect(appended(AppendQuoteRuneToASCII(prefix(''), 0x4e16))).toBe(
+      "'\\u4e16'",
+    )
+    expect(appended(AppendQuoteRuneToGraphic(prefix(''), 0x4e16))).toBe("'世'")
+  })
+
+  it('QuoteToGraphic and QuoteRune variants match Go', () => {
+    expect(QuoteToGraphic('背\t')).toBe('"背\\t"')
+    expect(QuoteRuneToASCII(0x4e16)).toBe("'\\u4e16'")
+    expect(QuoteRuneToGraphic(0x4e16)).toBe("'世'")
+  })
+
+  it('IsPrint and IsGraphic match Go predicates', () => {
+    expect(IsPrint(0x41)).toBe(true)
+    expect(IsPrint(0x09)).toBe(false)
+    expect(IsPrint(0x07)).toBe(false)
+    expect(IsGraphic(0x41)).toBe(true)
+    expect(IsGraphic(0x20)).toBe(true)
+    expect(IsGraphic(0x09)).toBe(false)
+  })
+
+  it('QuotedPrefix returns the leading quoted literal or a syntax error', () => {
+    const [p, err] = QuotedPrefix('"abc" tail')
+    expect(p).toBe('"abc"')
+    expect(err).toBeNull()
+    const [p2, err2] = QuotedPrefix('nope')
+    expect(p2).toBe('')
+    expect(err2).not.toBeNull()
+  })
+})