goscript 0.0.36 → 0.0.38

package/compiler/analysis.go

@@ -43,12 +43,25 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// FunctionTypeInfo represents Go function type information for reflection
+type FunctionTypeInfo struct {
+	Params   []types.Type // Parameter types
+	Results  []types.Type // Return types
+	Variadic bool         // Whether the function is variadic
+}
+
 // FunctionInfo consolidates function-related tracking data.
 type FunctionInfo struct {
 	IsAsync      bool
 	NamedReturns []string
 }
 
+// ReflectedFunctionInfo tracks functions that need reflection support
+type ReflectedFunctionInfo struct {
+	FuncType     *types.Signature // The function's type signature
+	NeedsReflect bool             // Whether this function is used with reflection
+}
+
 // NodeInfo consolidates node-related tracking data.
 type NodeInfo struct {
 	NeedsDefer        bool
@@ -84,6 +97,12 @@ type Analysis struct {
 	// FuncLitData tracks function literal specific data since they don't have types.Object
 	FuncLitData map[*ast.FuncLit]*FunctionInfo
 
+	// ReflectedFunctions tracks functions that need reflection type metadata
+	ReflectedFunctions map[ast.Node]*ReflectedFunctionInfo
+
+	// FunctionAssignments tracks which function literals are assigned to which variables
+	FunctionAssignments map[types.Object]ast.Node
+
 	// PackageMetadata holds package-level metadata
 	PackageMetadata map[string]interface{}
 }
@@ -102,12 +121,14 @@ type PackageAnalysis struct {
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
-		VariableUsage:   make(map[types.Object]*VariableUsageInfo),
-		Imports:         make(map[string]*fileImport),
-		FunctionData:    make(map[types.Object]*FunctionInfo),
-		NodeData:        make(map[ast.Node]*NodeInfo),
-		FuncLitData:     make(map[*ast.FuncLit]*FunctionInfo),
-		PackageMetadata: make(map[string]interface{}),
+		VariableUsage:       make(map[types.Object]*VariableUsageInfo),
+		Imports:             make(map[string]*fileImport),
+		FunctionData:        make(map[types.Object]*FunctionInfo),
+		NodeData:            make(map[ast.Node]*NodeInfo),
+		FuncLitData:         make(map[*ast.FuncLit]*FunctionInfo),
+		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
+		FunctionAssignments: make(map[types.Object]ast.Node),
+		PackageMetadata:     make(map[string]interface{}),
 	}
 }
 
@@ -341,6 +362,10 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 								// Case: var lhs = rhs_ident
 								assignmentType = DirectAssignment
 								sourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
+							} else if funcLit, ok := rhsExpr.(*ast.FuncLit); ok {
+								// Case: var lhs = func(...) { ... }
+								// Track function literal assignment
+								v.analysis.FunctionAssignments[lhsObj] = funcLit
 							}
 
 							// --- Record Usage ---
@@ -578,6 +603,9 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 
+		// Check for reflect function calls that operate on functions
+		v.checkReflectUsage(n)
+
 		// Store async state for this call expression
 		if v.analysis.NodeData[n] == nil {
 			v.analysis.NodeData[n] = &NodeInfo{}
@@ -637,16 +665,21 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 					continue // Skip blank identifier assignments
 				}
 				lhsTrackedObj = v.pkg.TypesInfo.ObjectOf(lhsIdent)
+
+				// Check if RHS is a function literal and track the assignment
+				if funcLit, ok := currentRHSExpr.(*ast.FuncLit); ok {
+					v.analysis.FunctionAssignments[lhsTrackedObj] = funcLit
+				}
 			} else if selExpr, ok := currentLHSExpr.(*ast.SelectorExpr); ok {
 				// LHS is struct.field or package.Var
 				if selection := v.pkg.TypesInfo.Selections[selExpr]; selection != nil {
 					lhsTrackedObj = selection.Obj() // This is the field or selected var object
 				}
-			} else if _, ok := currentLHSExpr.(*ast.StarExpr); ok {
+			} /* else if _, ok := currentLHSExpr.(*ast.StarExpr); ok {
 				// LHS is *pointer.
 				// We don't try to get a types.Object for the dereferenced entity itself to store in VariableUsage.
 				// lhsTrackedObj remains nil. The effect on rhsSourceObj (if its address is taken) is handled below.
-			}
+			} */
 			// For other complex LHS (e.g., map_expr[key_expr]), lhsTrackedObj remains nil.
 
 			// --- Record Usage Information ---
@@ -1095,3 +1128,91 @@ func (a *Analysis) IsMethodAsync(pkgName, typeName, methodName string) bool {
 
 	return false
 }
+
+// NeedsReflectionMetadata returns whether the given function node needs reflection type metadata
+func (a *Analysis) NeedsReflectionMetadata(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	reflectInfo := a.ReflectedFunctions[node]
+	return reflectInfo != nil && reflectInfo.NeedsReflect
+}
+
+// GetFunctionTypeInfo returns the function type information for reflection
+func (a *Analysis) GetFunctionTypeInfo(node ast.Node) *ReflectedFunctionInfo {
+	if node == nil {
+		return nil
+	}
+	return a.ReflectedFunctions[node]
+}
+
+// MarkFunctionForReflection marks a function node as needing reflection support
+func (a *Analysis) MarkFunctionForReflection(node ast.Node, funcType *types.Signature) {
+	if node == nil || funcType == nil {
+		return
+	}
+	a.ReflectedFunctions[node] = &ReflectedFunctionInfo{
+		FuncType:     funcType,
+		NeedsReflect: true,
+	}
+}
+
+// checkReflectUsage checks for reflect function calls that operate on functions
+func (v *analysisVisitor) checkReflectUsage(callExpr *ast.CallExpr) {
+	// Check if this is a reflect package function call
+	if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+		// Check if the selector is from reflect package
+		if ident, ok := selExpr.X.(*ast.Ident); ok {
+			// Check if this is a reflect package call (reflect.TypeOf, reflect.ValueOf, etc.)
+			if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
+				if pkgName, ok := obj.(*types.PkgName); ok && pkgName.Imported().Path() == "reflect" {
+					methodName := selExpr.Sel.Name
+
+					// Check for reflect.TypeOf and reflect.ValueOf calls
+					if methodName == "TypeOf" || methodName == "ValueOf" {
+						// Check if any argument is a function
+						for _, arg := range callExpr.Args {
+							v.checkReflectArgument(arg)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// checkReflectArgument checks if an argument to a reflect function is a function that needs metadata
+func (v *analysisVisitor) checkReflectArgument(arg ast.Expr) {
+	// Check if the argument is an identifier (variable)
+	if ident, ok := arg.(*ast.Ident); ok {
+		// Get the object this identifier refers to
+		if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
+			// Check if this object has a function type
+			if funcType, ok := obj.Type().(*types.Signature); ok {
+				// This is a function variable being passed to reflect
+				// We need to find the original function definition/assignment
+				v.markFunctionVariable(ident, funcType)
+			}
+		}
+	} else if funcLit, ok := arg.(*ast.FuncLit); ok {
+		// This is a function literal being passed directly to reflect
+		if funcType := v.pkg.TypesInfo.Types[funcLit].Type.(*types.Signature); funcType != nil {
+			v.analysis.MarkFunctionForReflection(funcLit, funcType)
+		}
+	}
+}
+
+// markFunctionVariable finds the function definition/assignment for a variable and marks it for reflection
+func (v *analysisVisitor) markFunctionVariable(ident *ast.Ident, funcType *types.Signature) {
+	// Get the object for this identifier
+	obj := v.pkg.TypesInfo.Uses[ident]
+	if obj == nil {
+		return
+	}
+
+	// Check if we have a tracked function assignment for this variable
+	if funcNode := v.analysis.FunctionAssignments[obj]; funcNode != nil {
+		// Mark the function node for reflection
+		v.analysis.MarkFunctionForReflection(funcNode, funcType)
+	}
+}

package/compiler/compiler.go

@@ -453,7 +453,10 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		if strings.HasSuffix(fileName, ".pb") {
 			// For protobuf files, add a simple re-export
 			pbTsFileName := fileName + ".ts"
-			if err := c.writeProtobufExports(indexFile, fileName, pbTsFileName); err != nil {
+			if err := func() error {
+				var _ string = pbTsFileName
+				return c.writeProtobufExports(indexFile, fileName)
+			}(); err != nil {
 				return err
 			}
 			continue

package/compiler/composite-lit.go

@@ -503,14 +503,12 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 		case *types.Pointer:
 			// Handle pointer to composite literal
 			ptrType := underlying.(*types.Pointer)
-			elemType := ptrType.Elem().Underlying()
-			switch elemType.(type) {
+			switch elemType := ptrType.Elem().Underlying().(type) {
 			case *types.Struct:
 				// This is an anonymous struct literal with inferred pointer type
 				// Just create the struct object directly - no var-refing needed
 				// Anonymous literals are not variables, so they don't get var-refed
-				structType := elemType.(*types.Struct)
-				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, elemType) // true = anonymous
 			default:
 				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
 			}

package/compiler/expr-call.go

@@ -1120,9 +1120,22 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				if i != 0 {
 					c.tsw.WriteLiterally(", ")
 				}
+				// Check if this is the last argument and we have ellipsis (variadic call)
+				if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
+					c.tsw.WriteLiterally("...")
+				}
 				if err := c.WriteValueExpr(arg); err != nil {
 					return fmt.Errorf("failed to write argument %d in call: %w", i, err)
 				}
+				// Add non-null assertion for spread arguments that might be null
+				if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
+					// Check if the argument type is potentially nullable (slice)
+					if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+						if _, isSlice := argType.Underlying().(*types.Slice); isSlice {
+							c.tsw.WriteLiterally("!")
+						}
+					}
+				}
 			}
 			c.tsw.WriteLiterally(")")
 			return nil // Handled regular function call
@@ -1206,9 +1219,22 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
+		// Check if this is the last argument and we have ellipsis (variadic call)
+		if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
+			c.tsw.WriteLiterally("...")
+		}
 		if err := c.WriteValueExpr(arg); err != nil {
 			return fmt.Errorf("failed to write argument %d in call: %w", i, err)
 		}
+		// Add non-null assertion for spread arguments that might be null
+		if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
+			// Check if the argument type is potentially nullable (slice)
+			if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+				if _, isSlice := argType.Underlying().(*types.Slice); isSlice {
+					c.tsw.WriteLiterally("!")
+				}
+			}
+		}
 	}
 	c.tsw.WriteLiterally(")")
 	return nil

package/compiler/lit.go

@@ -101,6 +101,17 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 //   - Wrapped in `Promise<>` if `async`.
 //   - The function body (`exp.Body`) is translated using `WriteStmt`.
 func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
+	// Check if this function needs reflection metadata
+	needsReflection := c.analysis.NeedsReflectionMetadata(exp)
+
+	if needsReflection {
+		// Start IIFE to attach metadata
+		c.tsw.WriteLiterally("(() => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		c.tsw.WriteLiterally("const fn = ")
+	}
+
 	// Determine if the function literal should be async
 	isAsync := c.analysis.IsFuncLitAsync(exp)
 
@@ -183,6 +194,78 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 		c.tsw.WriteLiterally("}")
 	}
 
+	// Add reflection metadata if needed
+	if needsReflection {
+		c.tsw.WriteLine("")
+
+		// Attach type metadata to the function
+		if err := c.writeReflectionMetadata(exp); err != nil {
+			return fmt.Errorf("failed to write reflection metadata: %w", err)
+		}
+
+		c.tsw.WriteLine("return fn")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("})()")
+	}
+
+	return nil
+}
+
+// writeReflectionMetadata attaches function type information to a function for reflection support
+func (c *GoToTSCompiler) writeReflectionMetadata(exp *ast.FuncLit) error {
+	// Get the reflection info for this function
+	reflectInfo := c.analysis.GetFunctionTypeInfo(exp)
+	if reflectInfo == nil || reflectInfo.FuncType == nil {
+		return nil // No reflection info available
+	}
+
+	funcType := reflectInfo.FuncType
+
+	// Build FunctionTypeInfo metadata
+	c.tsw.WriteLiterally("fn.__typeInfo = {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("")
+	c.tsw.WriteLiterally("kind: $.TypeKind.Function,")
+	c.tsw.WriteLine("")
+
+	// Add parameters
+	if funcType.Params() != nil && funcType.Params().Len() > 0 {
+		c.tsw.WriteLiterally("params: [")
+		for i := 0; i < funcType.Params().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			param := funcType.Params().At(i)
+			c.tsw.WriteLiterallyf("'%s'", param.Type().String())
+		}
+		c.tsw.WriteLiterally("],")
+		c.tsw.WriteLine("")
+	}
+
+	// Add results
+	if funcType.Results() != nil && funcType.Results().Len() > 0 {
+		c.tsw.WriteLiterally("results: [")
+		for i := 0; i < funcType.Results().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			result := funcType.Results().At(i)
+			c.tsw.WriteLiterallyf("'%s'", result.Type().String())
+		}
+		c.tsw.WriteLiterally("],")
+		c.tsw.WriteLine("")
+	}
+
+	// Add variadic flag
+	if funcType.Variadic() {
+		c.tsw.WriteLiterally("isVariadic: true,")
+		c.tsw.WriteLine("")
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLiterally("}")
+	c.tsw.WriteLine("")
+
 	return nil
 }
 

package/compiler/protobuf.go

@@ -118,7 +118,7 @@ func (c *PackageCompiler) copyProtobufTSFile(sourcePath, fileName string) error
 }
 
 // writeProtobufExports writes exports for a protobuf file to the index.ts file
-func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName, pbTsFileName string) error {
+func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName string) error {
 	// For protobuf files, we know they typically export message types
 	// For now, we'll use a simple heuristic: export all types that end with "Msg"
 	// In a full implementation, we would parse the .pb.ts file to extract actual exports
@@ -230,7 +230,7 @@ func (c *GoToTSCompiler) writeProtobufMarshalAssignment(lhs []ast.Expr, callExpr
 
 // writeProtobufUnmarshalAssignment handles: err = out.UnmarshalVT(data)
 // Generates: out = ExampleMsg.fromBinary(data); err = null;
-func (c *GoToTSCompiler) writeProtobufUnmarshalAssignment(lhs []ast.Expr, callExpr *ast.CallExpr, tok token.Token) error {
+func (c *GoToTSCompiler) writeProtobufUnmarshalAssignment(lhs []ast.Expr, callExpr *ast.CallExpr) error {
 	if len(lhs) != 1 {
 		return fmt.Errorf("protobuf unmarshal assignment requires exactly 1 LHS variable, got %d", len(lhs))
 	}

package/compiler/spec-value.go

@@ -233,14 +233,14 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 						if c.hasReceiverMethods(typeName) {
 							// Check if the initializer is a basic literal or simple value that needs wrapping
 							needsConstructor := false
-							switch initializerExpr.(type) {
+							switch expr := initializerExpr.(type) {
 							case *ast.BasicLit:
 								needsConstructor = true
 							case *ast.Ident:
 								// Check if it's a simple identifier (not a function call or complex expression)
-								if ident := initializerExpr.(*ast.Ident); ident.Name != "nil" {
+								if expr.Name != "nil" {
 									// Check if this identifier refers to a value of the underlying type
-									if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+									if obj := c.pkg.TypesInfo.Uses[expr]; obj != nil {
 										if objType := obj.Type(); objType != nil {
 											// If the identifier's type matches the underlying type, wrap it
 											if types.Identical(objType, namedType.Underlying()) {

package/compiler/spec.go

@@ -45,7 +45,10 @@ func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
 		return named.Obj().Name()
 	} else {
 		// Fallback for unnamed embedded types, though less common for structs
-		fieldKeyName := strings.Title(trueType.String()) // Simple heuristic
+		fieldKeyName := trueType.String()
+		if len(fieldKeyName) > 0 {
+			fieldKeyName = strings.ToUpper(fieldKeyName[:1]) + fieldKeyName[1:]
+		}
 		if dotIndex := strings.LastIndex(fieldKeyName, "."); dotIndex != -1 {
 			fieldKeyName = fieldKeyName[dotIndex+1:]
 		}
@@ -95,7 +98,7 @@ func (c *GoToTSCompiler) writeVarRefedFieldInitializer(fieldName string, fieldTy
 		if named, ok := fieldType.(*types.Named); ok {
 			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
 				isStructValueType = true
-				structTypeNameForClone = named.Obj().Name()
+				structTypeNameForClone = c.getTypeString(fieldType)
 			}
 		}
 
@@ -261,7 +264,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 			if recvTypeName == className {
 				c.tsw.WriteLine("")
-				if err := c.writeNamedTypeMethod(funcDecl, className); err != nil {
+				if err := c.writeNamedTypeMethod(funcDecl); err != nil {
 					return err
 				}
 			}
@@ -275,7 +278,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 }
 
 // writeNamedTypeMethod writes a method for a named type, handling receiver binding properly
-func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl, className string) error {
+func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl) error {
 	if decl.Doc != nil {
 		c.WriteDoc(decl.Doc)
 	}

package/compiler/stmt-assign.go

@@ -469,7 +469,7 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if callExpr, ok := exp.Rhs[0].(*ast.CallExpr); ok {
 			// Handle protobuf UnmarshalVT: err = out.UnmarshalVT(data)
 			if c.isProtobufMethodCall(callExpr, "UnmarshalVT") {
-				return c.writeProtobufUnmarshalAssignment(exp.Lhs, callExpr, exp.Tok)
+				return c.writeProtobufUnmarshalAssignment(exp.Lhs, callExpr)
 			}
 			// Handle protobuf UnmarshalJSON: err = out.UnmarshalJSON(data)
 			if c.isProtobufMethodCall(callExpr, "UnmarshalJSON") {

package/compiler/stmt.go

@@ -170,10 +170,16 @@ func (c *GoToTSCompiler) WriteStmtBranch(stmt *ast.BranchStmt) error {
 		c.tsw.WriteLine("break") // No semicolon needed
 	case token.CONTINUE:
 		c.tsw.WriteLine("continue") // No semicolon needed
+	case token.GOTO:
+		// TypeScript doesn't support goto, but we can handle it by skipping it
+		// since the labeled statement restructuring should handle the control flow
+		c.tsw.WriteCommentLinef("goto %s // goto statement skipped", stmt.Label.Name)
+	case token.FALLTHROUGH:
+		// Fallthrough is handled in switch statements, should not appear elsewhere
+		c.tsw.WriteCommentLinef("fallthrough // fallthrough statement skipped")
 	default:
 		// This case should ideally not be reached if the Go parser is correct,
 		// as ast.BranchStmt only covers break, continue, goto, fallthrough.
-		// 'goto' and 'fallthrough' are handled elsewhere or not supported.
 		c.tsw.WriteCommentLinef("unhandled branch statement token: %s", stmt.Tok.String())
 	}
 	return nil
@@ -855,17 +861,29 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 // WriteStmtLabeled handles labeled statements (ast.LabeledStmt), such as "label: statement".
 // In TypeScript, labels cannot be used with variable declarations, so we need to handle this case specially.
 func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
-	// Check if the labeled statement is a declaration statement
-	if declStmt, ok := stmt.Stmt.(*ast.DeclStmt); ok {
-		// For declaration statements, we need to put the label on a separate line
+	// Check if the labeled statement is a declaration statement or assignment with :=
+	needsBlock := false
+	if _, ok := stmt.Stmt.(*ast.DeclStmt); ok {
+		needsBlock = true
+	} else if assignStmt, ok := stmt.Stmt.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
+		// Assignment with := is also a declaration and needs special handling
+		needsBlock = true
+	}
+
+	if needsBlock {
+		// For declaration statements and := assignments, we need to put the label on a separate line
 		// because TypeScript doesn't allow labels with declarations
 		c.tsw.WriteLiterally(stmt.Label.Name)
-		c.tsw.WriteLine(": {}")
+		c.tsw.WriteLine(": {")
+		c.tsw.Indent(1)
 
-		// Write the declaration statement without the label
-		if err := c.WriteStmt(declStmt); err != nil {
-			return fmt.Errorf("failed to write labeled declaration statement: %w", err)
+		// Write the statement without the label
+		if err := c.WriteStmt(stmt.Stmt); err != nil {
+			return fmt.Errorf("failed to write labeled declaration/assignment statement: %w", err)
 		}
+
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
 	} else {
 		// For non-declaration statements, write the label normally
 		c.tsw.WriteLiterally(stmt.Label.Name)

package/dist/gs/builtin/slice.js

@@ -819,8 +819,9 @@ export const sliceString = (str, low, high) => {
         // Attempt to decode with strict UTF-8 validation
         const result = new TextDecoder('utf-8', { fatal: true }).decode(slicedBytes);
         return result;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
-    catch (_e) { //eslint-disable-line @typescript-eslint/no-unused-vars
+    catch (_e) {
         // If we get here, the slice would create invalid UTF-8
         // This is a fundamental limitation of JavaScript string handling
         throw new Error(`Cannot slice string at byte indices [${actualLow}:${actualHigh}] because it would create invalid UTF-8. ` +