goscript 0.0.36 → 0.0.38

package/gs/math/nextafter.gs.test.ts

@@ -6,7 +6,9 @@ describe('Nextafter', () => {
     expect(Nextafter(1.0, 1.0)).toBe(1.0)
     expect(Nextafter(0.0, 0.0)).toBe(0.0)
     expect(Nextafter(-1.0, -1.0)).toBe(-1.0)
-    expect(Nextafter(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Nextafter(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)).toBe(
+      Number.POSITIVE_INFINITY,
+    )
   })
 
   it('should return NaN when either input is NaN', () => {
@@ -18,7 +20,7 @@ describe('Nextafter', () => {
   it('should handle zero correctly', () => {
     const nextPos = Nextafter(0, 1)
     const nextNeg = Nextafter(0, -1)
-    
+
     expect(nextPos).toBeGreaterThan(0)
     expect(nextNeg).toBeLessThan(0)
     expect(Math.abs(nextPos)).toBe(Number.MIN_VALUE)
@@ -70,7 +72,7 @@ describe('Nextafter32', () => {
   it('should handle zero correctly', () => {
     const nextPos = Nextafter32(0, 1)
     const nextNeg = Nextafter32(0, -1)
-    
+
     expect(nextPos).toBeGreaterThan(0)
     expect(nextNeg).toBeLessThan(0)
     // For float32, the smallest positive value is different
@@ -82,7 +84,7 @@ describe('Nextafter32', () => {
     const x = 1.0
     const nextUp = Nextafter32(x, 2.0)
     const nextDown = Nextafter32(x, 0.0)
-    
+
     expect(nextUp).toBeGreaterThan(x)
     expect(nextDown).toBeLessThan(x)
   })
@@ -91,7 +93,7 @@ describe('Nextafter32', () => {
     const x = 1.0
     const nextUp = Nextafter32(x, Number.POSITIVE_INFINITY)
     const nextDown = Nextafter32(x, 0.0)
-    
+
     expect(nextUp).toBeGreaterThan(x)
     expect(nextDown).toBeLessThan(x)
   })
@@ -100,8 +102,8 @@ describe('Nextafter32', () => {
     const x = -1.0
     const nextUp = Nextafter32(x, 0.0)
     const nextDown = Nextafter32(x, -2.0)
-    
+
     expect(nextUp).toBeGreaterThan(x)
     expect(nextDown).toBeLessThan(x)
   })
-}) 
+})

package/gs/math/pow.gs.test.ts

@@ -37,7 +37,7 @@ describe('Pow', () => {
     expect(Pow(2, Number.NEGATIVE_INFINITY)).toBe(0)
     expect(Pow(0.5, Number.POSITIVE_INFINITY)).toBe(0)
     expect(Pow(0.5, Number.NEGATIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
-    
+
     expect(Pow(Number.POSITIVE_INFINITY, 1)).toBe(Number.POSITIVE_INFINITY)
     expect(Pow(Number.POSITIVE_INFINITY, -1)).toBe(0)
     expect(Pow(Number.NEGATIVE_INFINITY, 2)).toBe(Number.POSITIVE_INFINITY)
@@ -59,7 +59,7 @@ describe('Pow', () => {
 
   it('should handle fractional exponents', () => {
     expect(Pow(4, 0.5)).toBe(2)
-    expect(Pow(8, 1/3)).toBeCloseTo(2, 15)
+    expect(Pow(8, 1 / 3)).toBeCloseTo(2, 15)
     expect(Pow(16, 0.25)).toBe(2)
   })
 })
@@ -69,7 +69,9 @@ describe('pow', () => {
     expect(pow(2, 3)).toBe(Pow(2, 3))
     expect(pow(0, 1)).toBe(Pow(0, 1))
     expect(pow(-2, 2)).toBe(Pow(-2, 2))
-    expect(pow(Number.POSITIVE_INFINITY, 1)).toBe(Pow(Number.POSITIVE_INFINITY, 1))
+    expect(pow(Number.POSITIVE_INFINITY, 1)).toBe(
+      Pow(Number.POSITIVE_INFINITY, 1),
+    )
   })
 })
 
@@ -100,4 +102,4 @@ describe('isOddInt', () => {
     expect(isOddInt(1 << 53)).toBe(false) // too large
     expect(isOddInt((1 << 53) - 1)).toBe(true) // largest odd integer
   })
-}) 
+})

package/gs/math/pow10.gs.test.ts

@@ -55,4 +55,4 @@ describe('Pow10', () => {
       expect(Pow10(n)).toBeCloseTo(Math.pow(10, n), 15)
     }
   })
-}) 
+})

package/gs/math/remainder.gs.test.ts

@@ -67,4 +67,4 @@ describe('remainder', () => {
     expect(Number.isNaN(remainder(Number.NaN, 3))).toBe(true)
     expect(Number.isNaN(remainder(5, 0))).toBe(true)
   })
-}) 
+})

package/gs/math/signbit.gs.test.ts

@@ -30,4 +30,4 @@ describe('Signbit', () => {
     expect(Signbit(Number.NaN)).toBe(false)
     expect(Signbit(-Number.NaN)).toBe(false) // NaN doesn't have a sign
   })
-}) 
+})

package/gs/math/sin.gs.test.ts

@@ -80,4 +80,4 @@ describe('cos', () => {
     expect(cos(-Math.PI / 2)).toBe(Cos(-Math.PI / 2))
     expect(cos(Math.PI)).toBe(Cos(Math.PI))
   })
-}) 
+})

package/gs/math/sincos.gs.test.ts

@@ -6,7 +6,7 @@ describe('Sincos', () => {
     const [sin, cos] = Sincos(0)
     expect(sin).toBe(0)
     expect(cos).toBe(1)
-    
+
     const [sinNeg, cosNeg] = Sincos(-0)
     expect(sinNeg).toBe(-0)
     expect(cosNeg).toBe(1)
@@ -16,15 +16,15 @@ describe('Sincos', () => {
     const [sin1, cos1] = Sincos(Math.PI / 2)
     expect(sin1).toBeCloseTo(1, 15)
     expect(cos1).toBeCloseTo(0, 15)
-    
+
     const [sin2, cos2] = Sincos(-Math.PI / 2)
     expect(sin2).toBeCloseTo(-1, 15)
     expect(cos2).toBeCloseTo(0, 15)
-    
+
     const [sin3, cos3] = Sincos(Math.PI)
     expect(sin3).toBeCloseTo(0, 15)
     expect(cos3).toBeCloseTo(-1, 15)
-    
+
     const [sin4, cos4] = Sincos(-Math.PI)
     expect(sin4).toBeCloseTo(0, 15)
     expect(cos4).toBeCloseTo(-1, 15)
@@ -34,11 +34,11 @@ describe('Sincos', () => {
     const [sin1, cos1] = Sincos(Math.PI / 6)
     expect(sin1).toBeCloseTo(0.5, 15)
     expect(cos1).toBeCloseTo(Math.sqrt(3) / 2, 15)
-    
+
     const [sin2, cos2] = Sincos(Math.PI / 4)
     expect(sin2).toBeCloseTo(Math.sqrt(2) / 2, 15)
     expect(cos2).toBeCloseTo(Math.sqrt(2) / 2, 15)
-    
+
     const [sin3, cos3] = Sincos(Math.PI / 3)
     expect(sin3).toBeCloseTo(Math.sqrt(3) / 2, 15)
     expect(cos3).toBeCloseTo(0.5, 15)
@@ -48,19 +48,29 @@ describe('Sincos', () => {
     const [sin1, cos1] = Sincos(Number.POSITIVE_INFINITY)
     expect(Number.isNaN(sin1)).toBe(true)
     expect(Number.isNaN(cos1)).toBe(true)
-    
+
     const [sin2, cos2] = Sincos(Number.NEGATIVE_INFINITY)
     expect(Number.isNaN(sin2)).toBe(true)
     expect(Number.isNaN(cos2)).toBe(true)
-    
+
     const [sin3, cos3] = Sincos(Number.NaN)
     expect(Number.isNaN(sin3)).toBe(true)
     expect(Number.isNaN(cos3)).toBe(true)
   })
 
   it('should satisfy the Pythagorean identity', () => {
-    const testValues = [0, Math.PI / 6, Math.PI / 4, Math.PI / 3, Math.PI / 2, Math.PI, 1.5, 2.7, -1.2]
-    
+    const testValues = [
+      0,
+      Math.PI / 6,
+      Math.PI / 4,
+      Math.PI / 3,
+      Math.PI / 2,
+      Math.PI,
+      1.5,
+      2.7,
+      -1.2,
+    ]
+
     for (const x of testValues) {
       const [sin, cos] = Sincos(x)
       expect(sin * sin + cos * cos).toBeCloseTo(1, 14)
@@ -72,7 +82,7 @@ describe('Sincos', () => {
     const [sin1, cos1] = Sincos(x)
     const [sin2, cos2] = Sincos(x + 2 * Math.PI)
     const [sin3, cos3] = Sincos(x + 4 * Math.PI)
-    
+
     expect(sin1).toBeCloseTo(sin2, 14)
     expect(cos1).toBeCloseTo(cos2, 14)
     expect(sin1).toBeCloseTo(sin3, 14)
@@ -80,12 +90,21 @@ describe('Sincos', () => {
   })
 
   it('should match individual Math.sin and Math.cos calls', () => {
-    const testValues = [0, Math.PI / 6, Math.PI / 4, Math.PI / 3, Math.PI / 2, Math.PI, 1.5, -1.2]
-    
+    const testValues = [
+      0,
+      Math.PI / 6,
+      Math.PI / 4,
+      Math.PI / 3,
+      Math.PI / 2,
+      Math.PI,
+      1.5,
+      -1.2,
+    ]
+
     for (const x of testValues) {
       const [sin, cos] = Sincos(x)
       expect(sin).toBeCloseTo(Math.sin(x), 15)
       expect(cos).toBeCloseTo(Math.cos(x), 15)
     }
   })
-}) 
+})

package/gs/math/sinh.gs.test.ts

@@ -63,4 +63,4 @@ describe('cosh', () => {
     expect(cosh(-1)).toBe(Cosh(-1))
     expect(cosh(Number.POSITIVE_INFINITY)).toBe(Cosh(Number.POSITIVE_INFINITY))
   })
-}) 
+})

package/gs/math/sqrt.gs.test.ts

@@ -46,4 +46,4 @@ describe('sqrt', () => {
     expect(sqrt(9)).toBe(Sqrt(9))
     expect(Number.isNaN(sqrt(-1))).toBe(Number.isNaN(Sqrt(-1)))
   })
-}) 
+})

package/gs/math/tan.gs.test.ts

@@ -22,8 +22,8 @@ describe('Tan', () => {
   it('should approach infinity near asymptotes', () => {
     const nearPiOver2 = Math.PI / 2 - 1e-10
     expect(Math.abs(Tan(nearPiOver2))).toBeGreaterThan(1e9)
-    
-    const near3PiOver2 = 3 * Math.PI / 2 - 1e-10
+
+    const near3PiOver2 = (3 * Math.PI) / 2 - 1e-10
     expect(Math.abs(Tan(near3PiOver2))).toBeGreaterThan(1e9)
   })
 
@@ -47,4 +47,4 @@ describe('tan', () => {
     expect(tan(Math.PI)).toBe(Tan(Math.PI))
     expect(Number.isNaN(tan(Number.NaN))).toBe(Number.isNaN(Tan(Number.NaN)))
   })
-}) 
+})

package/gs/math/tanh.gs.test.ts

@@ -49,4 +49,4 @@ describe('tanh', () => {
     expect(tanh(-1)).toBe(Tanh(-1))
     expect(tanh(Number.POSITIVE_INFINITY)).toBe(Tanh(Number.POSITIVE_INFINITY))
   })
-}) 
+})

package/gs/os/dir.gs.ts

@@ -0,0 +1,42 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+import * as fs from "@goscript/io/fs/index.js"
+
+type DirEntry = fs.DirEntry;
+
+// ReadDir reads the named directory,
+// returning all its directory entries sorted by filename.
+// If an error occurs reading the directory,
+// ReadDir returns the entries it was able to read before the error,
+// along with the error.
+export function ReadDir(name: string): [$.Slice<DirEntry>, $.GoError] {
+	// Directory reading not supported in JavaScript environment
+	return [null, ErrUnimplemented]
+}
+
+// CopyFS copies the file system fsys into the directory dir,
+// creating dir if necessary.
+//
+// Files are created with mode 0o666 plus any execute permissions
+// from the source, and directories are created with mode 0o777
+// (before umask).
+//
+// CopyFS will not overwrite existing files. If a file name in fsys
+// already exists in the destination, CopyFS will return an error
+// such that errors.Is(err, fs.ErrExist) will be true.
+//
+// Symbolic links in fsys are not supported. A *PathError with Err set
+// to ErrInvalid is returned when copying from a symbolic link.
+//
+// Symbolic links in dir are followed.
+//
+// New files added to fsys (including if dir is a subdirectory of fsys)
+// while CopyFS is running are not guaranteed to be copied.
+//
+// Copying stops at and returns the first error encountered.
+export function CopyFS(dir: string, fsys: fs.FS): $.GoError {
+	// File system copying not supported in JavaScript environment
+	return ErrUnimplemented
+}
+

package/gs/os/dir_unix.gs.ts

@@ -0,0 +1,155 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { direntIno, direntNamlen, direntReclen, direntType } from "./dirent_js.gs.js";
+import { IsNotExist } from "./error.gs.js";
+import { newUnixDirent } from "./file_unix_js.gs.js";
+
+import * as byteorder from "@goscript/internal/byteorder/index.js"
+
+import * as goarch from "@goscript/internal/goarch/index.js"
+
+import * as io from "@goscript/io/index.js"
+
+import * as runtime from "@goscript/runtime/index.js"
+
+import * as sync from "@goscript/sync/index.js"
+
+import * as syscall from "@goscript/syscall/index.js"
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+// Import uintptr type
+type uintptr = syscall.uintptr
+
+class dirInfo {
+	public get mu(): sync.Mutex {
+		return this._fields.mu.value
+	}
+	public set mu(value: sync.Mutex) {
+		this._fields.mu.value = value
+	}
+
+	// buffer for directory I/O
+	public get buf(): $.VarRef<$.Bytes> | null {
+		return this._fields.buf.value
+	}
+	public set buf(value: $.VarRef<$.Bytes> | null) {
+		this._fields.buf.value = value
+	}
+
+	// length of buf; return value from Getdirentries
+	public get nbuf(): number {
+		return this._fields.nbuf.value
+	}
+	public set nbuf(value: number) {
+		this._fields.nbuf.value = value
+	}
+
+	// location of next record in buf.
+	public get bufp(): number {
+		return this._fields.bufp.value
+	}
+	public set bufp(value: number) {
+		this._fields.bufp.value = value
+	}
+
+	public _fields: {
+		mu: $.VarRef<sync.Mutex>;
+		buf: $.VarRef<$.VarRef<$.Bytes> | null>;
+		nbuf: $.VarRef<number>;
+		bufp: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{buf?: $.VarRef<$.Bytes> | null, bufp?: number, mu?: sync.Mutex, nbuf?: number}>) {
+		this._fields = {
+			mu: $.varRef(init?.mu?.clone() ?? new sync.Mutex()),
+			buf: $.varRef(init?.buf ?? null),
+			nbuf: $.varRef(init?.nbuf ?? 0),
+			bufp: $.varRef(init?.bufp ?? 0)
+		}
+	}
+
+	public clone(): dirInfo {
+		const cloned = new dirInfo()
+		cloned._fields = {
+			mu: $.varRef(this._fields.mu.value?.clone() ?? null),
+			buf: $.varRef(this._fields.buf.value),
+			nbuf: $.varRef(this._fields.nbuf.value),
+			bufp: $.varRef(this._fields.bufp.value)
+		}
+		return cloned
+	}
+
+	public close(): void {
+		const d = this
+		if (d.buf != null) {
+			dirBufPool.Put(d.buf)
+			d.buf = null
+		}
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'dirInfo',
+	  new dirInfo(),
+	  [{ name: "close", args: [], returns: [] }],
+	  dirInfo,
+	  {"mu": "Mutex", "buf": { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, "nbuf": { kind: $.TypeKind.Basic, name: "number" }, "bufp": { kind: $.TypeKind.Basic, name: "number" }}
+	);
+}
+
+// More than 5760 to work around https://golang.org/issue/24015.
+let blockSize: number = 8192
+
+let dirBufPool: sync.Pool = new sync.Pool({New: (): null | any => {
+	// The buffer must be at least a block long.
+	let buf = new Uint8Array(8192)
+	return buf
+}})
+
+// readInt returns the size-bytes unsigned integer in native byte order at offset off.
+export function readInt(b: $.Bytes, off: uintptr, size: uintptr): [number, boolean] {
+	let u: number = 0
+	let ok: boolean = false
+	{
+		if ($.len(b) < $.int(off + size)) {
+			return [0, false]
+		}
+		if (goarch.BigEndian) {
+			return [readIntBE($.goSlice(b, off, undefined), size), true]
+		}
+		return [readIntLE($.goSlice(b, off, undefined), size), true]
+	}
+}
+
+export function readIntBE(b: $.Bytes, size: uintptr): number {
+	switch (size) {
+		case 1:
+			return (b![0] as number)
+		case 2:
+			return (byteorder.BEUint16(b) as number)
+		case 4:
+			return (byteorder.BEUint32(b) as number)
+		case 8:
+			return (byteorder.BEUint64(b) as number)
+		default:
+			$.panic("syscall: readInt with unsupported size")
+			return 0 // This line will never be reached due to panic, but satisfies TypeScript
+	}
+}
+
+export function readIntLE(b: $.Bytes, size: uintptr): number {
+	switch (size) {
+		case 1:
+			return (b![0] as number)
+		case 2:
+			return (byteorder.LEUint16(b) as number)
+		case 4:
+			return (byteorder.LEUint32(b) as number)
+		case 8:
+			return (byteorder.LEUint64(b) as number)
+		default:
+			$.panic("syscall: readInt with unsupported size")
+			return 0 // This line will never be reached due to panic, but satisfies TypeScript
+	}
+}
+

package/gs/os/dirent_js.gs.ts

@@ -0,0 +1,27 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { readInt } from "./dir_unix.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+export function direntIno(buf: $.Bytes): [number, boolean] {
+	return [1, true]
+}
+
+export function direntReclen(buf: $.Bytes): [number, boolean] {
+	return readInt(buf, unsafe.Offsetof(new syscall.Dirent({}).Reclen), unsafe.Sizeof(new syscall.Dirent({}).Reclen))
+}
+
+export function direntNamlen(buf: $.Bytes): [number, boolean] {
+	let [reclen, ok] = direntReclen(buf)
+	if (!ok) {
+		return [0, false]
+	}
+	return [reclen - (unsafe.Offsetof(new syscall.Dirent({}).Name) as number), true]
+}
+
+export function direntType(buf: $.Bytes): number {
+	return ~(0 as number)
+}
+

package/gs/os/env.gs.ts

@@ -0,0 +1,179 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { NewSyscallError } from "./error.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+// Expand replaces ${var} or $var in the string based on the mapping function.
+// For example, [os.ExpandEnv](s) is equivalent to [os.Expand](s, [os.Getenv]).
+export function Expand(s: string, mapping: ((p0: string) => string) | null): string {
+	let buf: $.Bytes = new Uint8Array(0)
+	// ${} is all ASCII, so bytes are fine for this operation.
+	let i = 0
+
+	// Encountered invalid syntax; eat the
+	// characters.
+
+	// Valid syntax, but $ was not followed by a
+	// name. Leave the dollar character untouched.
+	for (let j = 0; j < $.len(s); j++) {
+
+		// Encountered invalid syntax; eat the
+		// characters.
+
+		// Valid syntax, but $ was not followed by a
+		// name. Leave the dollar character untouched.
+		if ($.indexString(s, j) == 36 && j + 1 < $.len(s)) {
+			if (buf == null) {
+				buf = $.makeSlice<number>(0, 2 * $.len(s), 'byte')
+			}
+			buf = $.append(buf, ...$.stringToBytes($.sliceString(s, i, j)))
+			let [name, w] = getShellName($.sliceString(s, j + 1, undefined))
+
+			// Encountered invalid syntax; eat the
+			// characters.
+
+			// Valid syntax, but $ was not followed by a
+			// name. Leave the dollar character untouched.
+			if (name == "" && w > 0) {
+
+			} else if (name == "") {
+				// Valid syntax, but $ was not followed by a
+				// name. Leave the dollar character untouched.
+				buf = $.append(buf, $.indexString(s, j))
+			} else {
+				buf = $.append(buf, ...$.stringToBytes(mapping!(name)))
+			}
+			j += w
+			i = j + 1
+		}
+	}
+	if (buf == null) {
+		return s
+	}
+	return $.bytesToString(buf) + $.sliceString(s, i, undefined)
+}
+
+// ExpandEnv replaces ${var} or $var in the string according to the values
+// of the current environment variables. References to undefined
+// variables are replaced by the empty string.
+export function ExpandEnv(s: string): string {
+	return Expand(s, Getenv)
+}
+
+// isShellSpecialVar reports whether the character identifies a special
+// shell variable such as $*.
+export function isShellSpecialVar(c: number): boolean {
+	switch (c) {
+		case 42:
+		case 35:
+		case 36:
+		case 64:
+		case 33:
+		case 63:
+		case 45:
+		case 48:
+		case 49:
+		case 50:
+		case 51:
+		case 52:
+		case 53:
+		case 54:
+		case 55:
+		case 56:
+		case 57:
+			return true
+			break
+	}
+	return false
+}
+
+// isAlphaNum reports whether the byte is an ASCII letter, number, or underscore.
+export function isAlphaNum(c: number): boolean {
+	return c == 95 || 48 <= c && c <= 57 || 97 <= c && c <= 122 || 65 <= c && c <= 90
+}
+
+// getShellName returns the name that begins the string and the number of bytes
+// consumed to extract it. If the name is enclosed in {}, it's part of a ${}
+// expansion and two more bytes are needed than the length of the name.
+export function getShellName(s: string): [string, number] {
+
+	// Scan to closing brace
+
+	// Bad syntax; eat "${}"
+
+	// Bad syntax; eat "${"
+	switch (true) {
+		case $.indexString(s, 0) == 123:
+			if ($.len(s) > 2 && isShellSpecialVar($.indexString(s, 1)) && $.indexString(s, 2) == 125) {
+				return [$.sliceString(s, 1, 2), 3]
+			}
+			for (let i = 1; i < $.len(s); i++) {
+
+				// Bad syntax; eat "${}"
+				if ($.indexString(s, i) == 125) {
+
+					// Bad syntax; eat "${}"
+					if (i == 1) {
+						return ["", 2]
+					}
+					return [$.sliceString(s, 1, i), i + 1]
+				}
+			}
+			return ["", 1]
+			break
+		case isShellSpecialVar($.indexString(s, 0)):
+			return [$.sliceString(s, 0, 1), 1]
+			break
+	}
+	// Scan alphanumerics.
+	let i: number = 0
+	for (i = 0; i < $.len(s) && isAlphaNum($.indexString(s, i)); i++) {
+	}
+	return [$.sliceString(s, undefined, i), i]
+}
+
+// Getenv retrieves the value of the environment variable named by the key.
+// It returns the value, which will be empty if the variable is not present.
+// To distinguish between an empty value and an unset value, use [LookupEnv].
+export function Getenv(key: string): string {
+	// testlog.Getenv(key) // Testlog not available in JavaScript
+	let [v, ] = syscall.Getenv(key)
+	return v
+}
+
+// LookupEnv retrieves the value of the environment variable named
+// by the key. If the variable is present in the environment the
+// value (which may be empty) is returned and the boolean is true.
+// Otherwise the returned value will be empty and the boolean will
+// be false.
+export function LookupEnv(key: string): [string, boolean] {
+	// testlog.Getenv(key) // Testlog not available in JavaScript
+	return syscall.Getenv(key)
+}
+
+// Setenv sets the value of the environment variable named by the key.
+// It returns an error, if any.
+export function Setenv(key: string, value: string): $.GoError {
+	let err = syscall.Setenv(key, value)
+	if (err != null) {
+		return NewSyscallError("setenv", err)
+	}
+	return null
+}
+
+// Unsetenv unsets a single environment variable.
+export function Unsetenv(key: string): $.GoError {
+	return syscall.Unsetenv(key)
+}
+
+// Clearenv deletes all environment variables.
+export function Clearenv(): void {
+	syscall.Clearenv()
+}
+
+// Environ returns a copy of strings representing the environment,
+// in the form "key=value".
+export function Environ(): $.Slice<string> {
+	return syscall.Environ()
+}
+