goscript 0.0.41 → 0.0.43

package/compiler/lit.go

@@ -164,29 +164,13 @@ 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 {
+	if c.hasNamedReturns(exp.Type.Results) {
 		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: ", c.sanitizeIdentifier(name.Name))
-				c.WriteTypeExpr(field.Type)
-				c.tsw.WriteLiterally(" = ")
-				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
-				c.tsw.WriteLine("")
-			}
+		if err := c.writeNamedReturnDeclarations(exp.Type.Results); err != nil {
+			return fmt.Errorf("failed to write named return declarations: %w", err)
 		}
 	}
 
@@ -195,7 +179,7 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 		return fmt.Errorf("failed to write block statement: %w", err)
 	}
 
-	if hasNamedReturns {
+	if c.hasNamedReturns(exp.Type.Results) {
 		c.tsw.Indent(-1)
 		c.tsw.WriteLiterally("}")
 	}

package/compiler/spec-struct.go

@@ -20,10 +20,9 @@ import (
 //   - Wrapper methods for promoted fields and methods from embedded structs,
 //     ensuring correct access and behavior.
 func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType) error {
-	// Add export for Go-exported structs
-	if a.Name.IsExported() {
-		c.tsw.WriteLiterally("export ")
-	}
+	// Always export types for cross-file imports within the same package
+	// This allows unexported Go types to be imported by other files in the same package
+	c.tsw.WriteLiterally("export ")
 	c.tsw.WriteLiterally("class ")
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err

package/compiler/spec-value.go

@@ -153,7 +153,14 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					}
 				} else {
 					// Not a pointer type, write as is.
-					c.WriteGoType(goType, GoTypeContextGeneral)
+					// Use AST-based type writing if explicit type is provided, otherwise use WriteGoType
+					if a.Type != nil {
+						// Explicit type annotation in Go code - use AST to preserve qualified names
+						c.WriteTypeExpr(a.Type)
+					} else {
+						// No explicit type - use type inference from WriteGoType
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
 				}
 			}
 		}
@@ -249,6 +256,16 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 										}
 									}
 								}
+							case *ast.CallExpr:
+								// Check if this is a make() call that returns the underlying type
+								if funIdent, ok := expr.Fun.(*ast.Ident); ok && funIdent.Name == "make" {
+									// Check if the make call returns a type that matches the underlying type
+									if exprType := c.pkg.TypesInfo.TypeOf(expr); exprType != nil {
+										if types.Identical(exprType, namedType.Underlying()) {
+											needsConstructor = true
+										}
+									}
+								}
 							}
 
 							if needsConstructor {

package/compiler/spec.go

@@ -188,7 +188,6 @@ func (c *GoToTSCompiler) hasReceiverMethods(typeName string) bool {
 // WriteNamedTypeWithMethods generates a TypeScript class for a Go named type that has receiver methods
 func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 	className := a.Name.Name
-	underlyingType := c.pkg.TypesInfo.TypeOf(a.Type)
 
 	// Add export for Go-exported types (but not if inside a function)
 	isInsideFunction := false
@@ -196,7 +195,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 
@@ -206,13 +205,15 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 	// Constructor that takes the underlying type value
 	c.tsw.WriteLiterally("constructor(private _value: ")
-	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLine(") {}")
 	c.tsw.WriteLine("")
 
 	// valueOf method to get the underlying value (for type conversions and operations)
 	c.tsw.WriteLiterally("valueOf(): ")
-	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLine(" {")
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("return this._value")
@@ -230,7 +231,8 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 	// Static from method for type conversion
 	c.tsw.WriteLiterallyf("static from(value: ")
-	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	// Use AST-based type writing to preserve qualified names like os.FileInfo
+	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLiterallyf("): %s {", className)
 	c.tsw.WriteLine("")
 	c.tsw.Indent(1)
@@ -364,6 +366,11 @@ func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl) error {
 				}
 			}
 
+			// Declare named return variables and initialize them to their zero values
+			if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+				return fmt.Errorf("failed to write named return declarations: %w", err)
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
@@ -404,13 +411,13 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 			return c.WriteNamedTypeWithMethods(a)
 		}
 
-		// type alias - add export for Go-exported types (but not if inside a function)
+		// Always export types for cross-file imports within the same package (but not if inside a function)
 		isInsideFunction := false
 		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
 			isInsideFunction = nodeInfo.IsInsideFunction
 		}
 
-		if a.Name.IsExported() && !isInsideFunction {
+		if !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("type ")
@@ -438,7 +445,7 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 	c.tsw.WriteLiterally("type ")

package/compiler/stmt-range.go

@@ -157,7 +157,7 @@ func (c *GoToTSCompiler) writeMapRange(exp *ast.RangeStmt) error {
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write range loop map expression: %w", err)
 	}
-	c.tsw.WriteLiterally(".entries()) {")
+	c.tsw.WriteLiterally("?.entries() ?? []) {")
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("")
 

package/compiler/stmt.go

@@ -444,53 +444,90 @@ func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
 //     recursively calling `WriteStmtIf`.
 //
 // The function aims to produce idiomatic TypeScript `if/else if/else` structures.
-func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
+func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	if exp.Init != nil {
-		s.tsw.WriteLiterally("{") // Write opening brace
-		s.tsw.WriteLine("")       // Add newline immediately after opening brace
-		s.tsw.Indent(1)           // Indent for the initializer
+		// Check if we need to handle variable shadowing BEFORE creating the block
+		var shadowingInfo *ShadowingInfo
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			shadowingInfo = c.analysis.GetShadowingInfo(assignStmt)
+		}
+
+		// Generate temporary variables OUTSIDE the block to avoid temporal dead zone
+		if shadowingInfo != nil {
+			for varName, tempVarName := range shadowingInfo.TempVariables {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(tempVarName)
+				c.tsw.WriteLiterally(" = ")
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(varName))
+				c.tsw.WriteLine("")
+			}
+		}
 
-		if err := s.WriteStmt(exp.Init); err != nil { // Write the initializer
-			return err
+		c.tsw.WriteLiterally("{") // Write opening brace
+		c.tsw.WriteLine("")       // Add newline immediately after opening brace
+		c.tsw.Indent(1)           // Indent for the initializer
+
+		// Check if we need to handle variable shadowing
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			if shadowingInfo != nil {
+				// Write the assignment statement with special handling for shadowing
+				if err := c.writeShadowedAssignment(assignStmt, shadowingInfo); err != nil {
+					return err
+				}
+			} else {
+				// No shadowing, write normally
+				if err := c.WriteStmt(exp.Init); err != nil {
+					return err
+				}
+			}
+		} else {
+			// Not an assignment statement, write normally
+			if err := c.WriteStmt(exp.Init); err != nil {
+				return err
+			}
 		}
 
 		// This defer handles closing the synthetic block for the initializer
 		defer func() {
-			s.tsw.Indent(-1)
-			s.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
-			s.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
+			c.tsw.Indent(-1)
+			c.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
+			c.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
 		}()
 	}
 
-	s.tsw.WriteLiterally("if (")
-	if err := s.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
+	// Ensure shadowing context is clear before writing condition
+	// (condition should refer to new local variables, not temp variables)
+	c.shadowingContext = make(map[string]string)
+
+	c.tsw.WriteLiterally("if (")
+	if err := c.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
 		return err
 	}
-	s.tsw.WriteLiterally(") ")
+	c.tsw.WriteLiterally(") ")
 
 	if exp.Body != nil {
-		if err := s.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write if body block statement: %w", err)
 		}
 	} else {
 		// Handle nil body case using WriteStmtBlock with an empty block
-		if err := s.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write empty block statement in if statement: %w", err)
 		}
 	}
 
 	// handle else branch
 	if exp.Else != nil {
-		s.tsw.WriteLiterally(" else ")
+		c.tsw.WriteLiterally(" else ")
 		switch elseStmt := exp.Else.(type) {
 		case *ast.BlockStmt:
 			// Always pass false for suppressNewline here
-			if err := s.WriteStmtBlock(elseStmt, false); err != nil {
+			if err := c.WriteStmtBlock(elseStmt, false); err != nil {
 				return fmt.Errorf("failed to write else block statement in if statement: %w", err)
 			}
 		case *ast.IfStmt:
 			// Recursive call handles its own block formatting
-			if err := s.WriteStmtIf(elseStmt); err != nil {
+			if err := c.WriteStmtIf(elseStmt); err != nil {
 				return fmt.Errorf("failed to write else if statement in if statement: %w", err)
 			}
 		}
@@ -897,3 +934,67 @@ func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
 
 	return nil
 }
+
+// writeShadowedAssignment writes an assignment statement that has variable shadowing,
+// applying the shadowing context only to RHS expressions.
+func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
+	// Write the LHS variables (these are new declarations, don't use temp variables)
+	for i, lhsExpr := range stmt.Lhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		if ident, ok := lhsExpr.(*ast.Ident); ok {
+			if ident.Name == "_" {
+				c.tsw.WriteLiterally("_")
+			} else {
+				c.tsw.WriteLiterally("let ")
+				c.WriteIdent(ident, false) // Don't use temp variable for LHS
+			}
+		} else {
+			// For non-identifier LHS (shouldn't happen in := assignments), write normally
+			if err := c.WriteValueExpr(lhsExpr); err != nil {
+				return err
+			}
+		}
+	}
+
+	c.tsw.WriteLiterally(" = ")
+
+	// Set up shadowing context for RHS expressions only
+	originalContext := make(map[string]string)
+	for varName, tempVarName := range shadowingInfo.TempVariables {
+		originalContext[varName] = c.shadowingContext[varName] // backup original
+		c.shadowingContext[varName] = tempVarName
+	}
+
+	// Write RHS expressions with shadowing context
+	for i, rhsExpr := range stmt.Rhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		if err := c.WriteValueExpr(rhsExpr); err != nil {
+			// Restore context on error
+			for varName := range shadowingInfo.TempVariables {
+				if original, existed := originalContext[varName]; existed {
+					c.shadowingContext[varName] = original
+				} else {
+					delete(c.shadowingContext, varName)
+				}
+			}
+			return err
+		}
+	}
+
+	// Restore original context after writing RHS
+	for varName := range shadowingInfo.TempVariables {
+		if original, existed := originalContext[varName]; existed {
+			c.shadowingContext[varName] = original
+		} else {
+			delete(c.shadowingContext, varName)
+		}
+	}
+
+	c.tsw.WriteLine("")
+	return nil
+}

package/compiler/type-assert.go

@@ -96,8 +96,8 @@ func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.Typ
 		// For selector expressions as ok, we need to use temporary variables approach
 		if okIsSelectorExpr {
 			// Use temporary variables approach similar to SelectorExpr case
-			tempValName := "_gs_ta_val_" // Fixed name for temporary value
-			tempOkName := "_gs_ta_ok_"   // Fixed name for temporary ok status
+			tempValName := fmt.Sprintf("_gs_ta_val_%d_", typeAssertExpr.Pos()) // Unique name based on AST position
+			tempOkName := fmt.Sprintf("_gs_ta_ok_%d_", typeAssertExpr.Pos())   // Unique name based on AST position
 
 			// Declare temporary variables:
 			// let _gs_ta_val_: AssertedTypeTS;
@@ -217,8 +217,8 @@ func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.Typ
 
 	case *ast.SelectorExpr:
 		// Handle s.field, ok := expr.(Type)
-		tempValName := "_gs_ta_val_" // Fixed name for temporary value
-		tempOkName := "_gs_ta_ok_"   // Fixed name for temporary ok status
+		tempValName := fmt.Sprintf("_gs_ta_val_%d_", typeAssertExpr.Pos()) // Unique name based on AST position
+		tempOkName := fmt.Sprintf("_gs_ta_ok_%d_", typeAssertExpr.Pos())   // Unique name based on AST position
 
 		// Declare temporary variables:
 		// let _gs_ta_val_: AssertedTypeTS;

package/compiler/type.go

@@ -373,14 +373,15 @@ func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
 }
 
 // WriteMapType translates a Go map type (map[K]V) to its TypeScript equivalent.
-// It generates Map<K_ts, V_ts>, where K_ts and V_ts are the translated key
+// It generates Map<K_ts, V_ts> | null, where K_ts and V_ts are the translated key
 // and element types respectively.
+// Maps are nilable in Go, so they are represented as nullable types in TypeScript.
 func (c *GoToTSCompiler) WriteMapType(t *types.Map) {
 	c.tsw.WriteLiterally("Map<")
 	c.WriteGoType(t.Key(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(", ")
 	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally(">")
+	c.tsw.WriteLiterally("> | null")
 }
 
 // WriteChannelType translates a Go channel type (chan T) to its TypeScript equivalent.
@@ -566,7 +567,17 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			c.tsw.WriteLiterally(method.Name())
 			c.tsw.WriteLiterally("(") // Start params
 			params := sig.Params()
-			for j := 0; j < params.Len(); j++ {
+
+			// Check if this is a variadic method
+			isVariadic := sig.Variadic()
+
+			// Handle regular parameters (all parameters if not variadic, or all but last if variadic)
+			paramCount := params.Len()
+			if isVariadic && paramCount > 0 {
+				paramCount-- // Don't process the last parameter in the regular loop for variadic functions
+			}
+
+			for j := 0; j < paramCount; j++ {
 				if j > 0 {
 					c.tsw.WriteLiterally(", ")
 				}
@@ -579,6 +590,35 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				c.tsw.WriteLiterally(": ")
 				c.WriteGoType(paramVar.Type(), GoTypeContextGeneral) // Recursive call for param type
 			}
+
+			// Handle variadic parameter if present
+			if isVariadic && params.Len() > 0 {
+				if paramCount > 0 { // Add comma if there were regular parameters
+					c.tsw.WriteLiterally(", ")
+				}
+
+				// Get the last parameter (the variadic one)
+				paramVar := params.At(params.Len() - 1)
+				paramName := paramVar.Name()
+				if paramName == "" || paramName == "_" {
+					paramName = fmt.Sprintf("_p%d", params.Len()-1)
+				}
+
+				// Write variadic parameter with ... prefix
+				c.tsw.WriteLiterally("...")
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(paramName))
+				c.tsw.WriteLiterally(": ")
+
+				// For variadic parameters, the type is a slice, so we need the element type + []
+				if sliceType, ok := paramVar.Type().(*types.Slice); ok {
+					c.WriteGoType(sliceType.Elem(), GoTypeContextVariadicParam) // Use variadic context to avoid null prefix
+					c.tsw.WriteLiterally("[]")
+				} else {
+					// Fallback if it's not a slice type (shouldn't happen for valid variadic parameters)
+					c.WriteGoType(paramVar.Type(), GoTypeContextGeneral)
+				}
+			}
+
 			c.tsw.WriteLiterally(")") // End params
 
 			// Return type
@@ -587,14 +627,32 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			if results.Len() == 0 {
 				c.tsw.WriteLiterally("void")
 			} else if results.Len() == 1 {
-				c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
+				// Try to use AST information if available to preserve qualified names
+				if astField != nil && astField.Type != nil {
+					if funcType, ok := astField.Type.(*ast.FuncType); ok && funcType.Results != nil && len(funcType.Results.List) == 1 {
+						c.WriteTypeExpr(funcType.Results.List[0].Type)
+					} else {
+						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn) // Fallback
+					}
+				} else {
+					c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn) // Fallback
+				}
 			} else {
 				c.tsw.WriteLiterally("[")
 				for j := 0; j < results.Len(); j++ {
 					if j > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
+					// Try to use AST information if available to preserve qualified names
+					if astField != nil && astField.Type != nil {
+						if funcType, ok := astField.Type.(*ast.FuncType); ok && funcType.Results != nil && j < len(funcType.Results.List) {
+							c.WriteTypeExpr(funcType.Results.List[j].Type)
+						} else {
+							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn) // Fallback
+						}
+					} else {
+						c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn) // Fallback
+					}
 				}
 				c.tsw.WriteLiterally("]")
 			}

package/dist/gs/builtin/map.d.ts

@@ -10,24 +10,24 @@ export declare const makeMap: <K, V>() => Map<K, V>;
  * @param defaultValue The default value to return if the key doesn't exist.
  * @returns A tuple [value, exists] where value is the map value or defaultValue, and exists is whether the key was found.
  */
-export declare function mapGet<K, V, D>(map: Map<K, V>, key: K, defaultValue: D): [V, true] | [D, false];
+export declare function mapGet<K, V, D>(map: Map<K, V> | null, key: K, defaultValue: D): [V, true] | [D, false];
 /**
  * Sets a value in a map.
  * @param map The map to set in.
  * @param key The key to set.
  * @param value The value to set.
  */
-export declare const mapSet: <K, V>(map: Map<K, V>, key: K, value: V) => void;
+export declare const mapSet: <K, V>(map: Map<K, V> | null, key: K, value: V) => void;
 /**
  * Deletes a key from a map.
  * @param map The map to delete from.
  * @param key The key to delete.
  */
-export declare const deleteMapEntry: <K, V>(map: Map<K, V>, key: K) => void;
+export declare const deleteMapEntry: <K, V>(map: Map<K, V> | null, key: K) => void;
 /**
  * Checks if a key exists in a map.
  * @param map The map to check in.
  * @param key The key to check.
  * @returns True if the key exists, false otherwise.
  */
-export declare const mapHas: <K, V>(map: Map<K, V>, key: K) => boolean;
+export declare const mapHas: <K, V>(map: Map<K, V> | null, key: K) => boolean;

package/dist/gs/builtin/map.js

@@ -13,7 +13,7 @@ export const makeMap = () => {
  * @returns A tuple [value, exists] where value is the map value or defaultValue, and exists is whether the key was found.
  */
 export function mapGet(map, key, defaultValue) {
-    const exists = map.has(key);
+    const exists = map?.has(key);
     if (exists) {
         return [map.get(key), true];
     }
@@ -28,6 +28,9 @@ export function mapGet(map, key, defaultValue) {
  * @param value The value to set.
  */
 export const mapSet = (map, key, value) => {
+    if (!map) {
+        throw new Error('assign to nil map');
+    }
     map.set(key, value);
 };
 /**
@@ -36,7 +39,7 @@ export const mapSet = (map, key, value) => {
  * @param key The key to delete.
  */
 export const deleteMapEntry = (map, key) => {
-    map.delete(key);
+    map?.delete(key);
 };
 /**
  * Checks if a key exists in a map.
@@ -45,6 +48,6 @@ export const deleteMapEntry = (map, key) => {
  * @returns True if the key exists, false otherwise.
  */
 export const mapHas = (map, key) => {
-    return map.has(key);
+    return map?.has(key) ?? false;
 };
 //# sourceMappingURL=map.js.map

package/dist/gs/builtin/map.js.map

@@ -1 +1 @@
-{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../gs/builtin/map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAoB,EAAE;IAC3C,OAAO,IAAI,GAAG,EAAQ,CAAA;AACxB,CAAC,CAAA;AACD;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,GAAc,EACd,GAAM,EACN,YAAe;IAEf,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC3B,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAE,EAAE,IAAI,CAAC,CAAA;IAC9B,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;IAC9B,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAc,EAAE,GAAM,EAAE,KAAQ,EAAQ,EAAE;IACrE,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AACrB,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAO,GAAc,EAAE,GAAM,EAAQ,EAAE;IACnE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AACjB,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAc,EAAE,GAAM,EAAW,EAAE;IAC9D,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AACrB,CAAC,CAAA"}
+{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../gs/builtin/map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAoB,EAAE;IAC3C,OAAO,IAAI,GAAG,EAAQ,CAAA;AACxB,CAAC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,GAAqB,EACrB,GAAM,EACN,YAAe;IAEf,MAAM,MAAM,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;IAC5B,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,CAAC,GAAI,CAAC,GAAG,CAAC,GAAG,CAAE,EAAE,IAAI,CAAC,CAAA;IAC/B,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;IAC9B,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAqB,EAAE,GAAM,EAAE,KAAQ,EAAQ,EAAE;IAC5E,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAA;IACtC,CAAC;IACD,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AACrB,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAO,GAAqB,EAAE,GAAM,EAAQ,EAAE;IAC1E,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;AAClB,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAqB,EAAE,GAAM,EAAW,EAAE;IACrE,OAAO,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,CAAA;AAC/B,CAAC,CAAA"}

package/dist/gs/builtin/slice.d.ts

@@ -102,6 +102,13 @@ export declare function index<T>(collection: string | Slice<T> | T[], index: num
  * @returns An array of numbers representing the Unicode code points.
  */
 export declare const stringToRunes: (str: string) => number[];
+/**
+ * Converts a single-character string to its Unicode code point (rune).
+ * Used for readable rune constants like $.stringToRune('/') instead of 47.
+ * @param str A single-character string.
+ * @returns The Unicode code point as a number.
+ */
+export declare const stringToRune: (str: string) => number;
 /**
  * Converts an array of Unicode code points (runes) to a string.
  * @param runes The input array of numbers representing Unicode code points.

package/dist/gs/builtin/slice.js

@@ -793,6 +793,18 @@ export function index(collection, index) {
 export const stringToRunes = (str) => {
     return Array.from(str).map((c) => c.codePointAt(0) || 0);
 };
+/**
+ * Converts a single-character string to its Unicode code point (rune).
+ * Used for readable rune constants like $.stringToRune('/') instead of 47.
+ * @param str A single-character string.
+ * @returns The Unicode code point as a number.
+ */
+export const stringToRune = (str) => {
+    if (str.length === 0) {
+        return 0;
+    }
+    return str.codePointAt(0) || 0;
+};
 /**
  * Converts an array of Unicode code points (runes) to a string.
  * @param runes The input array of numbers representing Unicode code points.