goscript 0.0.33 → 0.0.35

package/gs/github.com/pkg/errors/stack.ts

@@ -0,0 +1,127 @@
+import * as $ from "../../../builtin/builtin.js";
+
+// Type definitions
+export type uintptr = number;
+
+export class Frame {
+	constructor(private _value: uintptr) {}
+
+	valueOf(): uintptr {
+		return this._value
+	}
+
+	toString(): string {
+		return String(this._value)
+	}
+
+	static from(value: uintptr): Frame {
+		return new Frame(value)
+	}
+
+	// pc returns the program counter for this frame;
+	// multiple frames may have the same PC value.
+	public pc(): uintptr {
+		return this._value - 1
+	}
+
+	// file returns the full path to the file that contains the
+	// function for this Frame's pc.
+	public file(): string {
+		return "unknown"
+	}
+
+	// line returns the line number of source code of the
+	// function for this Frame's pc.
+	public line(): number {
+		return 0
+	}
+
+	// name returns the name of this function, if known.
+	public name(): string {
+		return "unknown"
+	}
+
+	// MarshalText formats a stacktrace Frame as a text string.
+	public MarshalText(): [$.Bytes, $.GoError] {
+		const name = this.name()
+		if (name == "unknown") {
+			return [new TextEncoder().encode(name), null]
+		}
+		return [new TextEncoder().encode(`${name} ${this.file()}:${this.line()}`), null]
+	}
+}
+
+export class StackTrace {
+	constructor(private _value: Frame[] | null) {}
+
+	valueOf(): Frame[] | null {
+		return this._value
+	}
+
+	toString(): string {
+		return String(this._value)
+	}
+
+	static from(value: Frame[] | null): StackTrace {
+		return new StackTrace(value)
+	}
+}
+
+class stack {
+	constructor(private _value: uintptr[]) {}
+
+	valueOf(): uintptr[] {
+		return this._value
+	}
+
+	toString(): string {
+		return String(this._value)
+	}
+
+	static from(value: uintptr[]): stack {
+		return new stack(value)
+	}
+
+	public StackTrace(): StackTrace {
+		const s = this._value
+		if (!s || s.length === 0) {
+			return new StackTrace(null)
+		}
+		
+		const frames: Frame[] = []
+		for (let i = 0; i < s.length; i++) {
+			frames.push(new Frame(s[i]))
+		}
+		return new StackTrace(frames)
+	}
+}
+
+// callers returns a simplified stack trace using JavaScript's native stack
+export function callers(): $.VarRef<stack> | null {
+	try {
+		// Get JavaScript stack trace
+		throw new Error();
+	} catch(e: any) {
+		// Parse the stack trace to get some basic frame information
+		const stackLines = e.stack ? e.stack.split('\n') : []
+		
+		// Create simplified frame data - just use line numbers as uintptr values
+		const pcs: uintptr[] = []
+		for (let i = 0; i < Math.min(stackLines.length, 8); i++) {
+			pcs.push(i + 1) // Simple frame counter
+		}
+		
+		const st = new stack(pcs)
+		return $.varRef(st)
+	}
+}
+
+// funcname extracts the function name from a full function path
+export function funcname(name: string): string {
+	const lastDot = name.lastIndexOf('.')
+	if (lastDot >= 0) {
+		return name.substring(lastDot + 1)
+	}
+	return name
+}
+

package/gs/maps/index.ts

@@ -0,0 +1,2 @@
+export { All, Collect, Insert, Keys, Values } from './iter.js'
+export { Clone, Copy, DeleteFunc, Equal, EqualFunc } from './maps.js'

package/gs/maps/iter.ts

@@ -0,0 +1,67 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+import * as iter from '@goscript/iter/index.js'
+
+// All returns an iterator over key-value pairs from m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+export function All<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq2<K, V> {
+  return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
+    for (const [k, v] of m.entries()) {
+      if (!_yield!(k, v)) {
+        return
+      }
+    }
+  }
+}
+
+// Keys returns an iterator over keys in m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+export function Keys<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<K> {
+  return (_yield: ((p0: K) => boolean) | null): void => {
+    for (const [k, _v] of m.entries()) {
+      if (!_yield!(k)) {
+        return
+      }
+    }
+  }
+}
+
+// Values returns an iterator over values in m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+export function Values<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<V> {
+  return (_yield: ((p0: V) => boolean) | null): void => {
+    for (const [_k, v] of m.entries()) {
+      if (!_yield!(v)) {
+        return
+      }
+    }
+  }
+}
+
+// Insert adds the key-value pairs from seq to m.
+// If a key in seq already exists in m, its value will be overwritten.
+export function Insert<K extends $.Comparable, V>(
+  m: Map<K, V>,
+  seq: iter.Seq2<K, V>,
+): void {
+  ;(() => {
+    let shouldContinue = true
+    seq!((k, v) => {
+      $.mapSet(m, k, v)
+      return shouldContinue
+    })
+  })()
+}
+
+// Collect collects key-value pairs from seq into a new map
+// and returns it.
+export function Collect<K extends $.Comparable, V extends any>(
+  seq: iter.Seq2<K, V>,
+): Map<K, V> {
+  let m = $.makeMap<K, V>()
+  Insert(m, seq)
+  return m
+}

package/gs/maps/maps.ts

@@ -0,0 +1,89 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+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, V extends $.Comparable>(
+  m1: Map<K, V>,
+  m2: Map<K, V>,
+): boolean {
+  if ($.len(m1) != $.len(m2)) {
+    return false
+  }
+  for (const [k, v1] of m1.entries()) {
+    let [v2, ok] = $.mapGet(m2, k, null as any)
+    if (!ok || v1 != v2) {
+      return false
+    }
+  }
+  return true
+}
+
+// EqualFunc is like Equal, but compares values using eq.
+// Keys are still compared with ==.
+export function EqualFunc<K extends $.Comparable, V1, V2>(
+  m1: Map<K, V1>,
+  m2: Map<K, V2>,
+  eq: ((p0: V1, p1: V2) => boolean) | null,
+): boolean {
+  if ($.len(m1) != $.len(m2)) {
+    return false
+  }
+  for (const [k, v1] of m1.entries()) {
+    let [v2, ok] = $.mapGet(m2, k, null as any)
+    if (!ok || !eq!(v1, v2)) {
+      return false
+    }
+  }
+  return true
+}
+
+// clone returns a shallow copy of the map.
+export function clone<K extends $.Comparable, V>(
+  m: Map<K, V> | null,
+): Map<K, V> | null {
+  if (m == null) {
+    return null
+  }
+  const result = $.makeMap<K, V>()
+  for (const [k, v] of m.entries()) {
+    $.mapSet(result, k, v)
+  }
+  return result
+}
+
+// Clone returns a copy of m.  This is a shallow clone:
+// the new keys and values are set using ordinary assignment.
+export function Clone<K extends $.Comparable, V>(m: Map<K, V>): Map<K, V> {
+  // Preserve nil in case it matters.
+  if (m == null) {
+    return null as unknown as Map<K, V>
+  }
+  return clone(m)!
+}
+
+// Copy copies all key/value pairs in src adding them to dst.
+// When a key in src is already present in dst,
+// the value in dst will be overwritten by the value associated
+// with the key in src.
+export function Copy<K extends $.Comparable, V>(
+  dst: Map<K, V>,
+  src: Map<K, V>,
+): void {
+  for (const [k, v] of src.entries()) {
+    $.mapSet(dst, k, v)
+  }
+}
+
+// DeleteFunc deletes any key/value pairs from m for which del returns true.
+export function DeleteFunc<K extends $.Comparable, V>(
+  m: Map<K, V>,
+  del: ((p0: K, p1: V) => boolean) | null,
+): void {
+  for (const [k, v] of m.entries()) {
+    if (del!(k, v)) {
+      $.deleteMapEntry(m, k)
+    }
+  }
+}

package/gs/math/TODO.md

@@ -0,0 +1,156 @@
+# Math Module Optimization TODO
+
+## ✅ **COMPLETED** - JavaScript-Optimized Functions
+
+### Basic Functions
+- [x] `Abs()` → `Math.abs()`
+- [x] `Signbit()` → Simple comparison with `Object.is()` for negative zero
+- [x] `Sqrt()` → `Math.sqrt()`
+
+### Trigonometric Functions
+- [x] `Sin()`, `Cos()` → `Math.sin()`, `Math.cos()`
+- [x] `Tan()` → `Math.tan()`
+- [x] `Asin()`, `Acos()` → `Math.asin()`, `Math.acos()`
+- [x] `Atan()` → `Math.atan()`
+- [x] `Atan2()` → `Math.atan2()`
+- [x] `Sincos()` → `[Math.sin(x), Math.cos(x)]`
+
+### Hyperbolic Functions
+- [x] `Sinh()`, `Cosh()`, `Tanh()` → `Math.sinh()`, `Math.cosh()`, `Math.tanh()`
+- [x] `Asinh()`, `Acosh()`, `Atanh()` → `Math.asinh()`, `Math.acosh()`, `Math.atanh()`
+
+### Exponential & Logarithmic Functions
+- [x] `Exp()`, `Exp2()` → `Math.exp()`, `Math.pow(2, x)`
+- [x] `Expm1()` → `Math.expm1()`
+- [x] `Log()`, `Log10()`, `Log2()` → `Math.log()`, `Math.log10()`, `Math.log2()`
+- [x] `Log1p()` → `Math.log1p()`
+- [x] `Pow()` → `Math.pow()`
+- [x] `Pow10()` → `Math.pow(10, n)`
+- [x] `Cbrt()` → `Math.cbrt()`
+
+### Rounding & Floor Functions
+- [x] `Floor()`, `Ceil()`, `Trunc()` → `Math.floor()`, `Math.ceil()`, `Math.trunc()`
+- [x] `Round()`, `RoundToEven()` → `Math.round()` with custom tie-breaking
+
+### Utility Functions
+- [x] `Min()`, `Max()` → Optimized with proper NaN and zero handling
+- [x] `Dim()` → Simple subtraction with zero clamping
+- [x] `Copysign()` → `Math.abs()` and `Math.sign()` combination
+- [x] `Hypot()` → `Math.hypot()`
+- [x] `Mod()` → JavaScript `%` operator with special case handling
+- [x] `Remainder()` → IEEE 754 remainder using `Math.round()`
+
+### Special Value Functions
+- [x] `Inf()`, `NaN()`, `IsNaN()`, `IsInf()` → JavaScript native equivalents
+
+### Floating-Point Manipulation
+- [x] `Modf()` → `Math.trunc()` for integer part
+- [x] `Frexp()` → `Math.log2()` and `Math.pow()` for mantissa/exponent extraction
+- [x] `Ldexp()` → `Math.pow(2, exp)` for scaling
+- [x] `Logb()`, `Ilogb()` → `Math.log2()` for binary exponent
+- [x] `FMA()` → Simple `x * y + z` (JavaScript lacks native FMA)
+
+---
+
+## 🔄 **KEEP AS-IS** - Complex Mathematical Functions
+
+These functions require specialized mathematical algorithms that don't have JavaScript equivalents and should remain unchanged:
+
+### IEEE 754 Bit Manipulation
+- [x] `Nextafter()`, `Nextafter32()` - Require precise IEEE 754 bit manipulation
+- [x] `Float64bits()`, `Float64frombits()`, `Float32bits()`, `Float32frombits()` - Low-level bit operations
+
+### Special Mathematical Functions
+- [x] **Bessel Functions** (`j0.gs.ts`, `j1.gs.ts`, `jn.gs.ts`)
+  - `J0()`, `J1()`, `Jn()` - Bessel functions of the first kind
+  - `Y0()`, `Y1()`, `Yn()` - Bessel functions of the second kind
+  - Complex mathematical series approximations
+
+- [x] **Error Functions** (`erf.gs.ts`, `erfinv.gs.ts`)
+  - `Erf()`, `Erfc()` - Error function and complementary error function
+  - `Erfinv()`, `Erfcinv()` - Inverse error functions
+  - Complex polynomial approximations
+
+- [x] **Gamma Functions** (`gamma.gs.ts`, `lgamma.gs.ts`)
+  - `Gamma()` - Gamma function
+  - `Lgamma()` - Log gamma function with sign
+  - Stirling's approximation and complex mathematical series
+
+### Support Files
+- [x] `bits.gs.ts` - Bit manipulation utilities
+- [x] `unsafe.gs.ts` - Low-level floating-point operations
+- [x] `const.gs.ts` - Mathematical constants
+- [x] `stubs.gs.ts` - Architecture-specific function stubs
+- [x] `trig_reduce.gs.ts` - Trigonometric argument reduction (has type issues with bigint/number but preserved as-is)
+
+### Assembly/Architecture Specific Files
+- [x] `*_noasm.gs.ts` files - Non-assembly fallback implementations (unused ones removed)
+- [x] `*_asm.gs.ts` files - Assembly-optimized implementations (unused ones removed)
+
+---
+
+## 🧹 **CLEANUP TASKS**
+
+### Remove Unused Files
+- [x] `exp_noasm.gs.ts` - Removed and cleaned up imports
+- [x] `exp2_noasm.gs.ts` - Removed and cleaned up imports
+- [x] `hypot_noasm.gs.ts` - Removed and cleaned up imports
+- [x] `dim_noasm.gs.ts` - Removed and cleaned up imports
+- [x] `floor_asm.gs.ts` - Removed and cleaned up imports
+- [x] `modf_noasm.gs.ts` - Removed and cleaned up imports
+- [x] `log_stub.gs.ts` - Removed and cleaned up imports
+
+### Update Index File
+- [x] Review `index.ts` to ensure all exports are correct
+- [x] Remove any imports from deleted files
+- [x] Verify all optimized functions are properly exported
+
+---
+
+## 📊 **PERFORMANCE IMPACT**
+
+### Estimated Improvements
+- **Bundle Size**: ~70% reduction in math module size
+- **Performance**: 2-5x faster for basic math operations
+- **Maintainability**: Significantly improved due to simpler implementations
+- **Memory Usage**: Reduced due to elimination of complex lookup tables
+
+### Functions with Potential Minor Precision Differences
+- `FMA()` - Uses simple `x * y + z` instead of true fused multiply-add
+- `Remainder()` - Uses `Math.round()` approach instead of complex bit manipulation
+- `Frexp()`, `Ldexp()` - May have slight precision differences in edge cases
+
+---
+
+## 🎯 **PRIORITY LEVELS**
+
+### High Priority (Performance Critical)
+- ✅ All basic math functions (completed)
+- ✅ Trigonometric functions (completed)
+- ✅ Exponential/logarithmic functions (completed)
+
+### Medium Priority (Cleanup)
+- ✅ Remove unused `*_noasm.gs.ts` and `*_asm.gs.ts` files
+- ✅ Update index.ts exports
+- ✅ Clean up imports in remaining files
+
+### Low Priority (Keep As-Is)
+- ✅ Complex mathematical functions (Bessel, Error, Gamma)
+- ✅ IEEE 754 bit manipulation functions
+- ✅ Architecture-specific optimizations
+
+---
+
+## ✅ **COMPLETION STATUS**
+
+**Overall Progress: 100% Complete**
+
+- ✅ **Basic Math Operations**: 100% optimized
+- ✅ **Trigonometric Functions**: 100% optimized  
+- ✅ **Exponential/Log Functions**: 100% optimized
+- ✅ **Utility Functions**: 100% optimized
+- ✅ **Floating-Point Manipulation**: 100% optimized
+- ✅ **Complex Mathematical Functions**: Intentionally kept as-is
+- ✅ **Cleanup Tasks**: Completed
+
+The math module optimization is **100% complete**. All performance-critical functions have been optimized with JavaScript-native implementations, unused files have been removed, and complex mathematical algorithms have been preserved as-is. 

package/gs/math/abs.gs.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest'
+import { Abs } from './abs.gs.js'
+
+describe('Abs', () => {
+  it('should return absolute value of positive numbers', () => {
+    expect(Abs(5)).toBe(5)
+    expect(Abs(3.14)).toBe(3.14)
+    expect(Abs(0)).toBe(0)
+  })
+
+  it('should return absolute value of negative numbers', () => {
+    expect(Abs(-5)).toBe(5)
+    expect(Abs(-3.14)).toBe(3.14)
+    expect(Abs(-0)).toBe(0)
+  })
+
+  it('should handle special values', () => {
+    expect(Abs(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Abs(Number.NEGATIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Number.isNaN(Abs(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Abs(Number.MAX_VALUE)).toBe(Number.MAX_VALUE)
+    expect(Abs(-Number.MAX_VALUE)).toBe(Number.MAX_VALUE)
+    expect(Abs(Number.MIN_VALUE)).toBe(Number.MIN_VALUE)
+    expect(Abs(-Number.MIN_VALUE)).toBe(Number.MIN_VALUE)
+  })
+}) 

package/gs/math/abs.gs.ts

@@ -0,0 +1,13 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Float64bits, Float64frombits } from "./unsafe.gs.js";
+
+// Abs returns the absolute value of x.
+//
+// Special cases are:
+//
+//	Abs(±Inf) = +Inf
+//	Abs(NaN) = NaN
+export function Abs(x: number): number {
+	return Math.abs(x)
+}
+

package/gs/math/acosh.gs.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest'
+import { Acosh, acosh } from './acosh.gs.js'
+
+describe('Acosh', () => {
+  it('should return correct inverse hyperbolic cosine values', () => {
+    expect(Acosh(1)).toBe(0)
+    expect(Acosh(Math.E)).toBeCloseTo(1.6574544541530771, 14)
+    expect(Acosh(2)).toBeCloseTo(1.3169578969248166, 14)
+    expect(Acosh(10)).toBeCloseTo(2.993222846126381, 14)
+  })
+
+  it('should return NaN for values less than 1', () => {
+    expect(Number.isNaN(Acosh(0.5))).toBe(true)
+    expect(Number.isNaN(Acosh(0))).toBe(true)
+    expect(Number.isNaN(Acosh(-1))).toBe(true)
+  })
+
+  it('should handle special values', () => {
+    expect(Acosh(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Number.isNaN(Acosh(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Acosh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    // For very large values, result should be very large but may not be exactly infinity
+    const result = Acosh(Number.MAX_VALUE)
+    expect(result > 700 || result === Number.POSITIVE_INFINITY).toBe(true)
+    expect(Number.isNaN(Acosh(Number.MIN_VALUE))).toBe(true)
+  })
+})
+
+describe('acosh', () => {
+  it('should work the same as Acosh', () => {
+    expect(acosh(1)).toBe(Acosh(1))
+    expect(acosh(2)).toBe(Acosh(2))
+    expect(acosh(10)).toBe(Acosh(10))
+    expect(acosh(Number.POSITIVE_INFINITY)).toBe(Acosh(Number.POSITIVE_INFINITY))
+  })
+}) 

package/gs/math/acosh.gs.ts

@@ -0,0 +1,21 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsNaN, NaN } from "./bits.gs.js";
+import { Log } from "./log.gs.js";
+import { Log1p } from "./log1p.gs.js";
+import { Sqrt } from "./sqrt.gs.js";
+
+// Acosh returns the inverse hyperbolic cosine of x.
+//
+// Special cases are:
+//
+//	Acosh(+Inf) = +Inf
+//	Acosh(x) = NaN if x < 1
+//	Acosh(NaN) = NaN
+export function Acosh(x: number): number {
+	return Math.acosh(x)
+}
+
+export function acosh(x: number): number {
+	return Math.acosh(x)
+}
+

package/gs/math/asin.gs.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { Asin, asin, Acos, acos } from './asin.gs.js'
+
+describe('Asin', () => {
+  it('should return correct arcsine values', () => {
+    expect(Asin(0)).toBe(0)
+    expect(Asin(1)).toBeCloseTo(1.5707963267948966, 15)
+    expect(Asin(-1)).toBeCloseTo(-1.5707963267948966, 15)
+    expect(Asin(0.5)).toBeCloseTo(0.5235987755982988, 15)
+    expect(Asin(-0.5)).toBeCloseTo(-0.5235987755982988, 15)
+  })
+
+  it('should return NaN for values outside [-1, 1]', () => {
+    expect(Number.isNaN(Asin(1.1))).toBe(true)
+    expect(Number.isNaN(Asin(-1.1))).toBe(true)
+    expect(Number.isNaN(Asin(2))).toBe(true)
+    expect(Number.isNaN(Asin(-2))).toBe(true)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Asin(Number.NaN))).toBe(true)
+    expect(Number.isNaN(Asin(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Asin(Number.NEGATIVE_INFINITY))).toBe(true)
+  })
+})
+
+describe('asin', () => {
+  it('should work the same as Asin', () => {
+    expect(asin(0)).toBe(Asin(0))
+    expect(asin(1)).toBe(Asin(1))
+    expect(asin(-1)).toBe(Asin(-1))
+    expect(asin(0.5)).toBe(Asin(0.5))
+  })
+})
+
+describe('Acos', () => {
+  it('should return correct arccosine values', () => {
+    expect(Acos(1)).toBe(0)
+    expect(Acos(0)).toBeCloseTo(1.5707963267948966, 15)
+    expect(Acos(-1)).toBeCloseTo(3.141592653589793, 15)
+    expect(Acos(0.5)).toBeCloseTo(1.0471975511965976, 15)
+    expect(Acos(-0.5)).toBeCloseTo(2.0943951023931953, 15)
+  })
+
+  it('should return NaN for values outside [-1, 1]', () => {
+    expect(Number.isNaN(Acos(1.1))).toBe(true)
+    expect(Number.isNaN(Acos(-1.1))).toBe(true)
+    expect(Number.isNaN(Acos(2))).toBe(true)
+    expect(Number.isNaN(Acos(-2))).toBe(true)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Acos(Number.NaN))).toBe(true)
+    expect(Number.isNaN(Acos(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Acos(Number.NEGATIVE_INFINITY))).toBe(true)
+  })
+})
+
+describe('acos', () => {
+  it('should work the same as Acos', () => {
+    expect(acos(0)).toBe(Acos(0))
+    expect(acos(1)).toBe(Acos(1))
+    expect(acos(-1)).toBe(Acos(-1))
+    expect(acos(0.5)).toBe(Acos(0.5))
+  })
+}) 

package/gs/math/asin.gs.ts

@@ -0,0 +1,27 @@
+// Asin returns the arcsine, in radians, of x.
+//
+// Special cases are:
+//
+//	Asin(±0) = ±0
+//	Asin(x) = NaN if x < -1 or x > 1
+export function Asin(x: number): number {
+	return Math.asin(x)
+}
+
+export function asin(x: number): number {
+	return Math.asin(x)
+}
+
+// Acos returns the arccosine, in radians, of x.
+//
+// Special case is:
+//
+//	Acos(x) = NaN if x < -1 or x > 1
+export function Acos(x: number): number {
+	return Math.acos(x)
+}
+
+export function acos(x: number): number {
+	return Math.acos(x)
+}
+

package/gs/math/asinh.gs.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest'
+import { Asinh, asinh } from './asinh.gs.js'
+
+describe('Asinh', () => {
+  it('should return correct inverse hyperbolic sine values', () => {
+    expect(Asinh(0)).toBe(0)
+    expect(Asinh(-0)).toBe(-0)
+    expect(Asinh(1)).toBeCloseTo(0.8813735870195429, 14)
+    expect(Asinh(-1)).toBeCloseTo(-0.8813735870195429, 14)
+    expect(Asinh(2)).toBeCloseTo(1.4436354751788103, 14)
+    expect(Asinh(-2)).toBeCloseTo(-1.4436354751788103, 14)
+  })
+
+  it('should handle special values', () => {
+    expect(Asinh(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Asinh(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Asinh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    // For very large values, result should be very large but may not be exactly infinity
+    const resultPos = Asinh(Number.MAX_VALUE)
+    expect(resultPos > 700 || resultPos === Number.POSITIVE_INFINITY).toBe(true)
+    const resultNeg = Asinh(-Number.MAX_VALUE)
+    expect(resultNeg < -700 || resultNeg === Number.NEGATIVE_INFINITY).toBe(true)
+    expect(Asinh(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 14)
+  })
+})
+
+describe('asinh', () => {
+  it('should work the same as Asinh', () => {
+    expect(asinh(0)).toBe(Asinh(0))
+    expect(asinh(1)).toBe(Asinh(1))
+    expect(asinh(-1)).toBe(Asinh(-1))
+    expect(asinh(Number.POSITIVE_INFINITY)).toBe(Asinh(Number.POSITIVE_INFINITY))
+  })
+})