goscript 0.2.2 → 0.2.3

package/gs/golang.org/x/crypto/scrypt/index.ts

@@ -0,0 +1,54 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import { scryptAsync } from '@noble/hashes/scrypt.js'
+
+const maxInt = Number.MAX_SAFE_INTEGER
+
+export async function Key(
+  password: $.Bytes,
+  salt: $.Bytes,
+  N: number,
+  r: number,
+  p: number,
+  keyLen: number,
+): Promise<[$.Bytes, $.GoError]> {
+  if (N <= 1 || (N & (N - 1)) !== 0) {
+    return [null, errors.New('scrypt: N must be > 1 and a power of 2')]
+  }
+  if (r <= 0 || p <= 0) {
+    return [null, errors.New('scrypt: parameters must be > 0')]
+  }
+  if (
+    r * p >= 1 << 30 ||
+    r > maxInt / 128 / p ||
+    r > maxInt / 256 ||
+    N > maxInt / 128 / r
+  ) {
+    return [null, errors.New('scrypt: parameters are too large')]
+  }
+
+  try {
+    const derived = await scryptAsync(
+      $.bytesToUint8Array(password),
+      $.bytesToUint8Array(salt),
+      {
+        N,
+        r,
+        p,
+        dkLen: keyLen,
+        asyncTick: 8,
+        maxmem: maxInt,
+      },
+    )
+    return [new Uint8Array(derived), null]
+  } catch (err) {
+    return [null, errors.New(`scrypt: ${errorMessage(err)}`)]
+  }
+}
+
+function errorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    return err.message
+  }
+  return String(err)
+}

package/gs/golang.org/x/crypto/scrypt/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncFunctions": {
+    "Key": true
+  }
+}

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

@@ -1,14 +1,7 @@
 import { describe, expect, it } from 'vitest'
 
 import * as $ from '../../builtin/index.js'
-import {
-  New128,
-  New128a,
-  New32,
-  New32a,
-  New64,
-  New64a,
-} from './index.js'
+import { New128, New128a, New32, New32a, New64, New64a } from './index.js'
 
 describe('hash/fnv override', () => {
   it('matches Go FNV sums for hello', async () => {

package/gs/hash/fnv/index.ts

@@ -65,7 +65,10 @@ class FNV32 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -136,7 +139,10 @@ class FNV64 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -185,7 +191,11 @@ class FNV128 {
   }
 
   async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
-    return appendBytes($.bytesToUint8Array(prefix), be64(this.high()), be64(this.low()))
+    return appendBytes(
+      $.bytesToUint8Array(prefix),
+      be64(this.high()),
+      be64(this.low()),
+    )
   }
 
   Reset(): void {
@@ -202,7 +212,12 @@ class FNV128 {
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
     return [
-      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.high()), be64(this.low())),
+      appendBytes(
+        $.bytesToUint8Array(prefix),
+        this.magic,
+        be64(this.high()),
+        be64(this.low()),
+      ),
       null,
     ]
   }
@@ -217,7 +232,8 @@ class FNV128 {
     if (err != null) {
       return err
     }
-    this.hash = ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
+    this.hash =
+      ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
     return null
   }
 
@@ -304,11 +320,12 @@ function be64(value: bigint): Uint8Array {
 
 function readBE32(bytes: Uint8Array, offset: number): number {
   return (
-    ((bytes[offset] << 24) >>> 0) |
-    (bytes[offset + 1] << 16) |
-    (bytes[offset + 2] << 8) |
-    bytes[offset + 3]
-  ) >>> 0
+    (((bytes[offset] << 24) >>> 0) |
+      (bytes[offset + 1] << 16) |
+      (bytes[offset + 2] << 8) |
+      bytes[offset + 3]) >>>
+    0
+  )
 }
 
 function readBE64(bytes: Uint8Array, offset: number): bigint {

package/gs/io/fs/glob.ts

@@ -60,15 +60,18 @@ $.registerInterfaceType(
 // If fs implements [GlobFS], Glob calls fs.Glob.
 // Otherwise, Glob uses [ReadDir] to traverse the directory tree
 // and look for matches for the pattern.
-export function Glob(fsys: FS, pattern: string): [$.Slice<string>, $.GoError] {
-  return globWithLimit(fsys, pattern, 0)
+export async function Glob(
+  fsys: FS,
+  pattern: string,
+): Promise<[$.Slice<string>, $.GoError]> {
+  return await globWithLimit(fsys, pattern, 0)
 }
 
-export function globWithLimit(
+export async function globWithLimit(
   fsys: FS,
   pattern: string,
   depth: number,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let matches: $.Slice<string> = null
   {
     // This limit is added to prevent stack exhaustion issues. See
@@ -105,7 +108,7 @@ export function globWithLimit(
     dir = cleanGlobPath(dir)
 
     if (!hasMeta(dir)) {
-      return glob(fsys, dir, file, null)
+      return await glob(fsys, dir, file, null)
     }
 
     // Prevent infinite recursion. See issue 15879.
@@ -113,14 +116,14 @@ export function globWithLimit(
       return [null, path.ErrBadPattern]
     }
 
-    const [dirs, dirErr] = globWithLimit(fsys, dir, depth + 1)
+    const [dirs, dirErr] = await globWithLimit(fsys, dir, depth + 1)
     if (dirErr != null) {
       return [null, dirErr]
     }
     for (let _i = 0; _i < $.len(dirs); _i++) {
       const d = dirs![_i]
       {
-        const [nextMatches, globErr] = glob(fsys, d, file, matches)
+        const [nextMatches, globErr] = await glob(fsys, d, file, matches)
         matches = nextMatches
         if (globErr != null) {
           return [matches, globErr]
@@ -148,15 +151,15 @@ export function cleanGlobPath(path: string): string {
 // and appends them to matches, returning the updated slice.
 // If the directory cannot be opened, glob returns the existing matches.
 // New matches are added in lexicographical order.
-export function glob(
+export async function glob(
   fs: FS,
   dir: string,
   pattern: string,
   matches: $.Slice<string>,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let m = matches
   {
-    let [infos, err] = ReadDir(fs, dir)
+    let [infos, err] = await ReadDir(fs, dir)
 
     // ignore I/O error
     if (err != null) {

package/gs/io/fs/meta.json

@@ -1,5 +1,7 @@
 {
   "asyncFunctions": {
+    "Glob": true,
+    "ReadDir": true,
     "WalkDir": true
   }
 }

package/gs/io/fs/readdir.test.ts

@@ -4,7 +4,7 @@ import * as $ from '@goscript/builtin/index.js'
 import { File, FileInfo, ReadDir } from './index.js'
 
 describe('io/fs ReadDir override', () => {
-  it('returns a nil entry slice without sorting when directory read fails', () => {
+  it('returns a nil entry slice without sorting when directory read fails', async () => {
     const readErr = $.newError('read failed')
     const file: File & {
       ReadDir(n: number): [null, $.GoError]
@@ -23,7 +23,7 @@ describe('io/fs ReadDir override', () => {
       },
     }
 
-    const [list, err] = ReadDir(
+    const [list, err] = await ReadDir(
       {
         Open(_name: string): [File, $.GoError] {
           return [file, null]
@@ -35,4 +35,65 @@ describe('io/fs ReadDir override', () => {
     expect(list).toBeNull()
     expect(err).toBe(readErr)
   })
+
+  it('awaits async FS.Open fallback implementations', async () => {
+    const entries = [
+      {
+        Name(): string {
+          return 'b.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+      {
+        Name(): string {
+          return 'a.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+    ]
+    const file: File & {
+      ReadDir(n: number): Promise<[$.Slice<any>, $.GoError]>
+    } = {
+      Close(): $.GoError {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      Stat(): [FileInfo, $.GoError] {
+        return [null, null]
+      },
+      async ReadDir(_n: number): Promise<[$.Slice<any>, $.GoError]> {
+        return [$.arrayToSlice(entries), null]
+      },
+    }
+
+    const [list, err] = await ReadDir(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      },
+      'dir',
+    )
+
+    expect(err).toBeNull()
+    expect(list?.map((entry) => entry?.Name())).toEqual(['a.txt', 'b.txt'])
+  })
 })

package/gs/io/fs/readdir.ts

@@ -17,7 +17,11 @@ export type ReadDirFS =
   | ({
       // ReadDir reads the named directory
       // and returns a list of directory entries sorted by filename.
-      ReadDir(name: string): [$.Slice<DirEntry>, $.GoError]
+      ReadDir(
+        name: string,
+      ):
+        | [$.Slice<DirEntry>, $.GoError]
+        | Promise<[$.Slice<DirEntry>, $.GoError]>
     } & FS)
 
 $.registerInterfaceType(
@@ -55,51 +59,50 @@ $.registerInterfaceType(
 // If fs implements [ReadDirFS], ReadDir calls fs.ReadDir.
 // Otherwise ReadDir calls fs.Open and uses ReadDir and Close
 // on the returned file.
-export function ReadDir(
+export async function ReadDir(
   fsys: FS,
   name: string,
-): [$.Slice<DirEntry>, $.GoError] {
-  using __defer = new $.DisposableStack()
+): Promise<[$.Slice<DirEntry>, $.GoError]> {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<ReadDirFS>(
       fsys,
       'ReadDirFS',
     )
     if (ok) {
-      return fsysTyped!.ReadDir(name)
+      return await fsysTyped!.ReadDir(name)
     }
   }
 
-  let [file, err] = fsys!.Open(name)
+  let [file, err] = await fsys!.Open(name)
   if (err != null) {
     return [null, err]
   }
-  __defer.defer(() => {
-    file!.Close()
-  })
-
-  let { value: dir, ok: ok } = $.typeAssert<ReadDirFile>(file, 'ReadDirFile')
-  if (!ok) {
-    return [
-      null,
-      new PathError({
-        Err: errors.New('not implemented'),
-        Op: 'readdir',
-        Path: name,
-      }),
-    ]
-  }
+  try {
+    let { value: dir, ok: ok } = $.typeAssert<ReadDirFile>(file, 'ReadDirFile')
+    if (!ok) {
+      return [
+        null,
+        new PathError({
+          Err: errors.New('not implemented'),
+          Op: 'readdir',
+          Path: name,
+        }),
+      ]
+    }
 
-  let list: $.Slice<DirEntry>
-  ;[list, err] = dir!.ReadDir(-1)
-  if (list) {
-    list.sort((a: DirEntry, b: DirEntry): number => {
-      return $.pointerValue<Exclude<DirEntry, null>>(a)
-        .Name()
-        .localeCompare($.pointerValue<Exclude<DirEntry, null>>(b).Name())
-    })
+    let list: $.Slice<DirEntry>
+    ;[list, err] = await dir!.ReadDir(-1)
+    if (list) {
+      list.sort((a: DirEntry, b: DirEntry): number => {
+        return $.pointerValue<Exclude<DirEntry, null>>(a)
+          .Name()
+          .localeCompare($.pointerValue<Exclude<DirEntry, null>>(b).Name())
+      })
+    }
+    return [list, err]
+  } finally {
+    await file!.Close()
   }
-  return [list, err]
 }
 
 class dirInfo {

package/gs/io/fs/sub.ts

@@ -164,14 +164,14 @@ class subFS {
     return [file, f!.fixErr(err)]
   }
 
-  public ReadDir(name: string): [$.Slice<DirEntry>, $.GoError] {
+  public async ReadDir(name: string): Promise<[$.Slice<DirEntry>, $.GoError]> {
     const f = this
     let [full, err] = f!.fullName('read', name)
     if (err != null) {
       return [null, err]
     }
     let dir: $.Slice<DirEntry>
-    ;[dir, err] = ReadDir(f!.fsys, full)
+    ;[dir, err] = await ReadDir(f!.fsys, full)
     return [dir, f!.fixErr(err)]
   }
 
@@ -186,7 +186,7 @@ class subFS {
     return [data, f!.fixErr(err)]
   }
 
-  public Glob(pattern: string): [$.Slice<string>, $.GoError] {
+  public async Glob(pattern: string): Promise<[$.Slice<string>, $.GoError]> {
     const f = this
     {
       let [, err] = path.Match(pattern, '')
@@ -198,7 +198,7 @@ class subFS {
       return [$.arrayToSlice<string>(['.']), null]
     }
     let full = f!.dir + '/' + pattern
-    let [list, err] = Glob(f!.fsys, full)
+    let [list, err] = await Glob(f!.fsys, full)
     for (let i = 0; i < $.len(list); i++) {
       const name = list![i]
       {

package/gs/io/fs/walk.ts

@@ -39,7 +39,7 @@ export async function walkDir(
     }
   }
 
-  let [dirs, err] = ReadDir(fsys, name)
+  let [dirs, err] = await ReadDir(fsys, name)
 
   // Second call, to report ReadDir error.
   if (err != null) {

package/gs/maps/iter.ts

@@ -8,9 +8,9 @@ import * as iter from '@goscript/iter/index.js'
 export function All<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq2<K, V> {
-  return (_yield: ((p0: K, p1: V) => iter.YieldResult) | null):
-    | void
-    | globalThis.Promise<void> => iteratePairs(m?.entries() ?? [], _yield)
+  return (
+    _yield: ((p0: K, p1: V) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => iteratePairs(m?.entries() ?? [], _yield)
 }
 
 // Keys returns an iterator over keys in m.
@@ -19,9 +19,9 @@ export function All<K extends $.Comparable | null, V>(
 export function Keys<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<K> {
-  return (_yield: ((p0: K) => iter.YieldResult) | null):
-    | void
-    | globalThis.Promise<void> => iterateValues(mapKeys(m), _yield)
+  return (
+    _yield: ((p0: K) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => iterateValues(mapKeys(m), _yield)
 }
 
 // Values returns an iterator over values in m.
@@ -30,9 +30,9 @@ export function Keys<K extends $.Comparable | null, V>(
 export function Values<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<V> {
-  return (_yield: ((p0: V) => iter.YieldResult) | null):
-    | void
-    | globalThis.Promise<void> => iterateValues(mapValues(m), _yield)
+  return (
+    _yield: ((p0: V) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => iterateValues(mapValues(m), _yield)
 }
 
 // Insert adds the key-value pairs from seq to m.

package/gs/maps/maps.ts

@@ -4,10 +4,10 @@ import * as _ from '@goscript/unsafe/index.js'
 
 // Equal reports whether two maps contain the same key/value pairs.
 // Values are compared using ==.
-export function Equal<K extends $.Comparable | null, V extends $.Comparable | null>(
-  m1: Map<K, V>,
-  m2: Map<K, V>,
-): boolean {
+export function Equal<
+  K extends $.Comparable | null,
+  V extends $.Comparable | null,
+>(m1: Map<K, V>, m2: Map<K, V>): boolean {
   if ($.len(m1) != $.len(m2)) {
     return false
   }

package/gs/math/bits/index.test.ts

@@ -1,6 +1,15 @@
 import { describe, expect, it } from 'vitest'
 
-import { Mul64, Rem, Rem32, Rem64, RotateLeft16, RotateLeft32, RotateLeft64, RotateLeft8 } from './index.js'
+import {
+  Mul64,
+  Rem,
+  Rem32,
+  Rem64,
+  RotateLeft16,
+  RotateLeft32,
+  RotateLeft64,
+  RotateLeft8,
+} from './index.js'
 
 describe('math/bits override', () => {
   it('returns the full 128-bit product from Mul64', () => {

package/gs/mime/index.test.ts

@@ -22,14 +22,15 @@ describe('mime override', () => {
     expect(mediaType).toBe('text/plain')
     expect(params.get('charset')).toBe('utf-8')
     expect(params.get('format')).toBe('flowed')
-    const [trailingMediaType, trailingParams, trailingErr] = ParseMediaType('text/plain;')
+    const [trailingMediaType, trailingParams, trailingErr] =
+      ParseMediaType('text/plain;')
     expect(trailingErr).toBeNull()
     expect(trailingMediaType).toBe('text/plain')
     expect(trailingParams.size).toBe(0)
 
-    expect(
-      FormatMediaType('text/plain', new Map([['charset', 'utf-8']])),
-    ).toBe('text/plain; charset=utf-8')
+    expect(FormatMediaType('text/plain', new Map([['charset', 'utf-8']]))).toBe(
+      'text/plain; charset=utf-8',
+    )
     expect(
       FormatMediaType('Attachment', new Map([['FileName', 'hello.txt']])),
     ).toBe('attachment; filename=hello.txt')
@@ -37,10 +38,13 @@ describe('mime override', () => {
       FormatMediaType('attachment', new Map([['filename', 'foo bar.txt']])),
     ).toBe('attachment; filename="foo bar.txt"')
     expect(
-      FormatMediaType('text/plain', new Map([
-        ['z', 'last'],
-        ['a', 'first'],
-      ])),
+      FormatMediaType(
+        'text/plain',
+        new Map([
+          ['z', 'last'],
+          ['a', 'first'],
+        ]),
+      ),
     ).toBe('text/plain; a=first; z=last')
 
     const encoded = FormatMediaType(
@@ -51,13 +55,17 @@ describe('mime override', () => {
     const [, encodedParams, encodedErr] = ParseMediaType(encoded)
     expect(encodedErr).toBeNull()
     expect(encodedParams.get('filename')).toBe('résumé.txt')
-    const [, pathParams, pathErr] = ParseMediaType('form-data; filename="C:\\dev\\go.txt"; quoted="a\\"b"')
+    const [, pathParams, pathErr] = ParseMediaType(
+      'form-data; filename="C:\\dev\\go.txt"; quoted="a\\"b"',
+    )
     expect(pathErr).toBeNull()
     expect(pathParams.get('filename')).toBe('C:\\dev\\go.txt')
     expect(pathParams.get('quoted')).toBe('a"b')
 
     expect(TypeByExtension('.json')).toBe('application/json')
-    expect(AddExtensionType('.goscript', 'text/plain; charset=utf-8')).toBeNull()
+    expect(
+      AddExtensionType('.goscript', 'text/plain; charset=utf-8'),
+    ).toBeNull()
     const [extensions, extensionErr] = ExtensionsByType('text/plain')
     expect(extensionErr).toBeNull()
     expect(extensions).toContain('.goscript')
@@ -66,10 +74,18 @@ describe('mime override', () => {
   it('reports invalid media parameters', () => {
     const [, , err] = ParseMediaType('text/plain; broken')
     expect(err).toBe(ErrInvalidMediaParameter)
-    expect(ParseMediaType('text/plain; filename=foo bar')[2]).toBe(ErrInvalidMediaParameter)
-    expect(ParseMediaType('text/plain; filename="unterminated')[2]).toBe(ErrInvalidMediaParameter)
-    expect(ParseMediaType('text/plain; x=1; x=2')[2]).toBe(ErrInvalidMediaParameter)
-    expect(ParseMediaType('text/plain; bad[]=x')[2]).toBe(ErrInvalidMediaParameter)
+    expect(ParseMediaType('text/plain; filename=foo bar')[2]).toBe(
+      ErrInvalidMediaParameter,
+    )
+    expect(ParseMediaType('text/plain; filename="unterminated')[2]).toBe(
+      ErrInvalidMediaParameter,
+    )
+    expect(ParseMediaType('text/plain; x=1; x=2')[2]).toBe(
+      ErrInvalidMediaParameter,
+    )
+    expect(ParseMediaType('text/plain; bad[]=x')[2]).toBe(
+      ErrInvalidMediaParameter,
+    )
     expect(ParseMediaType('text/plain; bad{}=x')[1].get('bad{}')).toBe('x')
   })
 
@@ -83,7 +99,9 @@ describe('mime override', () => {
     expect(qWord).toBe('hello world')
 
     const encodedQWord = WordEncoder_Encode(QEncoding, 'utf-8', 'héllo world')
-    const [header, err] = new WordDecoder().DecodeHeader(`subject ${encodedQWord}`)
+    const [header, err] = new WordDecoder().DecodeHeader(
+      `subject ${encodedQWord}`,
+    )
     expect(err).toBeNull()
     expect(header).toBe('subject héllo world')
   })

package/gs/mime/index.ts

@@ -52,7 +52,11 @@ export function FormatMediaType(
     param instanceof Map ?
       Array.from(param.entries())
     : Object.entries(param ?? {})
-  entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+  entries.sort(([a], [b]) =>
+    a < b ? -1
+    : a > b ? 1
+    : 0,
+  )
   for (const [key, value] of entries) {
     if (!isToken(key)) {
       return ''
@@ -92,7 +96,10 @@ export function ParseMediaType(
     if (key.endsWith('*')) {
       const decoded = decode2231Value(value)
       if (decoded !== null) {
-        if (params.has(key.slice(0, -1)) && params.get(key.slice(0, -1)) !== decoded) {
+        if (
+          params.has(key.slice(0, -1)) &&
+          params.get(key.slice(0, -1)) !== decoded
+        ) {
           return ['', new Map(), ErrInvalidMediaParameter]
         }
         params.set(key.slice(0, -1), decoded)