goscript 0.0.34 → 0.0.36

package/gs/math/tan.gs.ts

@@ -0,0 +1,23 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { trigReduce } from "./trig_reduce.gs.js";
+
+let _tanP = $.arrayToSlice<number>([-1.30936939181383777646e4, 1.15351664838587416140e6, -1.79565251976484877988e7])
+
+let _tanQ = $.arrayToSlice<number>([1.00000000000000000000e0, 1.36812963470692954678e4, -1.32089234440210967447e6, 2.50083801823357915839e7, -5.38695755929454629881e7])
+
+// Tan returns the tangent of the radian argument x.
+//
+// Special cases are:
+//
+//	Tan(±0) = ±0
+//	Tan(±Inf) = NaN
+//	Tan(NaN) = NaN
+export function Tan(x: number): number {
+	return Math.tan(x)
+}
+
+export function tan(x: number): number {
+	return Math.tan(x)
+}
+

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

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest'
+import { Tanh, tanh } from './tanh.gs.js'
+
+describe('Tanh', () => {
+  it('should return correct hyperbolic tangent values', () => {
+    expect(Tanh(0)).toBe(0)
+    expect(Tanh(-0)).toBe(-0)
+    expect(Tanh(1)).toBeCloseTo(0.7615941559557649, 14)
+    expect(Tanh(-1)).toBeCloseTo(-0.7615941559557649, 14)
+    expect(Tanh(2)).toBeCloseTo(0.9640275800758169, 14)
+    expect(Tanh(-2)).toBeCloseTo(-0.9640275800758169, 15)
+  })
+
+  it('should approach ±1 for large values', () => {
+    // Relax tolerance for large values due to JavaScript precision limits
+    expect(Tanh(10)).toBeCloseTo(1, 8)
+    expect(Tanh(-10)).toBeCloseTo(-1, 8)
+    expect(Tanh(100)).toBeCloseTo(1, 8)
+    expect(Tanh(-100)).toBeCloseTo(-1, 8)
+  })
+
+  it('should handle special values', () => {
+    expect(Tanh(Number.POSITIVE_INFINITY)).toBe(1)
+    expect(Tanh(Number.NEGATIVE_INFINITY)).toBe(-1)
+    expect(Number.isNaN(Tanh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Tanh(Number.MAX_VALUE)).toBe(1)
+    expect(Tanh(-Number.MAX_VALUE)).toBe(-1)
+    expect(Tanh(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 14)
+    expect(Tanh(-Number.MIN_VALUE)).toBeCloseTo(-Number.MIN_VALUE, 14)
+  })
+
+  it('should be bounded between -1 and 1', () => {
+    const testValues = [-100, -10, -1, -0.5, 0, 0.5, 1, 10, 100]
+    for (const x of testValues) {
+      const result = Tanh(x)
+      expect(result).toBeGreaterThanOrEqual(-1)
+      expect(result).toBeLessThanOrEqual(1)
+    }
+  })
+})
+
+describe('tanh', () => {
+  it('should work the same as Tanh', () => {
+    expect(tanh(0)).toBe(Tanh(0))
+    expect(tanh(1)).toBe(Tanh(1))
+    expect(tanh(-1)).toBe(Tanh(-1))
+    expect(tanh(Number.POSITIVE_INFINITY)).toBe(Tanh(Number.POSITIVE_INFINITY))
+  })
+}) 

package/gs/math/tanh.gs.ts

@@ -0,0 +1,23 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Abs } from "./abs.gs.js";
+import { Exp } from "./exp.gs.js";
+
+let tanhP = $.arrayToSlice<number>([-9.64399179425052238628e-1, -9.92877231001918586564e1, -1.61468768441708447952e3])
+
+let tanhQ = $.arrayToSlice<number>([1.12811678491632931402e2, 2.23548839060100448583e3, 4.84406305325125486048e3])
+
+// Tanh returns the hyperbolic tangent of x.
+//
+// Special cases are:
+//
+//	Tanh(±0) = ±0
+//	Tanh(±Inf) = ±1
+//	Tanh(NaN) = NaN
+export function Tanh(x: number): number {
+	return Math.tanh(x)
+}
+
+export function tanh(x: number): number {
+	return Math.tanh(x)
+}
+

package/gs/math/trig_reduce.gs.ts

@@ -0,0 +1,66 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Float64bits, Float64frombits } from "./unsafe.gs.js";
+
+import * as bits from "@goscript/math/bits/index.js"
+
+let reduceThreshold: number = (1 << 29)
+
+// trigReduce implements Payne-Hanek range reduction by Pi/4
+// for x > 0. It returns the integer part mod 8 (j) and
+// the fractional part (z) of x / (Pi/4).
+// The implementation is based on:
+// "ARGUMENT REDUCTION FOR HUGE ARGUMENTS: Good to the Last Bit"
+// K. C. Ng et al, March 24, 1992
+// The simulated multi-precision calculation of x*B uses 64-bit integer arithmetic.
+export function trigReduce(x: number): [number, number] {
+	let j: number = 0
+	let z: number = 0
+	{
+		let PI4: number = 3.14159 / 4
+		if (x < 0.785398) {
+			return [0, x]
+		}
+		// Extract out the integer and exponent such that,
+		// x = ix * 2 ** exp.
+		let ix = Float64bits(x)
+		let exp = $.int(((ix >> 52) & 2047)) - 1023 - 52
+		ix &= ~(2047 << 52)
+		ix |= (1 << 52)
+		// Use the exponent to extract the 3 appropriate uint64 digits from mPi4,
+		// B ~ (z0, z1, z2), such that the product leading digit has the exponent -61.
+		// Note, exp >= -53 since x >= PI4 and exp < 971 for maximum float64.
+		let [digit, bitshift] = [$.int((exp + 61) / 64), (exp + 61) % 64]
+		let z0 = (((mPi4![digit] << bitshift)) | ((mPi4![digit + 1] >> (64 - bitshift))))
+		let z1 = (((mPi4![digit + 1] << bitshift)) | ((mPi4![digit + 2] >> (64 - bitshift))))
+		let z2 = (((mPi4![digit + 2] << bitshift)) | ((mPi4![digit + 3] >> (64 - bitshift))))
+		// Multiply mantissa by the digits and extract the upper two digits (hi, lo).
+		let [z2hi, ] = bits.Mul64(BigInt(z2), BigInt(ix))
+		let [z1hi, z1lo] = bits.Mul64(BigInt(z1), BigInt(ix))
+		let z0lo = BigInt(z0 * ix)
+		let [lo, c] = bits.Add64(z1lo, z2hi, 0n)
+		let [hi, ] = bits.Add64(z0lo, z1hi, c)
+		// The top 3 bits are j.
+		j = Number(hi >> 61n)
+		// Extract the fraction and find its magnitude.
+		hi = ((hi << 3n) | (lo >> 61n))
+		let lz = bits.LeadingZeros64(hi)
+		let e = 1023 - (lz + 1)
+		// Clear implicit mantissa bit and shift into place.
+		hi = (((hi << BigInt(lz + 1))) | ((lo >> BigInt(64 - (lz + 1)))))
+		hi >>= 64n - 52n
+		// Include the exponent and convert to a float.
+		hi |= BigInt(e) << 52n
+		z = Float64frombits(Number(hi))
+		// Map zeros to origin.
+		if ((j & 1) == 1) {
+			j++
+			j &= 7
+			z--
+		}
+		// Multiply the fractional part by pi/4.
+		return [j, z * 0.785398]
+	}
+}
+
+let mPi4 = $.arrayToSlice<number>([0x0000000000000001, 0x45f306dc9c882a53, 0xf84eafa3ea69bb81, 0xb6c52b3278872083, 0xfca2c757bd778ac3, 0x6e48dc74849ba5c0, 0x0c925dd413a32439, 0xfc3bd63962534e7d, 0xd1046bea5d768909, 0xd338e04d68befc82, 0x7323ac7306a673e9, 0x3908bf177bf25076, 0x3ff12fffbc0b301f, 0xde5e2316b414da3e, 0xda6cfd9e4f96136e, 0x9e8c7ecd3cbfd45a, 0xea4f758fd7cbe2f6, 0x7a0e73ef14a525d4, 0xd7f6bf623f1aba10, 0xac06608df8f6d757])
+

package/gs/math/unsafe.gs.ts

@@ -0,0 +1,52 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// Float32bits returns the IEEE 754 binary representation of f,
+// with the sign bit of f and the result in the same bit position.
+// Float32bits(Float32frombits(x)) == x.
+export function Float32bits(f: number): number {
+	const buffer = new ArrayBuffer(4);
+	const view = new DataView(buffer);
+	view.setFloat32(0, f, true); // little endian
+	return view.getUint32(0, true);
+}
+
+// Float32frombits returns the floating-point number corresponding
+// to the IEEE 754 binary representation b, with the sign bit of b
+// and the result in the same bit position.
+// Float32frombits(Float32bits(x)) == x.
+export function Float32frombits(b: number): number {
+	const buffer = new ArrayBuffer(4);
+	const view = new DataView(buffer);
+	view.setUint32(0, b, true); // little endian
+	return view.getFloat32(0, true);
+}
+
+// Float64bits returns the IEEE 754 binary representation of f,
+// with the sign bit of f and the result in the same bit position,
+// and Float64bits(Float64frombits(x)) == x.
+export function Float64bits(f: number): number {
+	const buffer = new ArrayBuffer(8);
+	const view = new DataView(buffer);
+	view.setFloat64(0, f, true); // little endian
+	// JavaScript numbers are limited to 53-bit precision, so we need to handle this carefully
+	const low = view.getUint32(0, true);
+	const high = view.getUint32(4, true);
+	// Combine into a single number (may lose precision for very large values)
+	return high * 0x100000000 + low;
+}
+
+// Float64frombits returns the floating-point number corresponding
+// to the IEEE 754 binary representation b, with the sign bit of b
+// and the result in the same bit position.
+// Float64frombits(Float64bits(x)) == x.
+export function Float64frombits(b: number): number {
+	const buffer = new ArrayBuffer(8);
+	const view = new DataView(buffer);
+	// Split the number into high and low 32-bit parts
+	const low = b & 0xFFFFFFFF;
+	const high = Math.floor(b / 0x100000000);
+	view.setUint32(0, low, true); // little endian
+	view.setUint32(4, high, true);
+	return view.getFloat64(0, true);
+}
+

package/gs/strconv/atob.gs.ts

@@ -0,0 +1,45 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { syntaxError } from "./atoi.gs.js";
+
+// ParseBool returns the boolean value represented by the string.
+// It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
+// Any other value returns an error.
+export function ParseBool(str: string): [boolean, $.GoError] {
+	switch (str) {
+		case "1":
+		case "t":
+		case "T":
+		case "true":
+		case "TRUE":
+		case "True":
+			return [true, null]
+			break
+		case "0":
+		case "f":
+		case "F":
+		case "false":
+		case "FALSE":
+		case "False":
+			return [false, null]
+			break
+	}
+	return [false, syntaxError("ParseBool", str)]
+}
+
+// FormatBool returns "true" or "false" according to the value of b.
+export function FormatBool(b: boolean): string {
+	if (b) {
+		return "true"
+	}
+	return "false"
+}
+
+// AppendBool appends "true" or "false", according to the value of b,
+// to dst and returns the extended buffer.
+export function AppendBool(dst: $.Bytes, b: boolean): $.Bytes {
+	if (b) {
+		return $.append(dst, ...$.stringToBytes("true"))
+	}
+	return $.append(dst, ...$.stringToBytes("false"))
+}
+

package/gs/strconv/atof.gs.ts

@@ -0,0 +1,60 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrSyntax, ErrRange, NumError } from "./atoi.gs.js";
+
+// ParseFloat converts the string s to a floating-point number
+// with the precision specified by bitSize: 32 for float32, or 64 for float64.
+// When bitSize=32, the result still has type float64, but it will be
+// convertible to float32 without changing its value.
+export function ParseFloat(s: string, bitSize: number): [number, $.GoError] {
+	if (s === "") {
+		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+	}
+
+	// Validate bitSize
+	if (bitSize !== 32 && bitSize !== 64) {
+		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+	}
+
+	// Handle special cases
+	const lower = s.toLowerCase();
+	switch (lower) {
+		case "+inf":
+		case "inf":
+		case "+infinity":
+		case "infinity":
+			return [Infinity, null];
+		case "-inf":
+		case "-infinity":
+			return [-Infinity, null];
+		case "nan":
+			return [NaN, null];
+	}
+
+	// Remove underscores if present (Go allows them in numeric literals)
+	let cleanS = s;
+	if (s.includes('_')) {
+		cleanS = s.replace(/_/g, '');
+	}
+
+	// Use JavaScript's parseFloat
+	const result = parseFloat(cleanS);
+	
+	if (isNaN(result)) {
+		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+	}
+
+	// Check for range errors based on bitSize
+	if (bitSize === 32) {
+		const maxFloat32 = 3.4028234663852886e+38;
+		const minFloat32 = 1.175494351e-38;
+		
+		if (isFinite(result) && Math.abs(result) > maxFloat32) {
+			return [result > 0 ? Infinity : -Infinity, new NumError({Func: "ParseFloat", Num: s, Err: ErrRange})];
+		}
+		if (isFinite(result) && result !== 0 && Math.abs(result) < minFloat32) {
+			return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrRange})];
+		}
+	}
+
+	return [result, null];
+} 

package/gs/strconv/atoi.gs.ts

@@ -0,0 +1,243 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import * as errors from "@goscript/errors/index.js";
+
+export let ErrRange: $.GoError = errors.New("value out of range");
+export let ErrSyntax: $.GoError = errors.New("invalid syntax");
+
+export class NumError {
+	// the failing function (ParseBool, ParseInt, ParseUint, ParseFloat, ParseComplex)
+	public get Func(): string {
+		return this._fields.Func.value;
+	}
+	public set Func(value: string) {
+		this._fields.Func.value = value;
+	}
+
+	// the input
+	public get Num(): string {
+		return this._fields.Num.value;
+	}
+	public set Num(value: string) {
+		this._fields.Num.value = value;
+	}
+
+	// the reason the conversion failed (e.g. ErrRange, ErrSyntax, etc.)
+	public get Err(): $.GoError {
+		return this._fields.Err.value;
+	}
+	public set Err(value: $.GoError) {
+		this._fields.Err.value = value;
+	}
+
+	public _fields: {
+		Func: $.VarRef<string>;
+		Num: $.VarRef<string>;
+		Err: $.VarRef<$.GoError>;
+	}
+
+	constructor(init?: Partial<{Err?: $.GoError, Func?: string, Num?: string}>) {
+		this._fields = {
+			Func: $.varRef(init?.Func ?? ""),
+			Num: $.varRef(init?.Num ?? ""),
+			Err: $.varRef(init?.Err ?? null)
+		};
+	}
+
+	public clone(): NumError {
+		const cloned = new NumError();
+		cloned._fields = {
+			Func: $.varRef(this._fields.Func.value),
+			Num: $.varRef(this._fields.Num.value),
+			Err: $.varRef(this._fields.Err.value)
+		};
+		return cloned;
+	}
+
+	public Error(): string {
+		const e = this;
+		return "strconv." + e.Func + ": " + "parsing " + JSON.stringify(e.Num) + ": " + e.Err!.Error();
+	}
+
+	public Unwrap(): $.GoError {
+		const e = this;
+		return e.Err;
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+		'NumError',
+		new NumError(),
+		[{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
+		NumError,
+		{"Func": { kind: $.TypeKind.Basic, name: "string" }, "Num": { kind: $.TypeKind.Basic, name: "string" }, "Err": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }}
+	);
+}
+
+export function syntaxError(fn: string, str: string): NumError {
+	return new NumError({Func: fn, Num: str, Err: ErrSyntax});
+}
+
+export function rangeError(fn: string, str: string): NumError {
+	return new NumError({Func: fn, Num: str, Err: ErrRange});
+}
+
+export function baseError(fn: string, str: string, base: number): NumError {
+	return new NumError({Func: fn, Num: str, Err: errors.New("invalid base " + base)});
+}
+
+export function bitSizeError(fn: string, str: string, bitSize: number): NumError {
+	return new NumError({Func: fn, Num: str, Err: errors.New("invalid bit size " + bitSize)});
+}
+
+export let IntSize: number = 64;
+
+// lower(c) is a lower-case letter if and only if
+// c is either that lower-case letter or the equivalent upper-case letter.
+function lower(c: number): number {
+	return (c | (120 - 88));
+}
+
+// ParseUint is like ParseInt but for unsigned numbers.
+// A sign prefix is not permitted.
+export function ParseUint(s: string, base: number, bitSize: number): [number, $.GoError] {
+	if (s === "") {
+		return [0, syntaxError("ParseUint", s)];
+	}
+
+	const base0 = base === 0;
+	const s0 = s;
+
+	// Handle base validation
+	if (base < 0 || base === 1 || base > 36) {
+		return [0, baseError("ParseUint", s0, base)];
+	}
+
+	// Handle base inference
+	if (base === 0) {
+		base = 10;
+		if (s.length >= 3) {
+			if (s[0] === '0') {
+				const prefix = s[1].toLowerCase();
+				if (prefix === 'b') {
+					base = 2;
+					s = s.slice(2);
+				} else if (prefix === 'o') {
+					base = 8;
+					s = s.slice(2);
+				} else if (prefix === 'x') {
+					base = 16;
+					s = s.slice(2);
+				} else {
+					base = 8;
+					s = s.slice(1);
+				}
+			}
+		} else if (s.length >= 2 && s[0] === '0') {
+			base = 8;
+			s = s.slice(1);
+		}
+	}
+
+	// Validate bitSize
+	if (bitSize === 0) {
+		bitSize = 64;
+	} else if (bitSize < 0 || bitSize > 64) {
+		return [0, bitSizeError("ParseUint", s0, bitSize)];
+	}
+
+	// Check for underscores only if base0 (auto-detected base)
+	if (base0 && s.includes('_')) {
+		if (!underscoreOK(s)) {
+			return [0, syntaxError("ParseUint", s0)];
+		}
+		s = s.replace(/_/g, '');
+	}
+
+	// Use JavaScript's parseInt
+	const result = parseInt(s, base);
+	
+	if (isNaN(result) || !isFinite(result)) {
+		return [0, syntaxError("ParseUint", s0)];
+	}
+
+	if (result < 0) {
+		return [0, syntaxError("ParseUint", s0)];
+	}
+
+	// Check range for the specified bit size
+	const maxVal = (1 << bitSize) - 1;
+	if (result > maxVal) {
+		return [0, rangeError("ParseUint", s0)];
+	}
+
+	return [result, null];
+}
+
+// ParseInt interprets a string s in the given base (0, 2 to 36) and
+// bit size (0 to 64) and returns the corresponding value i.
+export function ParseInt(s: string, base: number, bitSize: number): [number, $.GoError] {
+	if (s === "") {
+		return [0, syntaxError("ParseInt", s)];
+	}
+
+	let neg = false;
+	if (s[0] === '+' || s[0] === '-') {
+		neg = s[0] === '-';
+		s = s.slice(1);
+		if (s.length < 1) {
+			return [0, syntaxError("ParseInt", s)];
+		}
+	}
+
+	// Convert to unsigned first
+	const [un, err] = ParseUint(s, base, bitSize);
+	if (err !== null) {
+		const numErr = err as NumError;
+		numErr.Func = "ParseInt";
+		return [0, err];
+	}
+
+	if (bitSize === 0) {
+		bitSize = 64;
+	}
+
+	const cutoff = 1 << (bitSize - 1);
+	if (!neg && un >= cutoff) {
+		return [0, rangeError("ParseInt", s)];
+	}
+	if (neg && un > cutoff) {
+		return [0, rangeError("ParseInt", s)];
+	}
+
+	const result = neg ? -un : un;
+	return [result, null];
+}
+
+// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
+export function Atoi(s: string): [number, $.GoError] {
+	const [i64, err] = ParseInt(s, 10, 0);
+	return [i64, err];
+}
+
+// underscoreOK reports whether the underscores in s are allowed.
+function underscoreOK(s: string): boolean {
+	// Simplified validation for underscores
+	if (s.length === 0) {
+		return false;
+	}
+	
+	// Can't start or end with underscore
+	if (s[0] === '_' || s[s.length - 1] === '_') {
+		return false;
+	}
+	
+	// Can't have consecutive underscores
+	for (let i = 0; i < s.length - 1; i++) {
+		if (s[i] === '_' && s[i + 1] === '_') {
+			return false;
+		}
+	}
+	
+	return true;
+}
+

package/gs/strconv/doc.gs.ts

@@ -0,0 +1,2 @@
+import * as $ from "@goscript/builtin/builtin.js";
+

package/gs/strconv/ftoa.gs.ts

@@ -0,0 +1,66 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// FormatFloat converts the floating-point number f to a string,
+// according to the format fmt and precision prec. It rounds the
+// result assuming that the original was obtained from a floating-point
+// value of bitSize bits (32 for float32, 64 for float64).
+export function FormatFloat(f: number, fmt: number, prec: number, bitSize: number): string {
+	const fmtChar = String.fromCharCode(fmt);
+	
+	// Handle special cases
+	if (isNaN(f)) {
+		return "NaN";
+	}
+	if (f === Infinity) {
+		return "+Inf";
+	}
+	if (f === -Infinity) {
+		return "-Inf";
+	}
+	
+	// Convert to appropriate precision for float32
+	if (bitSize === 32) {
+		f = Math.fround(f);
+	}
+	
+	switch (fmtChar.toLowerCase()) {
+		case 'e':
+			// Exponential notation
+			if (prec < 0) {
+				return f.toExponential();
+			}
+			return f.toExponential(prec);
+			
+		case 'f':
+			// Fixed-point notation
+			if (prec < 0) {
+				return f.toString();
+			}
+			return f.toFixed(prec);
+			
+		case 'g':
+			// Use the more compact of 'e' or 'f'
+			if (prec < 0) {
+				return f.toPrecision();
+			}
+			return f.toPrecision(prec + 1);
+			
+		case 'x':
+			// Hexadecimal notation (simplified)
+			return f.toString(16);
+			
+		default:
+			// Default to 'g' format
+			if (prec < 0) {
+				return f.toString();
+			}
+			return f.toPrecision(prec + 1);
+	}
+}
+
+// AppendFloat appends the string form of the floating-point number f,
+// as generated by FormatFloat, to dst and returns the extended buffer.
+export function AppendFloat(dst: $.Bytes, f: number, fmt: number, prec: number, bitSize: number): $.Bytes {
+	const str = FormatFloat(f, fmt, prec, bitSize);
+	return $.append(dst, ...$.stringToBytes(str)!);
+} 

package/gs/strconv/index.ts

@@ -0,0 +1,6 @@
+export { AppendBool, FormatBool, ParseBool } from "./atob.gs.js"
+export { ParseFloat } from "./atof.gs.js"
+export { Atoi, ErrRange, ErrSyntax, IntSize, NumError, ParseInt, ParseUint } from "./atoi.gs.js"
+export { AppendFloat, FormatFloat } from "./ftoa.gs.js"
+export { AppendInt, AppendUint, FormatInt, FormatUint, Itoa } from "./itoa.gs.js"
+export { AppendQuote, AppendQuoteRune, AppendQuoteRuneToASCII, AppendQuoteRuneToGraphic, AppendQuoteToASCII, AppendQuoteToGraphic, CanBackquote, IsGraphic, IsPrint, Quote, QuoteRune, QuoteRuneToASCII, QuoteRuneToGraphic, QuoteToASCII, QuoteToGraphic, QuotedPrefix, Unquote, UnquoteChar } from "./quote.gs.js"

package/gs/strconv/itoa.gs.ts

@@ -0,0 +1,41 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// FormatUint returns the string representation of i in the given base,
+// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
+// for digit values >= 10.
+export function FormatUint(i: number, base: number): string {
+	if (base < 2 || base > 36) {
+		throw new Error("FormatUint: illegal base");
+	}
+	// JavaScript's toString() handles bases 2-36 natively
+	return Math.floor(Math.abs(i)).toString(base);
+}
+
+// FormatInt returns the string representation of i in the given base,
+// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
+// for digit values >= 10.
+export function FormatInt(i: number, base: number): string {
+	if (base < 2 || base > 36) {
+		throw new Error("FormatInt: illegal base");
+	}
+	return Math.floor(i).toString(base);
+}
+
+// Itoa is equivalent to FormatInt(i, 10).
+export function Itoa(i: number): string {
+	return FormatInt(i, 10);
+}
+
+// AppendInt appends the string form of the integer i,
+// as generated by FormatInt, to dst and returns the extended buffer.
+export function AppendInt(dst: $.Bytes, i: number, base: number): $.Bytes {
+	const str = FormatInt(i, base);
+	return $.append(dst, ...$.stringToBytes(str)!);
+}
+
+// AppendUint appends the string form of the unsigned integer i,
+// as generated by FormatUint, to dst and returns the extended buffer.
+export function AppendUint(dst: $.Bytes, i: number, base: number): $.Bytes {
+	const str = FormatUint(i, base);
+	return $.append(dst, ...$.stringToBytes(str)!);
+}