goscript 0.0.22 → 0.0.24

package/compiler/expr.go

@@ -11,10 +11,35 @@ import (
 
 // WriteIndexExpr translates a Go index expression (a[b]) to its TypeScript equivalent.
 func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
+	// Check if this might be a generic function instantiation with a single type argument
+	// In this case, the Index should be a type expression, not a value expression
+	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
+		// If X is a function type, this might be generic instantiation
+		if _, isFuncType := tv.Type.Underlying().(*types.Signature); isFuncType {
+			// Check if the index is a type expression (identifier that refers to a type)
+			if indexIdent, isIdent := exp.Index.(*ast.Ident); isIdent {
+				// Check if this identifier refers to a type
+				if obj := c.pkg.TypesInfo.Uses[indexIdent]; obj != nil {
+					if _, isTypeName := obj.(*types.TypeName); isTypeName {
+						// This is a generic function instantiation: f[T] -> f<T>
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("<")
+						c.WriteTypeExpr(exp.Index)
+						c.tsw.WriteLiterally(">")
+						return nil
+					}
+				}
+			}
+		}
+	}
+
 	// Handle map access: use Map.get() instead of brackets for reading values
 	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
+		underlyingType := tv.Type.Underlying()
 		// Check if it's a map type
-		if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+		if mapType, isMap := underlyingType.(*types.Map); isMap {
 			c.tsw.WriteLiterally("$.mapGet(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return err
@@ -30,6 +55,36 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			c.tsw.WriteLiterally(")")
 			return nil
 		}
+
+		// Check if it's a string type
+		if basicType, isBasic := underlyingType.(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+			c.tsw.WriteLiterally("$.indexString(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(")")
+			return nil
+		}
+
+		// Check if it's a type parameter with a union constraint (e.g., string | []byte)
+		if _, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+			// For type parameters with string | []byte constraint, use specialized function
+			// that returns number (byte value) for better TypeScript typing
+			c.tsw.WriteLiterally("$.indexStringOrBytes(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(")")
+			return nil
+		}
 	}
 
 	// Regular array/slice access: use brackets
@@ -44,6 +99,26 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 	return nil
 }
 
+// WriteIndexListExpr translates a Go generic function instantiation (f[T1, T2]) to its TypeScript equivalent (f<T1, T2>).
+func (c *GoToTSCompiler) WriteIndexListExpr(exp *ast.IndexListExpr) error {
+	// Write the function expression
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return err
+	}
+
+	// Write the type arguments using TypeScript syntax
+	c.tsw.WriteLiterally("<")
+	for i, typeArg := range exp.Indices {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.WriteTypeExpr(typeArg)
+	}
+	c.tsw.WriteLiterally(">")
+
+	return nil
+}
+
 // WriteTypeAssertExpr translates a Go type assertion expression (e.g., `x.(T)`)
 // into a TypeScript call to `$.typeAssert<T_ts>(x_ts, 'TypeName').value`.
 // The `$.typeAssert` runtime function handles the actual type check and panic
@@ -52,7 +127,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 // by the runtime for error messages.
 func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 	// Generate a call to $.typeAssert
-	c.tsw.WriteLiterally("$.typeAssert<")
+	c.tsw.WriteLiterally("$.mustTypeAssert<")
 	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
 	c.tsw.WriteLiterally(">(")
 	if err := c.WriteValueExpr(exp.X); err != nil { // The interface expression
@@ -60,9 +135,6 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 	}
 	c.tsw.WriteLiterally(", ")
 
-	// Write the type description instead of just the type name
-	// This ensures we generate proper type info objects for all types
-
 	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
 	typeExpr := exp.Type
 	for {
@@ -75,7 +147,8 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 
 	c.writeTypeDescription(typeExpr)
 
-	c.tsw.WriteLiterally(")") // Just close the parenthesis, don't access .value directly
+	c.tsw.WriteLiterally(")")
+
 	return nil
 }
 
@@ -84,7 +157,7 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 // of the left (X) and right (Y) operands of the binary expression.
 // Returns `true` if both operands are determined to be pointer types,
 // `false` otherwise. This is used to apply specific comparison semantics
-// for pointers (e.g., comparing the box objects directly).
+// for pointers (e.g., comparing the varRef objects directly).
 func (c *GoToTSCompiler) isPointerComparison(exp *ast.BinaryExpr) bool {
 	leftType := c.pkg.TypesInfo.TypeOf(exp.X)
 	rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
@@ -122,10 +195,10 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 // It handles several cases:
 //   - Channel send (`ch <- val`): Becomes `await ch.send(val)`.
 //   - Nil comparison for pointers (`ptr == nil` or `ptr != nil`): Compares the
-//     pointer (which may be a box object or `null`) directly to `null` using
+//     pointer (which may be a varRef object or `null`) directly to `null` using
 //     the translated operator (`==` or `!=`).
 //   - Pointer comparison (non-nil, `ptr1 == ptr2` or `ptr1 != ptr2`): Compares
-//     the box objects directly using strict equality (`===` or `!==`).
+//     the varRef objects directly using strict equality (`===` or `!==`).
 //   - Bitwise operations (`&`, `|`, `^`, `<<`, `>>`, `&^`): The expression is wrapped
 //     in parentheses `()` to ensure correct precedence in TypeScript, and operators
 //     are mapped (e.g., `&^` might need special handling or is mapped to a runtime helper).
@@ -137,12 +210,12 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	// Handle special cases like channel send
 	if exp.Op == token.ARROW {
-		// Channel send: ch <- val becomes await ch.send(val)
-		c.tsw.WriteLiterally("await ")
+		// Channel send: ch <- val becomes await $.chanSend(ch, val)
+		c.tsw.WriteLiterally("await $.chanSend(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write channel send target: %w", err)
 		}
-		c.tsw.WriteLiterally(".send(")
+		c.tsw.WriteLiterally(", ")
 		if err := c.WriteValueExpr(exp.Y); err != nil {
 			return fmt.Errorf("failed to write channel send value: %w", err)
 		}
@@ -170,9 +243,26 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	}
 
 	if isNilComparison {
-		// Compare the box object directly to null
-		if err := c.WriteValueExpr(ptrExpr); err != nil {
-			return fmt.Errorf("failed to write pointer expression in nil comparison: %w", err)
+		// For nil comparisons, we need to decide whether to write .value or not
+		// If the pointer variable is varrefed, we need to access .value
+		if ident, ok := ptrExpr.(*ast.Ident); ok {
+			if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+				if c.analysis.NeedsVarRef(obj) {
+					// Variable is varrefed, so we need to access .value
+					c.WriteIdent(ident, true) // This will add .value
+				} else {
+					// Variable is not varrefed, write directly
+					c.WriteIdent(ident, false)
+				}
+			} else {
+				// No object info, write directly
+				c.WriteIdent(ident, false)
+			}
+		} else {
+			// For other expressions, use WriteValueExpr (but this might need review)
+			if err := c.WriteValueExpr(ptrExpr); err != nil {
+				return fmt.Errorf("failed to write pointer expression in nil comparison: %w", err)
+			}
 		}
 		c.tsw.WriteLiterally(" ")
 		tokStr, ok := TokenToTs(exp.Op)
@@ -185,7 +275,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	}
 
 	// Check if this is a pointer comparison (non-nil)
-	// Compare the box objects directly using === or !==
+	// Compare the varRef objects directly using === or !==
 	if c.isPointerComparison(exp) {
 		c.tsw.WriteLiterally("(") // Wrap comparison
 		if err := c.WriteValueExpr(exp.X); err != nil {
@@ -211,6 +301,50 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		return nil
 	}
 
+	// Check for Duration arithmetic operations (multiplication)
+	if exp.Op == token.MUL && c.pkg != nil && c.pkg.TypesInfo != nil {
+		leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+		rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+
+		// Check if left operand is a Duration type (from time package)
+		if leftType != nil {
+			if namedType, ok := leftType.(*types.Named); ok {
+				if namedType.Obj().Pkg() != nil && namedType.Obj().Pkg().Path() == "time" && namedType.Obj().Name() == "Duration" {
+					// Duration * number -> Duration.multiply(duration, number)
+					c.tsw.WriteLiterally("$.multiplyDuration(")
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write Duration in multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(", ")
+					if err := c.WriteValueExpr(exp.Y); err != nil {
+						return fmt.Errorf("failed to write multiplier in Duration multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(")")
+					return nil
+				}
+			}
+		}
+
+		// Check if right operand is a Duration type (number * Duration)
+		if rightType != nil {
+			if namedType, ok := rightType.(*types.Named); ok {
+				if namedType.Obj().Pkg() != nil && namedType.Obj().Pkg().Path() == "time" && namedType.Obj().Name() == "Duration" {
+					// number * Duration -> Duration.multiply(duration, number)
+					c.tsw.WriteLiterally("$.multiplyDuration(")
+					if err := c.WriteValueExpr(exp.Y); err != nil {
+						return fmt.Errorf("failed to write Duration in multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(", ")
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write multiplier in Duration multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(")")
+					return nil
+				}
+			}
+		}
+	}
+
 	// Check if the operator is a bitwise operator
 	isBitwise := false
 	switch exp.Op {
@@ -218,6 +352,19 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		isBitwise = true
 	}
 
+	// Special handling for large bit shift expressions that would overflow in JavaScript
+	if exp.Op == token.SHL {
+		// Check if this is 1 << 63 pattern
+		if leftLit, leftIsLit := exp.X.(*ast.BasicLit); leftIsLit && leftLit.Value == "1" {
+			if rightLit, rightIsLit := exp.Y.(*ast.BasicLit); rightIsLit && rightLit.Value == "63" {
+				// Replace 1 << 63 with Number.MAX_SAFE_INTEGER (9007199254740991)
+				// This is the largest integer that can be exactly represented in JavaScript
+				c.tsw.WriteLiterally("Number.MAX_SAFE_INTEGER")
+				return nil
+			}
+		}
+	}
+
 	if isBitwise {
 		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
 	}
@@ -248,11 +395,11 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 // It handles several unary operations:
 // - Channel receive (`<-ch`): Becomes `await ch.receive()`.
 // - Address-of (`&var`):
-//   - If `var` is a boxed variable (its address was taken), `&var` evaluates
-//     to the box itself (i.e., `varName` in TypeScript, which holds the box).
-//   - Otherwise (e.g., `&unboxedVar`, `&MyStruct{}`, `&FuncCall()`), it evaluates
+//   - If `var` is a varrefed variable (its address was taken), `&var` evaluates
+//     to the varRef itself (i.e., `varName` in TypeScript, which holds the varRef).
+//   - Otherwise (e.g., `&unvarrefedVar`, `&MyStruct{}`, `&FuncCall()`), it evaluates
 //     the operand `var`. The resulting TypeScript value (e.g., a new object instance)
-//     acts as the "pointer". Boxing decisions for such pointers are handled at
+//     acts as the "pointer". VarRefing decisions for such pointers are handled at
 //     the assignment site.
 //   - Other unary operators (`+`, `-`, `!`, `^`): Mapped to their TypeScript
 //     equivalents (e.g., `+`, `-`, `!`, `~` for bitwise NOT). Parentheses are added
@@ -263,36 +410,36 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 // their statement contexts (e.g., `IncDecStmt`).
 func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	if exp.Op == token.ARROW {
-		// Channel receive: <-ch becomes await ch.receive()
-		c.tsw.WriteLiterally("await ")
+		// Channel receive: <-ch becomes await $.chanRecv(ch)
+		c.tsw.WriteLiterally("await $.chanRecv(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write channel receive operand: %w", err)
 		}
-		c.tsw.WriteLiterally(".receive()")
+		c.tsw.WriteLiterally(")")
 		return nil
 	}
 
 	if exp.Op == token.AND { // Address-of operator (&)
-		// If the operand is an identifier for a variable that is boxed,
-		// the result of & is the box itself.
+		// If the operand is an identifier for a variable that is varrefed,
+		// the result of & is the varRef itself.
 		if ident, ok := exp.X.(*ast.Ident); ok {
 			var obj types.Object
 			obj = c.pkg.TypesInfo.Uses[ident]
 			if obj == nil {
 				obj = c.pkg.TypesInfo.Defs[ident]
 			}
-			if obj != nil && c.analysis.NeedsBoxed(obj) {
-				// &boxedVar -> boxedVar (the box itself)
-				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the box)
+			if obj != nil && c.analysis.NeedsVarRef(obj) {
+				// &varRefVar -> varRefVar (the variable reference itself)
+				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the variable reference)
 				return nil
 			}
 		}
 
-		// Otherwise (&unboxedVar, &CompositeLit{}, &FuncCall(), etc.),
+		// Otherwise (&unvarrefedVar, &CompositeLit{}, &FuncCall(), etc.),
 		// the address-of operator in Go, when used to create a pointer,
 		// translates to simply evaluating the operand in TypeScript.
 		// The resulting value (e.g., a new object instance) acts as the "pointer".
-		// Boxing decisions are handled at the assignment site based on the LHS variable.
+		// VarRefing decisions are handled at the assignment site based on the LHS variable.
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write &-operand: %w", err)
 		}
@@ -337,6 +484,155 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	return nil
 }
 
+// WriteSliceExpr translates a Go slice expression (e.g., `s[low:high:max]`) to its TypeScript equivalent.
+// If `s` is a string and it's not a 3-index slice, it uses `s.substring(low, high)`.
+// If `s` is `[]byte` (Uint8Array) and it's not a 3-index slice, it uses `s.subarray(low, high)`.
+// Otherwise, it falls back to the `$.goSlice(s, low, high, max)` runtime helper.
+func (c *GoToTSCompiler) WriteSliceExpr(exp *ast.SliceExpr) error {
+	// Check if the expression being sliced is a string
+	tv := c.pkg.TypesInfo.TypeOf(exp.X)
+	isString := false
+	isByteSlice := false
+	isTypeParam := false
+	if tv != nil {
+		if basicType, isBasic := tv.Underlying().(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+			isString = true
+		}
+		if sliceType, isSlice := tv.Underlying().(*types.Slice); isSlice {
+			if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+				isByteSlice = true
+			}
+		}
+		if _, isTP := tv.(*types.TypeParam); isTP {
+			isTypeParam = true
+		}
+	}
+
+	// Handle type parameters with union constraints (e.g., string | []byte)
+	if isTypeParam {
+		// For type parameters, we need to create a runtime helper that handles both string and []byte
+		c.tsw.WriteLiterally("$.sliceStringOrBytes(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	}
+
+	if isString && !exp.Slice3 {
+		// Use $.sliceString for byte-correct string slicing
+		c.tsw.WriteLiterally("$.sliceString(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			// Go's default low for string[:high] is 0.
+			// $.sliceString can handle undefined for low as 0.
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			// Go's default high for string[low:] means to the end.
+			// $.sliceString can handle undefined for high as end of string.
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(")")
+	} else if isByteSlice && !exp.Slice3 {
+		// Use s.subarray(low, high) for []byte slices
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(".subarray(")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("0") // Default low for subarray is 0
+		}
+		if exp.High != nil {
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			// If high is omitted, subarray goes to the end of the array.
+			// No need to write undefined or length, just close the parenthesis if low was the last arg.
+		}
+		c.tsw.WriteLiterally(")")
+	} else {
+		// Fallback to $.goSlice for actual slices (arrays) or 3-index string slices (which are rare and might need $.goSlice's complexity)
+		// Or if it's a string but has Slice3, it's not handled by simple substring.
+		c.tsw.WriteLiterally("$.goSlice(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+	}
+	return nil
+}
+
 // WriteKeyValueExpr translates a Go key-value pair expression (`ast.KeyValueExpr`),
 // typically found within composite literals (for structs, maps, or arrays with
 // indexed elements), into its TypeScript object property equivalent: `key: value`.

package/compiler/field.go

@@ -50,7 +50,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				c.tsw.WriteLiterally(name.Name)
 				c.tsw.WriteLiterally(": ")
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ)
+				c.WriteGoType(typ, GoTypeContextGeneral)
 			}
 		}
 
@@ -89,7 +89,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 					c.tsw.WriteLiterally(name.Name)
 					c.tsw.WriteLiterally(": ")
 					typ := c.pkg.TypesInfo.TypeOf(field.Type)
-					c.WriteGoType(typ) // Use WriteGoType for parameter type
+					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
 				}
 			} else {
 				// For struct fields and other non-argument fields
@@ -155,7 +155,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 		// write type for struct fields (not arguments)
 		c.tsw.WriteLiterally(": ")
 		typ := c.pkg.TypesInfo.TypeOf(field.Type)
-		c.WriteGoType(typ) // Use WriteGoType for field type
+		c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for field type
 
 		if !isArguments {
 			// write tag comment if any for struct fields

package/compiler/lit.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"strconv"
@@ -90,9 +91,40 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 
 	c.tsw.WriteLiterally(" => ")
 
+	hasNamedReturns := false
+	if exp.Type.Results != nil {
+		for _, field := range exp.Type.Results.List {
+			if len(field.Names) > 0 {
+				hasNamedReturns = true
+				break
+			}
+		}
+	}
+
+	if hasNamedReturns {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+
+		// Declare named return variables and initialize them to their zero values
+		for _, field := range exp.Type.Results.List {
+			for _, name := range field.Names {
+				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.WriteTypeExpr(field.Type)
+				c.tsw.WriteLiterally(" = ")
+				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+				c.tsw.WriteLine("")
+			}
+		}
+	}
+
 	// Write function body
-	if err := c.WriteStmt(exp.Body); err != nil {
-		return err
+	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+		return fmt.Errorf("failed to write block statement: %w", err)
+	}
+
+	if hasNamedReturns {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("}")
 	}
 
 	return nil

package/compiler/primitive.go

@@ -29,7 +29,10 @@ var goToTypescriptPrimitives = map[string]string{
 	"int16": "number",
 	"int32": "number",
 	"rune":  "number", // alias for int32
-	"int64": "bigint", // Requires TypeScript target >= ES2020
+
+	// TODO: add bigint support
+	// "int64": "bigint", // Requires TypeScript target >= ES2020
+	"int64": "number",
 
 	// Unsigned Integers
 	"uint":   "number",
@@ -37,7 +40,10 @@ var goToTypescriptPrimitives = map[string]string{
 	"byte":   "number",
 	"uint16": "number",
 	"uint32": "number",
-	"uint64": "bigint", // Requires TypeScript target >= ES2020
+
+	// TODO: add bigint support
+	// "uint64": "bigint", // Requires TypeScript target >= ES2020
+	"uint64": "number",
 
 	// Floating Point Numbers
 	"float32": "number",
@@ -76,16 +82,17 @@ func GoBuiltinToTypescript(typeName string) (string, bool) {
 // in their respective expression/statement writers and might not be directly mapped here.
 // Bitwise AND NOT (`&^=`) is also mapped but may require specific runtime support if not directly translatable.
 var tokenMap = map[token.Token]string{
-	token.ADD: "+",
-	token.SUB: "-",
-	token.MUL: "*",
-	token.QUO: "/",
-	token.REM: "%",
-	token.AND: "&",
-	token.OR:  "|",
-	token.XOR: "^",
-	token.SHL: "<<",
-	token.SHR: ">>",
+	token.ADD:     "+",
+	token.SUB:     "-",
+	token.MUL:     "*",
+	token.QUO:     "/",
+	token.REM:     "%",
+	token.AND:     "&",
+	token.OR:      "|",
+	token.XOR:     "^",
+	token.SHL:     "<<",
+	token.SHR:     ">>",
+	token.AND_NOT: "& ~", // &^ operator: bitwise AND NOT
 
 	token.ADD_ASSIGN: "+=",
 	token.SUB_ASSIGN: "-=",