goscript 0.0.47 → 0.0.49

package/gs/fmt/fmt.ts

@@ -200,10 +200,24 @@ function parseFormat(format: string, args: any[]): string {
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
-    // For now, just use a simple implementation that doesn't output
-    // In the real implementation, this would interact with the Go runtime
-    // The test will still pass because it only checks compilation
-    $.println(data)
+    // Use process.stdout.write if available (Node.js), otherwise fallback to console.log
+    // but we need to avoid adding extra newlines that console.log adds
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.write) {
+      process.stdout.write(data)
+    } else {
+      // In browser environments, we need to use console.log but handle newlines carefully
+      // If the data already ends with \n, we should strip it to avoid double newlines
+      if (data.endsWith('\n')) {
+        console.log(data.slice(0, -1))
+      } else {
+        // Use console.log without adding newline by using a custom method
+        if (console.log) {
+          // For data without newlines, we can just print it directly
+          // This is a bit of a hack but works for most cases
+          console.log(data)
+        }
+      }
+    }
   },
 }
 

package/gs/fmt/meta.json

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

package/gs/internal/meta.json

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

package/gs/io/fs/fs.ts

@@ -369,148 +369,133 @@ $.registerInterfaceType(
   ],
 )
 
-export class FileMode {
-  constructor(private _value: number) {}
+export type FileMode = number
 
-  valueOf(): number {
-    return this._value
-  }
-
-  toString(): string {
-    return fileModeString(this)
-  }
-
-  static from(value: number): FileMode {
-    return new FileMode(value)
-  }
-
-  // IsDir reports whether m describes a directory.
-  // That is, it tests for the ModeDir bit being set in m.
-  IsDir(): boolean {
-    return (this._value & ModeDir.valueOf()) != 0
-  }
+// IsDir reports whether m describes a directory.
+// That is, it tests for the ModeDir bit being set in m.
+export function FileMode_IsDir(receiver: FileMode): boolean {
+  return (receiver & ModeDir) != 0
+}
 
-  // IsRegular reports whether m describes a regular file.
-  // That is, it tests that no mode type bits are set.
-  IsRegular(): boolean {
-    return (this._value & ModeType.valueOf()) == 0
-  }
+// IsRegular reports whether m describes a regular file.
+// That is, it tests that no mode type bits are set.
+export function FileMode_IsRegular(receiver: FileMode): boolean {
+  return (receiver & ModeType) == 0
+}
 
-  // Perm returns the Unix permission bits in m (m & ModePerm).
-  Perm(): FileMode {
-    return new FileMode(this._value & ModePerm.valueOf())
-  }
+// Perm returns the Unix permission bits in m (m & ModePerm).
+export function FileMode_Perm(receiver: FileMode): FileMode {
+  return (receiver & ModePerm) as FileMode
+}
 
-  // String returns a textual representation of the file mode.
-  String(): string {
-    return fileModeString(this)
-  }
+// String returns a textual representation of the file mode.
+export function FileMode_String(receiver: FileMode): string {
+  return fileModeString(receiver)
+}
 
-  // Type returns type bits in m (m & ModeType).
-  Type(): FileMode {
-    return new FileMode((this._value & ModeType.valueOf()) >>> 0)
-  }
+// Type returns type bits in m (m & ModeType).
+export function FileMode_Type(receiver: FileMode): FileMode {
+  return ((receiver & ModeType) >>> 0) as FileMode
 }
 
 // The single letters are the abbreviations
 // used by the String method's formatting.
 // d: is a directory
-export let ModeDir: FileMode = new FileMode(2147483648) // 0x80000000
+export let ModeDir: FileMode = 2147483648 // 0x80000000
 
 // a: append-only
-export let ModeAppend: FileMode = new FileMode(1 << 30) // 0x40000000
+export let ModeAppend: FileMode = 1 << 30 // 0x40000000
 
 // l: exclusive use
-export let ModeExclusive: FileMode = new FileMode(1 << 29) // 0x20000000
+export let ModeExclusive: FileMode = 1 << 29 // 0x20000000
 
 // T: temporary file; Plan 9 only
-export let ModeTemporary: FileMode = new FileMode(1 << 28) // 0x10000000
+export let ModeTemporary: FileMode = 1 << 28 // 0x10000000
 
 // L: symbolic link
-export let ModeSymlink: FileMode = new FileMode(1 << 27) // 0x08000000
+export let ModeSymlink: FileMode = 1 << 27 // 0x08000000
 
 // D: device file
-export let ModeDevice: FileMode = new FileMode(1 << 26) // 0x04000000
+export let ModeDevice: FileMode = 1 << 26 // 0x04000000
 
 // p: named pipe (FIFO)
-export let ModeNamedPipe: FileMode = new FileMode(1 << 25) // 0x02000000
+export let ModeNamedPipe: FileMode = 1 << 25 // 0x02000000
 
 // S: Unix domain socket
-export let ModeSocket: FileMode = new FileMode(1 << 24) // 0x01000000
+export let ModeSocket: FileMode = 1 << 24 // 0x01000000
 
 // u: setuid
-export let ModeSetuid: FileMode = new FileMode(1 << 23) // 0x00800000
+export let ModeSetuid: FileMode = 1 << 23 // 0x00800000
 
 // g: setgid
-export let ModeSetgid: FileMode = new FileMode(1 << 22) // 0x00400000
+export let ModeSetgid: FileMode = 1 << 22 // 0x00400000
 
 // c: Unix character device, when ModeDevice is set
-export let ModeCharDevice: FileMode = new FileMode(1 << 21) // 0x00200000
+export let ModeCharDevice: FileMode = 1 << 21 // 0x00200000
 
 // t: sticky
-export let ModeSticky: FileMode = new FileMode(1 << 20) // 0x00100000
+export let ModeSticky: FileMode = 1 << 20 // 0x00100000
 
 // ?: non-regular file; nothing else is known about this file
-export let ModeIrregular: FileMode = new FileMode(1 << 19) // 0x00080000
+export let ModeIrregular: FileMode = 1 << 19 // 0x00080000
 
 // Mask for the type bits. For regular files, none will be set.
-export let ModeType: FileMode = new FileMode(2401763328)
+export let ModeType: FileMode = 2401763328
 
 // Unix permission bits
-export let ModePerm: FileMode = new FileMode(0o777)
+export let ModePerm: FileMode = 0o777
 
 // FileMode methods
 export function fileModeString(mode: FileMode): string {
   const buf: string[] = []
-  const w = mode.valueOf()
+  const w = mode
 
   // File type - these are the main type indicators
-  if (w & ModeDir.valueOf()) buf.push('d')
-  else if (w & ModeSymlink.valueOf()) buf.push('L')
-  else if (w & ModeNamedPipe.valueOf()) buf.push('p')
-  else if (w & ModeSocket.valueOf()) buf.push('S')
-  else if (w & ModeDevice.valueOf()) {
-    if (w & ModeCharDevice.valueOf()) buf.push('c')
+  if (w & ModeDir) buf.push('d')
+  else if (w & ModeSymlink) buf.push('L')
+  else if (w & ModeNamedPipe) buf.push('p')
+  else if (w & ModeSocket) buf.push('S')
+  else if (w & ModeDevice) {
+    if (w & ModeCharDevice) buf.push('c')
     else buf.push('D')
-  }
-  else if (w & ModeIrregular.valueOf()) buf.push('?')
+  } else if (w & ModeIrregular) buf.push('?')
   else buf.push('-')
 
   // Permission bits
-  const perm = w & ModePerm.valueOf()
+  const perm = w & ModePerm
   buf.push(perm & 0o400 ? 'r' : '-')
   buf.push(perm & 0o200 ? 'w' : '-')
-  
+
   // Execute/search for user
   if (perm & 0o100) {
-    if (w & ModeSetuid.valueOf()) buf.push('s')
+    if (w & ModeSetuid) buf.push('s')
     else buf.push('x')
   } else {
-    if (w & ModeSetuid.valueOf()) buf.push('S')
+    if (w & ModeSetuid) buf.push('S')
     else buf.push('-')
   }
-  
+
   buf.push(perm & 0o040 ? 'r' : '-')
   buf.push(perm & 0o020 ? 'w' : '-')
-  
+
   // Execute/search for group
   if (perm & 0o010) {
-    if (w & ModeSetgid.valueOf()) buf.push('s')
+    if (w & ModeSetgid) buf.push('s')
     else buf.push('x')
   } else {
-    if (w & ModeSetgid.valueOf()) buf.push('S')
+    if (w & ModeSetgid) buf.push('S')
     else buf.push('-')
   }
-  
+
   buf.push(perm & 0o004 ? 'r' : '-')
   buf.push(perm & 0o002 ? 'w' : '-')
-  
+
   // Execute/search for other
   if (perm & 0o001) {
-    if (w & ModeSticky.valueOf()) buf.push('t')
+    if (w & ModeSticky) buf.push('t')
     else buf.push('x')
   } else {
-    if (w & ModeSticky.valueOf()) buf.push('T')
+    if (w & ModeSticky) buf.push('T')
     else buf.push('-')
   }
 
@@ -518,7 +503,7 @@ export function fileModeString(mode: FileMode): string {
 }
 
 export function fileModeType(mode: FileMode): FileMode {
-  return new FileMode(mode.valueOf() & ModeType.valueOf())
+  return (mode & ModeType) as FileMode
 }
 
 export class PathError {

package/gs/io/meta.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": [
+    "errors",
+    "internal/oserror",
+    "path",
+    "time",
+    "unicode/utf8"
+  ]
+} 

package/gs/maps/meta.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": [
+    "iter",
+    "unsafe"
+  ]
+} 

package/gs/math/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "math/bits"
+  ]
+} 

package/gs/os/index.ts

@@ -107,7 +107,11 @@ export {
   DirEntry,
   File,
   FileInfo,
-  FileMode,
+  FileMode_IsDir,
+  FileMode_IsRegular,
+  FileMode_Perm,
+  FileMode_String,
+  FileMode_Type,
   Getpagesize,
   ModeAppend,
   ModeCharDevice,
@@ -126,3 +130,6 @@ export {
   ModeType,
   SameFile,
 } from './types_js.gs.js'
+
+// Export FileMode as a type
+export type { FileMode } from './types_js.gs.js'

package/gs/os/meta.json

@@ -0,0 +1,15 @@
+{
+  "dependencies": [
+    "errors",
+    "internal/byteorder",
+    "internal/goarch",
+    "internal/poll",
+    "io",
+    "io/fs",
+    "runtime",
+    "sync",
+    "syscall",
+    "time",
+    "unsafe"
+  ]
+} 

package/gs/os/types_js.gs.ts

@@ -9,7 +9,7 @@ import * as syscall from "@goscript/syscall/index.js"
 // Re-export essential types
 export type Time = time.Time;
 export type FileInfo = fs.FileInfo;
-export { FileMode } from "@goscript/io/fs/index.js";
+export type FileMode = fs.FileMode;
 export type DirEntry = fs.DirEntry;
 
 // Export runtime values for ES module compatibility  
@@ -202,4 +202,25 @@ export let ModePerm: fs.FileMode = fs.ModePerm
 export function SameFile(fi1: fs.FileInfo, fi2: fs.FileInfo): boolean {
 	// In JavaScript environment, always return false as we can't compare files
 	return false
+}
+
+// FileMode wrapper functions - re-export from fs module
+export function FileMode_IsDir(receiver: fs.FileMode): boolean {
+	return fs.FileMode_IsDir(receiver)
+}
+
+export function FileMode_IsRegular(receiver: fs.FileMode): boolean {
+	return fs.FileMode_IsRegular(receiver)
+}
+
+export function FileMode_Perm(receiver: fs.FileMode): fs.FileMode {
+	return fs.FileMode_Perm(receiver)
+}
+
+export function FileMode_String(receiver: fs.FileMode): string {
+	return fs.FileMode_String(receiver)
+}
+
+export function FileMode_Type(receiver: fs.FileMode): fs.FileMode {
+	return fs.FileMode_Type(receiver)
 } 

package/gs/os/types_unix.gs.ts

@@ -54,7 +54,7 @@ class fileStat {
 		this._fields = {
 			name: $.varRef(init?.name ?? ""),
 			size: $.varRef(init?.size ?? 0),
-			mode: $.varRef(init?.mode ?? new fs.FileMode(0)),
+			mode: $.varRef(init?.mode ?? 0),
 			modTime: $.varRef(init?.modTime?.clone() ?? time.Now()),
 			sys: $.varRef(init?.sys?.clone() ?? new syscall.Stat_t())
 		}
@@ -79,7 +79,7 @@ class fileStat {
 
 	public IsDir(): boolean {
 		const fileStat = this
-		return (fileStat!.Mode().valueOf() & fs.ModeDir.valueOf()) !== 0
+		return (fileStat!.Mode() & fs.ModeDir) !== 0
 	}
 
 	public Size(): number {

package/gs/path/meta.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": [
+    "errors",
+    "unicode/utf8"
+  ]
+} 

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { TypeOf } from './type.js'
+import { TypeOf, Kind_String } from './type.js'
 
 describe('Function Type Detection', () => {
   it('should detect regular function types', () => {
@@ -8,7 +8,7 @@ describe('Function Type Detection', () => {
     }
     const type = TypeOf(regularFunc)
     expect(type.String()).toMatch(/^func/)
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should detect GoScript typed functions with __goTypeName', () => {
@@ -19,7 +19,7 @@ describe('Function Type Detection', () => {
     Object.assign(greetFunc, { __goTypeName: 'Greeter' })
     const greetType = TypeOf(greetFunc)
     expect(greetType.String()).toBe('func(string) string')
-    expect(greetType.Kind().String()).toBe('func')
+    expect(Kind_String(greetType.Kind())).toBe('func')
 
     // Test Adder function type
     const addFunc = function (a: number, b: number) {
@@ -28,7 +28,7 @@ describe('Function Type Detection', () => {
     Object.assign(addFunc, { __goTypeName: 'Adder' })
     const addType = TypeOf(addFunc)
     expect(addType.String()).toBe('func(int, int) int')
-    expect(addType.Kind().String()).toBe('func')
+    expect(Kind_String(addType.Kind())).toBe('func')
   })
 
   it('should detect functions with full __typeInfo metadata', () => {
@@ -49,7 +49,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(complexFunc)
     expect(type.String()).toBe('func(int, int) int')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with multiple return types', () => {
@@ -70,7 +70,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(multiReturnFunc)
     expect(type.String()).toBe('func() (int, string)')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with no parameters', () => {
@@ -88,7 +88,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(noParamFunc)
     expect(type.String()).toBe('func() int')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with no return type', () => {
@@ -106,7 +106,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(voidFunc)
     expect(type.String()).toBe('func(int)')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should fallback to generic func for unknown typed functions', () => {
@@ -117,14 +117,14 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(unknownFunc)
     expect(type.String()).toBe('func')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle arrow functions', () => {
     const arrowFunc = (x: number) => x * 2
     const type = TypeOf(arrowFunc)
     expect(type.String()).toMatch(/^func/)
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should detect functions that return values vs void functions', () => {

package/gs/reflect/index.ts

@@ -3,15 +3,19 @@ export {
   TypeOf,
   ValueOf,
   Value,
-  Kind,
+  Kind_String,
   ArrayOf,
   SliceOf,
   PointerTo,
   PtrTo,
   MapOf,
   ChanOf,
+  ChanDir_String,
+  RecvDir,
+  SendDir,
+  BothDir,
 } from './type'
-export type { Type } from './type'
+export type { Type, ChanDir, Kind } from './type'
 export { DeepEqual } from './deepequal'
 export {
   Zero,
@@ -28,10 +32,6 @@ export { Swapper } from './swapper'
 
 // Export new types and constants
 export {
-  ChanDir,
-  RecvDir,
-  SendDir,
-  BothDir,
   StructTag,
   ValueError,
   SelectDir,

package/gs/reflect/map.ts

@@ -1,4 +1,4 @@
-import { Type, Kind, Value } from './type.js'
+import { Type, Kind, Value, Map as MapKind } from './type.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -17,7 +17,7 @@ class MapType implements Type {
   }
 
   public Kind(): Kind {
-    return new Kind(21) // Map kind
+    return MapKind // Map kind
   }
 
   public Size(): number {

package/gs/reflect/meta.json

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