batteries

var Builtins_auditd = map[string]*env.Builtin{
	"parse-line": {
		Argsn: 1,
		Doc:   "Parses a single auditd log line into a dict using go-libaudit auparse.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, _ env.Object, _ env.Object, _ env.Object, _ env.Object) env.Object {
			switch s := arg0.(type) {
			case env.String:
				m := parseLineWithAuparse(s.Value)
				if m == nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "malformed auditd line", "auditd-parse-line")
				}
				return *env.NewDict(m)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "auditd-parse-line")
			}
		},
	},
	"parse-file": {
		Argsn: 1,
		Doc:   "Parses all lines of an auditd log file into a block of dicts using go-libaudit auparse.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, _ env.Object, _ env.Object, _ env.Object, _ env.Object) env.Object {
			switch u := arg0.(type) {
			case env.Uri:
				path := resolveAuditPath(ps.WorkingPath, u.GetPath())
				f, err := os.Open(path)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, err.Error(), "auditd-parse-file")
				}
				defer f.Close()
				scanner := bufio.NewScanner(f)
				var items []env.Object
				for scanner.Scan() {
					if m := parseLineWithAuparse(scanner.Text()); m != nil {
						items = append(items, *env.NewDict(m))
					}
				}
				if err := scanner.Err(); err != nil {
					return evaldo.MakeBuiltinError(ps, err.Error(), "auditd-parse-file")
				}
				return *env.NewBlock(*env.NewTSeries(items))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.UriType}, "auditd-parse-file")
			}
		},
	},
	"tail-parse": {
		Argsn: 2,
		Doc:   "Parses the last N lines of an auditd log file into a block of dicts using go-libaudit auparse.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, _ env.Object, _ env.Object, _ env.Object) env.Object {
			switch u := arg0.(type) {
			case env.Uri:
				path := resolveAuditPath(ps.WorkingPath, u.GetPath())
				lim, ok := arg1.(env.Integer)
				if !ok {
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "auditd-tail-parse")
				}
				lines, err := tailLastNLines(path, int(lim.Value))
				if err != nil {
					return evaldo.MakeBuiltinError(ps, err.Error(), "auditd-tail-parse")
				}
				items := make([]env.Object, 0, len(lines))
				for _, line := range lines {
					if m := parseLineWithAuparse(line); m != nil {
						items = append(items, *env.NewDict(m))
					}
				}
				return *env.NewBlock(*env.NewTSeries(items))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.UriType}, "auditd-tail-parse")
			}
		},
	},
}

var Builtins_bcrypt = map[string]*env.Builtin{

	"bcrypt-hash": {
		Argsn: 1,
		Doc:   "Generates a bcrypt hash from a password string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __bcrypt_hash(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"bcrypt-check": {
		Argsn: 2,
		Doc:   "Compares a bcrypt hash with a plain text password.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __bcrypt_check(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"generate-token": {
		Argsn: 1,
		Doc:   "Generates a cryptographically secure random token of the specified length in bytes.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __generate_token(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},
}

var Builtins_bson = map[string]*env.Builtin{

	"from-bson": {
		Argsn: 1,
		Doc:   "Decodes BSON data into Rye values.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var val map[string]any

			err := bson.Unmarshal(arg0.(env.Bytes).Value, &val)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "from-bson")
			}

			return BsonToValue_Map(ps, val["val"], val["typ"].(string), val["met"], true)

		},
	},

	"to-bson": {
		Argsn: 1,
		Doc:   "Encodes a Rye value into BSON format.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			value := ValueToBSON(arg0, true)
			encoded, err := bson.Marshal(value)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "to-bson")
			}
			return *env.NewBytes(encoded)
		},
	},
}

var Builtins_chitosocket = map[string]*env.Builtin{

	"chitosocket": {
		Argsn: 1,
		Doc:   "Creates a new ChitoSocket WebSocket server with the specified number of CPU cores.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cores := arg0.(type) {
			case env.Integer:
				socket, err := chitosocket.StartUp(int(cores.Value))
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, err.Error(), "chitosocket")
				}
				return *env.NewNative(ps.Idx, socket, "Chitosocket-server")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "chitosocket")
			}
		},
	},

	"Chitosocket-server//close": {
		Argsn: 1,
		Doc:   "Closes the ChitoSocket server and releases resources.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				sock := server.Value.(*chitosocket.Socket)
				err := sock.Close()
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//close")
				}
				return *env.NewInteger(1)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//close")
			}
		},
	},

	"Chitosocket-server//on": {
		Argsn: 3,
		Doc:   "Registers an event handler for the specified event name. Handler receives subscriber and data as arguments.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch eventName := arg1.(type) {
				case env.String:
					switch handler := arg2.(type) {
					case env.Function:
						sock := server.Value.(*chitosocket.Socket)
						sock.On[eventName.Value] = func(sub *chitosocket.Subscriber, data []byte) {

							ps.FailureFlag = false
							ps.ErrorFlag = false
							ps.ReturnFlag = false

							subNative := *env.NewNative(ps.Idx, sub, "Chitosocket-subscriber")
							dataStr := *env.NewString(string(data))

							evaldo.CallFunctionArgs2(handler, ps, subNative, dataStr, nil)
						}
						return arg0
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.FunctionType}, "Chitosocket-server//on")
					}
				case env.Word:
					switch handler := arg2.(type) {
					case env.Function:
						sock := server.Value.(*chitosocket.Socket)
						eventNameStr := ps.Idx.GetWord(eventName.Index)
						sock.On[eventNameStr] = func(sub *chitosocket.Subscriber, data []byte) {
							ps.FailureFlag = false
							ps.ErrorFlag = false
							ps.ReturnFlag = false

							subNative := *env.NewNative(ps.Idx, sub, "Chitosocket-subscriber")
							dataStr := *env.NewString(string(data))

							evaldo.CallFunctionArgs2(handler, ps, subNative, dataStr, nil)
						}
						return arg0
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.FunctionType}, "Chitosocket-server//on")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType, env.WordType}, "Chitosocket-server//on")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//on")
			}
		},
	},

	"Chitosocket-server//upgrade-connection": {
		Argsn: 3,
		Doc:   "Upgrades an HTTP connection to WebSocket. Returns a block with connection, response writer, and subscriber.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch req := arg1.(type) {
				case env.Native:
					switch w := arg2.(type) {
					case env.Native:
						sock := server.Value.(*chitosocket.Socket)

						httpReq, ok1 := req.Value.(*http.Request)
						httpWriter, ok2 := w.Value.(http.ResponseWriter)

						if !ok1 || !ok2 {
							ps.FailureFlag = true
							return evaldo.MakeBuiltinError(ps, "Invalid HTTP request or response writer types", "Chitosocket-server//upgrade-connection")
						}

						conn, rw, sub, err := sock.UpgradeConnection(httpReq, httpWriter)
						if err != nil {
							ps.FailureFlag = true
							return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//upgrade-connection")
						}

						result := make([]env.Object, 3)
						result[0] = *env.NewNative(ps.Idx, conn, "Chitosocket-connection")
						result[1] = *env.NewNative(ps.Idx, rw, "Chitosocket-response-writer")
						result[2] = *env.NewNative(ps.Idx, sub, "Chitosocket-subscriber")

						return *env.NewBlock(*env.NewTSeries(result))
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.NativeType}, "Chitosocket-server//upgrade-connection")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-server//upgrade-connection")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//upgrade-connection")
			}
		},
	},

	"Chitosocket-server//emit-direct": {
		Argsn: 4,
		Doc:   "Emits an event directly to a specific subscriber with the given data.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch sub := arg1.(type) {
				case env.Native:
					switch eventName := arg2.(type) {
					case env.String:
						sock := server.Value.(*chitosocket.Socket)
						subscriber := sub.Value.(*chitosocket.Subscriber)

						var dataBytes []byte
						switch data := arg3.(type) {
						case env.String:
							dataBytes = []byte(data.Value)
						case env.Dict:
							jsonData, err := json.Marshal(data.Data)
							if err != nil {
								ps.FailureFlag = true
								return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//emit-direct")
							}
							dataBytes = jsonData
						default:
							dataBytes = []byte(arg3.Inspect(*ps.Idx))
						}

						sock.EmitDirect(subscriber, eventName.Value, dataBytes)
						return *env.NewInteger(1)
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "Chitosocket-server//emit-direct")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-server//emit-direct")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//emit-direct")
			}
		},
	},

	"Chitosocket-server//emit": {
		Argsn: 4,
		Doc:   "Emits an event to all subscribers in a specific room (excluding none).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch eventName := arg1.(type) {
				case env.String:
					switch room := arg3.(type) {
					case env.String:
						sock := server.Value.(*chitosocket.Socket)

						var dataBytes []byte
						switch data := arg2.(type) {
						case env.String:
							dataBytes = []byte(data.Value)
						case env.Dict:
							jsonData, err := json.Marshal(data.Data)
							if err != nil {
								ps.FailureFlag = true
								return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//emit")
							}
							dataBytes = jsonData
						default:
							dataBytes = []byte(arg2.Inspect(*ps.Idx))
						}

						sock.Emit(eventName.Value, nil, dataBytes, room.Value)
						return *env.NewInteger(1)
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 4, []env.Type{env.StringType}, "Chitosocket-server//emit")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "Chitosocket-server//emit")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//emit")
			}
		},
	},

	"Chitosocket-server//broadcast": {
		Argsn: 3,
		Doc:   "Broadcasts an event to all connected subscribers.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch eventName := arg1.(type) {
				case env.String:
					sock := server.Value.(*chitosocket.Socket)

					var dataBytes []byte
					switch data := arg2.(type) {
					case env.String:
						dataBytes = []byte(data.Value)
					case env.Dict:
						jsonData, err := json.Marshal(data.Data)
						if err != nil {
							ps.FailureFlag = true
							return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//broadcast")
						}
						dataBytes = jsonData
					default:
						dataBytes = []byte(arg2.Inspect(*ps.Idx))
					}

					sock.Broadcast(eventName.Value, dataBytes)
					return *env.NewInteger(1)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "Chitosocket-server//broadcast")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//broadcast")
			}
		},
	},

	"Chitosocket-server//add-to-room": {
		Argsn: 3,
		Doc:   "Adds a subscriber to a room.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch sub := arg1.(type) {
				case env.Native:
					switch room := arg2.(type) {
					case env.String:
						sock := server.Value.(*chitosocket.Socket)
						subscriber := sub.Value.(*chitosocket.Subscriber)
						sock.AddToRoom(subscriber, room.Value)
						return *env.NewInteger(1)
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "Chitosocket-server//add-to-room")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-server//add-to-room")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//add-to-room")
			}
		},
	},

	"Chitosocket-server//remove-from-room": {
		Argsn: 3,
		Doc:   "Removes a subscriber from a room.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch sub := arg1.(type) {
				case env.Native:
					switch room := arg2.(type) {
					case env.String:
						sock := server.Value.(*chitosocket.Socket)
						subscriber := sub.Value.(*chitosocket.Subscriber)
						sock.RemoveFromRoom(subscriber, room.Value)
						return *env.NewInteger(1)
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "Chitosocket-server//remove-from-room")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-server//remove-from-room")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//remove-from-room")
			}
		},
	},

	"Chitosocket-server//room-count?": {
		Argsn: 2,
		Doc:   "Returns the number of subscribers in a room.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch room := arg1.(type) {
				case env.String:
					sock := server.Value.(*chitosocket.Socket)
					count := sock.GetRoomCount(room.Value)
					return *env.NewInteger(int64(count))
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "Chitosocket-server//room-count?")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//room-count?")
			}
		},
	},

	"Chitosocket-subscriber//id?": {
		Argsn: 1,
		Doc:   "Returns the unique ID of the subscriber.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch sub := arg0.(type) {
			case env.Native:
				subscriber := sub.Value.(*chitosocket.Subscriber)
				return *env.NewString(subscriber.ID)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-subscriber//id?")
			}
		},
	},

	"Chitosocket-server//handler?": {
		Argsn: 2,
		Doc:   "Returns the handler function for a specific event, or void if not set.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch eventName := arg1.(type) {
				case env.String:
					sock := server.Value.(*chitosocket.Socket)
					if handler, ok := sock.On[eventName.Value]; ok {
						return *env.NewNative(ps.Idx, handler, "Chitosocket-handler")
					}
					return env.Void{}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "Chitosocket-server//handler?")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//handler?")
			}
		},
	},

	"Chitosocket-handler//call": {
		Argsn: 3,
		Doc:   "Calls a handler function with the given subscriber and data.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch handler := arg0.(type) {
			case env.Native:
				switch sub := arg1.(type) {
				case env.Native:
					handlerFn := handler.Value.(chitosocket.HandlerFunc)
					subscriber := sub.Value.(*chitosocket.Subscriber)

					var dataBytes []byte
					switch data := arg2.(type) {
					case env.String:
						dataBytes = []byte(data.Value)
					case env.Void:
						dataBytes = nil
					default:
						dataBytes = []byte(arg2.Inspect(*ps.Idx))
					}

					handlerFn(subscriber, dataBytes)
					return *env.NewInteger(1)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-handler//call")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-handler//call")
			}
		},
	},

	"Chitosocket-server//remove": {
		Argsn: 2,
		Doc:   "Removes a subscriber from the server.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch server := arg0.(type) {
			case env.Native:
				switch sub := arg1.(type) {
				case env.Native:
					sock := server.Value.(*chitosocket.Socket)
					subscriber := sub.Value.(*chitosocket.Subscriber)
					err := sock.Remove(subscriber)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, err.Error(), "Chitosocket-server//remove")
					}
					return *env.NewInteger(1)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "Chitosocket-server//remove")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Chitosocket-server//remove")
			}
		},
	},
}

var Builtins_cli = map[string]*env.Builtin{

	"parse-args": {
		Argsn: 2,
		Doc:   "Parses command line arguments according to a specification block, returning a dictionary with the parsed values.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return BuiParseArgs(es, arg0, arg1)
		},
	},

	"parse-args\\ctx": {
		Argsn: 2,
		Doc:   "Parses command line arguments according to a specification block, returning a context for easy field access.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			result := BuiParseArgs(es, arg0, arg1)
			if es.FailureFlag || es.ErrorFlag || es.ReturnFlag {
				return result
			}
			switch dict := result.(type) {
			case env.Dict:

				ctx := env.NewEnv(es.Ctx)
				for k, v := range dict.Data {
					idx := es.Idx.IndexWord(k)
					if obj, ok := v.(env.Object); ok {
						ctx.Set(idx, obj)
					} else {
						ctx.Set(idx, env.ToRyeValue(v))
					}
				}
				return ctx
			default:
				return result
			}
		},
	},

	"parse-args\\full": {
		Argsn: 2,
		Doc:   "Parses command line arguments and on failure prints parse errors plus generated help, returning the parsed Dict or help text.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return BuiParseArgsFull(es, arg0, arg1)
		},
	},

	"Rye-itself//Parse-args\\full": {
		Argsn: 2,
		Doc:   "Parses process arguments using a CLI specification, printing parse errors and generated help on failure. Equivalent to rye .Args? |parse-args spec with automatic error/help output.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return BuiParseArgsFull(es, ryeItselfArgsForCLI(es), arg1)
		},
	},

	"generate-help": {
		Argsn: 1,
		Doc:   "Generates help text from a CLI specification block.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			spec, ok := arg0.(env.Block)
			if !ok {
				es.FailureFlag = true
				return evaldo.MakeArgError(es, 1, []env.Type{env.BlockType}, "generate-help")
			}

			cliSpec, err := CLI_ParseSpec(es, spec)
			if err != nil {
				es.FailureFlag = true
				return env.NewError2(400, "spec error: "+err.Error())
			}

			helpText := generateHelpText(es, cliSpec, nil)
			return *env.NewString(helpText)
		},
	},

	"generate-help\\command": {
		Argsn: 2,
		Doc:   "Generates help text for a specific subcommand.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			spec, ok := arg0.(env.Block)
			if !ok {
				es.FailureFlag = true
				return evaldo.MakeArgError(es, 1, []env.Type{env.BlockType}, "generate-help\\command")
			}

			cmdPath := make([]string, 0)
			switch cmd := arg1.(type) {
			case env.String:
				if cmd.Value != "" {
					cmdPath = strings.Split(cmd.Value, " ")
				}
			case env.Block:
				ser := cmd.Series
				ser.Reset()
				for ser.Pos() < ser.Len() {
					obj := ser.Pop()
					if s, ok := obj.(env.String); ok {
						cmdPath = append(cmdPath, s.Value)
					} else if w, ok := obj.(env.Word); ok {
						cmdPath = append(cmdPath, es.Idx.GetWord(w.Index))
					}
				}
			default:
				es.FailureFlag = true
				return evaldo.MakeArgError(es, 2, []env.Type{env.StringType, env.BlockType}, "generate-help\\command")
			}

			cliSpec, err := CLI_ParseSpec(es, spec)
			if err != nil {
				es.FailureFlag = true
				return env.NewError2(400, "spec error: "+err.Error())
			}

			helpText := generateHelpText(es, cliSpec, cmdPath)
			return *env.NewString(helpText)
		},
	},

	"format-parse-errors": {
		Argsn: 1,
		Doc:   "Formats parse errors into human-readable messages.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch errObj := arg0.(type) {
			case env.Dict:
				errors := make(map[string]env.Object)
				for k, v := range errObj.Data {
					if obj, ok := v.(env.Object); ok {
						errors[k] = obj
					}
				}
				return *env.NewString(formatParseErrors(errors))
			case *env.Error:

				if errObj.Values != nil {
					return *env.NewString(formatParseErrors(errObj.Values))
				}
				return *env.NewString(errObj.Message)
			default:
				es.FailureFlag = true
				return evaldo.MakeArgError(es, 1, []env.Type{env.DictType}, "format-parse-errors")
			}
		},
	},
}

var Builtins_complex = map[string]*env.Builtin{

	"complex": {
		Argsn: 2,
		Doc:   "Creates a complex number from real and imaginary parts.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var real, imag float64

			switch r := arg0.(type) {
			case env.Integer:
				real = float64(r.Value)
			case env.Decimal:
				real = r.Value
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "complex")
			}

			switch i := arg1.(type) {
			case env.Integer:
				imag = float64(i.Value)
			case env.Decimal:
				imag = i.Value
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "complex")
			}

			return *env.NewComplexFromParts(real, imag)
		},
	},

	"complex?": {
		Argsn: 1,
		Doc:   "Checks if a value is a complex number.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			_, ok := arg0.(env.Complex)
			return *env.NewBoolean(ok)
		},
	},

	"real": {
		Argsn: 1,
		Doc:   "Returns the real part of a complex number.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch c := arg0.(type) {
			case env.Complex:
				return *env.NewDecimal(real(c.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.ComplexType}, "real")
			}
		},
	},

	"imag": {
		Argsn: 1,
		Doc:   "Returns the imaginary part of a complex number.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch c := arg0.(type) {
			case env.Complex:
				return *env.NewDecimal(imag(c.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.ComplexType}, "imag")
			}
		},
	},

	"complex-conj": {
		Argsn: 1,
		Doc:   "Returns the complex conjugate of a complex number.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch z := arg0.(type) {
			case env.Complex:
				return *env.NewComplex(cmplx.Conj(z.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.ComplexType}, "complex-conj")
			}
		},
	},

	"complex-phase": {
		Argsn: 1,
		Doc:   "Returns the phase (argument) of a complex number.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch z := arg0.(type) {
			case env.Complex:
				return *env.NewDecimal(cmplx.Phase(z.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.ComplexType}, "complex-phase")
			}
		},
	},
}

var Builtins_console = map[string]*env.Builtin{

	"enter-console": {
		Argsn: 1,
		Doc:   "Stops execution and gives you an interactive Rye console to test code in the current environment.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch name := arg0.(type) {
			case env.String:
				ser := ps.Ser

				fmt.Println("Welcome to console: \033[1m" + name.Value + "\033[0m")
				fmt.Println("* use \033[1mlc\033[0m to list current context")
				fmt.Println("-------------------------------------------------------------")

				console.DoRyeRepl(ps, "rye", evaldo.ShowResults, false, "")
				fmt.Println("-------------------------------------------------------------")
				ps.Ser = ser
				return ps.Res
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "enter-console")
			}
		},
	},
}

var Builtins_control = map[string]*env.Builtin{
	"case": {
		Argsn: 1,
		Doc:   "Evaluates condition expressions followed by action blocks. Returns the result of the first block whose condition is boolean true, or the default block marked with _ if no condition matches. Returns void if none match. Non-boolean conditions fail.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			pairs, ok := arg0.(env.Block)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "case")
			}

			ser := ps.Ser
			defer func() { ps.Ser = ser }()
			ps.Ser = pairs.Series
			for ps.Ser.Pos() < ps.Ser.Len() {

				_, isDefault := ps.Ser.Peek().(env.Void)
				condition := env.Boolean{Value: isDefault}
				if isDefault {
					ps.Ser.Pop()
				} else {

					evaldo.EvalExpression_CollectArg(ps, false, false)
					if ps.ErrorFlag || ps.FailureFlag || ps.ReturnFlag {
						return ps.Res
					}
					var ok bool
					condition, ok = ps.Res.(env.Boolean)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "Condition must evaluate to boolean", "case")
					}
				}
				if ps.Ser.Pos() >= ps.Ser.Len() {
					return evaldo.MakeBuiltinError(ps, "Expected block after condition", "case")
				}
				action, ok := ps.Ser.Pop().(env.Block)
				if !ok {
					return evaldo.MakeBuiltinError(ps, "Expected block after condition", "case")
				}
				if condition.Value {
					ps.Ser = action.Series
					ps.Res = *env.NewVoid()
					evaldo.EvalBlockInj(ps, nil, false)
					return ps.Res
				}
				evaldo.MaybeAcceptComma(ps, nil, false)
			}
			return *env.NewVoid()
		},
	},
}

var Builtins_conversion = map[string]*env.Builtin{

	"convert": {
		Argsn: 2,
		Doc:   "Converts value from one kind to another based on a conversion specification block.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return BuiConvert(ps, arg0, arg1)
		},
	},

	"converter": {
		Argsn: 3,
		Doc:   "Registers a converter between two kinds of objects.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {

			switch obj1 := arg0.(type) {
			case env.Kind:
				switch obj2 := arg1.(type) {
				case env.Kind:
					switch spec := arg2.(type) {
					case env.Block:
						obj2.SetConverter(obj1.Kind.Index, spec)
						return obj2
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.BlockType}, "converter")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.KindType, env.BlockType}, "converter")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.KindType}, "converter")
			}
		},
	},
}

var Builtins_crypto = map[string]*env.Builtin{

	"Ed25519-pub-key//To-string": {
		Argsn: 1,
		Doc:   "Converts an Ed25519 public key to its hexadecimal string representation.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch addr := arg0.(type) {
			case env.Native:
				return *env.NewString(hex.EncodeToString(addr.Value.(ed25519.PublicKey)))
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Ed25519-pub-key//To-string")
			}
		},
	},

	"Ed25519-priv-key//To-string": {
		Argsn: 1,
		Doc:   "Converts an Ed25519 private key to its hexadecimal string representation.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch addr := arg0.(type) {
			case env.Native:
				return *env.NewString(hex.EncodeToString(addr.Value.(ed25519.PrivateKey)))
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Ed25519-priv-key//To-string")
			}
		},
	},

	"ed25519-generate-keys": {
		Argsn: 0,
		Doc:   "Generates a new Ed25519 key pair and returns them in a block with public key first, then private key.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			keys := make([]env.Object, 2)
			puk, pvk, err := ed25519.GenerateKey(nil)
			if err != nil {
				ps.FailureFlag = true
				return evaldo.MakeBuiltinError(ps, "Failed to generate keys.", "ed25519-generate-keys")
			}
			keys[0] = *env.NewNative(ps.Idx, puk, "Ed25519-pub-key")
			keys[1] = *env.NewNative(ps.Idx, pvk, "Ed25519-priv-key")
			ser := *env.NewTSeries(keys)
			return *env.NewBlock(ser)
		},
	},

	"ed25519-private-key": {
		Argsn: 1,
		Doc:   "Creates an Ed25519 private key from a hexadecimal string or bytes value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var pkey []byte
			var err error
			switch server := arg0.(type) {
			case env.Native:
				pkey = server.Value.([]byte)
			case env.String:
				pkey, err = hex.DecodeString(server.Value)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in decoding string.", "ed25519-private-key")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType, env.StringType}, "ed25519-private-key")
			}
			return *env.NewNative(ps.Idx, ed25519.PrivateKey(pkey), "Ed25519-priv-key")

		},
	},

	"ed25519-public-key": {
		Argsn: 1,
		Doc:   "Creates an Ed25519 public key from a hexadecimal string or bytes value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var pkey []byte
			var err error
			switch server := arg0.(type) {
			case env.Native:
				pkey = server.Value.([]byte)
			case env.String:
				pkey, err = hex.DecodeString(server.Value)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in decoding string.", "ed25519-public-key")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType, env.StringType}, "ed25519-public-key")
			}
			return *env.NewNative(ps.Idx, ed25519.PublicKey(pkey), "Ed25519-pub-key")

		},
	},

	"Ed25519-priv-key//Sign": {
		Argsn: 2,
		Doc:   "Signs a string message with an Ed25519 private key and returns the signature as bytes.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch pvk := arg0.(type) {
			case env.Native:
				switch buff := arg1.(type) {
				case env.String:
					sigb := ed25519.Sign(pvk.Value.(ed25519.PrivateKey), []byte(buff.Value))
					return *env.NewBytes(sigb)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "Ed25519-priv-key//Sign")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Ed25519-priv-key//Sign")
			}
		},
	},

	"md5": {
		Argsn: 1,
		Doc:   "Calculates the MD5 hash of a string or bytes and returns the result as a hexadecimal string. MD5 is not suitable for security-sensitive use.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, md5.New, "md5")
		},
	},

	"sha1": {
		Argsn: 1,
		Doc:   "Calculates the SHA-1 hash of a string or bytes and returns the result as a hexadecimal string. SHA-1 is not suitable for security-sensitive use.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, sha1.New, "sha1")
		},
	},

	"sha224": {
		Argsn: 1,
		Doc:   "Calculates the SHA-224 hash of a string or bytes and returns the result as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, sha256.New224, "sha224")
		},
	},

	"sha256": {
		Argsn: 1,
		Doc:   "Calculates the SHA-256 hash of a string or bytes and returns the result as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, sha256.New, "sha256")
		},
	},

	"sha384": {
		Argsn: 1,
		Doc:   "Calculates the SHA-384 hash of a string or bytes and returns the result as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, sha512.New384, "sha384")
		},
	},

	"sha512": {
		Argsn: 1,
		Doc:   "Calculates the SHA-512 hash of a string or bytes and returns the result as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, sha512.New, "sha512")
		},
	},

	"crc32": {
		Argsn: 1,
		Doc:   "Calculates the CRC-32 (IEEE) checksum of a string or bytes and returns it as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, func() hash.Hash { return crc32.NewIEEE() }, "crc32")
		},
	},

	"adler32": {
		Argsn: 1,
		Doc:   "Calculates the Adler-32 checksum of a string or bytes and returns it as a hexadecimal string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return hashToHex(ps, arg0, func() hash.Hash { return adler32.New() }, "adler32")
		},
	},

	"age-generate-keys": {
		Argsn: 0,
		Doc:   "Generates a new age key pair (identity and recipient).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			identity, err := age.GenerateX25519Identity()
			if err != nil {
				ps.FailureFlag = true
				return evaldo.MakeBuiltinError(ps, "Failed to generate key pair.", "age-generate-keys")
			}
			keys := make([]env.Object, 2)
			keys[0] = *env.NewNative(ps.Idx, identity, "age-identity")
			keys[1] = *env.NewNative(ps.Idx, identity.Recipient(), "age-recipient")
			ser := *env.NewTSeries(keys)
			return *env.NewBlock(ser)
		},
	},

	"age-identity": {
		Argsn: 1,
		Doc:   "Creates an age identity from a string or bytes.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var identity *age.X25519Identity
			var err error
			switch ident := arg0.(type) {
			case env.Bytes:
				identity, err = age.ParseX25519Identity(hex.EncodeToString(ident.Value))
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in parsing identity: "+err.Error(), "age-identity")
				}
			case env.String:
				identity, err = age.ParseX25519Identity(ident.Value)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in decoding string: "+err.Error(), "age-identity")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BytesType, env.StringType}, "age-identity")
			}
			return *env.NewNative(ps.Idx, identity, "age-identity")
		},
	},

	"age-recipient": {
		Argsn: 1,
		Doc:   "Creates an age recipient from a string or bytes.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var recipient *age.X25519Recipient
			var err error
			switch rec := arg0.(type) {
			case env.Bytes:
				recipient, err = age.ParseX25519Recipient(hex.EncodeToString(rec.Value))
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in parsing recipient: "+err.Error(), "age-recipient")
				}
			case env.String:
				recipient, err = age.ParseX25519Recipient(rec.Value)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in decoding string: "+err.Error(), "age-recipient")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BytesType, env.StringType}, "age-recipient")
			}
			return *env.NewNative(ps.Idx, recipient, "age-recipient")
		},
	},

	"age-encrypt": {
		Argsn: 2,
		Doc:   "Encrypts a reader with age for the provided age recipient or string password and returns a reader.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch r := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(r.GetKind()) != "reader" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-encrypt")
				}
				reader := r.Value.(io.Reader)
				var recipient age.Recipient
				switch rec := arg1.(type) {
				case env.Native:
					if ps.Idx.GetWord(rec.GetKind()) != "age-recipient" {
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-encrypt")
					}
					recipient = rec.Value.(*age.X25519Recipient)
				case env.String:
					var err error
					recipient, err = age.NewScryptRecipient(rec.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, "Error in creating recipient: "+err.Error(), "age-encrypt")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType, env.StringType}, "age-encrypt")
				}
				buf := new(bytes.Buffer)
				w, err := age.Encrypt(buf, recipient)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in encrypting: "+err.Error(), "age-encrypt")
				}

				data, err := io.ReadAll(reader)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error reading from reader: "+err.Error(), "age-encrypt")
				}

				if _, err := w.Write(data); err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in writing to buffer: "+err.Error(), "age-encrypt")
				}
				w.Close()
				return *env.NewNative(ps.Idx, bytes.NewReader(buf.Bytes()), "reader")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-encrypt")
			}
		},
	},

	"age-decrypt": {
		Argsn: 2,
		Doc:   "Decrypts a reader with age using the provided age identity or string password and returns a reader with the decrypted content.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch r := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(r.GetKind()) != "reader" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-decrypt")
				}
				reader := r.Value.(io.Reader)
				var identity age.Identity
				switch ident := arg1.(type) {
				case env.Native:
					if ps.Idx.GetWord(ident.GetKind()) != "age-identity" {
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-decrypt")
					}
					identity = ident.Value.(*age.X25519Identity)
				case env.String:
					var err error
					identity, err = age.NewScryptIdentity(ident.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, "Error in creating identity: "+err.Error(), "age-decrypt")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType, env.StringType}, "age-decrypt")
				}
				decrypted, err := age.Decrypt(reader, identity)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Error in decrypting: "+err.Error(), "age-decrypt")
				}
				return *env.NewNative(ps.Idx, decrypted, "reader")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "age-decrypt")
			}
		},
	},

	"pkcs12-to-pem": {
		Argsn: 2,
		Doc:   "Converts a PKCS#12 (.p12) file bytes to PEM blocks using the provided password. Returns a block of pem-block native values.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch p12Data := arg0.(type) {
			case env.Bytes:
				switch password := arg1.(type) {
				case env.String:
					blocks, err := pkcs12.ToPEM(p12Data.Value, password.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to convert .p12 to PEM: %v", err), "pkcs12-to-pem")
					}

					objects := make([]env.Object, len(blocks))
					for i, block := range blocks {
						objects[i] = *env.NewNative(ps.Idx, block, "pem-block")
					}
					ser := *env.NewTSeries(objects)
					return *env.NewBlock(ser)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "pkcs12-to-pem")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BytesType}, "pkcs12-to-pem")
			}
		},
	},

	"pkcs12-decode": {
		Argsn: 2,
		Doc:   "Decodes a PKCS#12 (.p12) file bytes into private key and certificates using the provided password. Returns a block with [private-key, certificates, ca-certificates].",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch p12Data := arg0.(type) {
			case env.Bytes:
				switch password := arg1.(type) {
				case env.String:
					key, cert, caCerts, err := sslmate.DecodeChain(p12Data.Value, password.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to decode .p12: %v", err), "pkcs12-decode")
					}

					certObjects := make([]env.Object, 0)
					if cert != nil {
						certObjects = append(certObjects, *env.NewNative(ps.Idx, cert, "x509-certificate"))
					}
					certSer := *env.NewTSeries(certObjects)
					certBlock := *env.NewBlock(certSer)

					caCertObjects := make([]env.Object, len(caCerts))
					for i, caCert := range caCerts {
						caCertObjects[i] = *env.NewNative(ps.Idx, caCert, "x509-certificate")
					}
					caCertSer := *env.NewTSeries(caCertObjects)
					caCertBlock := *env.NewBlock(caCertSer)

					objects := make([]env.Object, 3)
					if key != nil {
						objects[0] = *env.NewNative(ps.Idx, key, "private-key")
					} else {
						objects[0] = *env.NewNative(ps.Idx, nil, "private-key")
					}
					objects[1] = certBlock
					objects[2] = caCertBlock
					ser := *env.NewTSeries(objects)
					return *env.NewBlock(ser)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "pkcs12-decode")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BytesType}, "pkcs12-decode")
			}
		},
	},

	"pem-block//Block-type?": {
		Argsn: 1,
		Doc:   "Returns the type of a PEM block as a string (e.g., 'CERTIFICATE', 'RSA PRIVATE KEY').",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch certData := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(certData.GetKind()) != "pem-block" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
				}
				pb, ok := certData.Value.(*pem.Block)
				if ok {
					return *env.NewString(pb.Type)
				}
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to parse certificate"), "x509-parse-certificate")

			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
			}
		},
	},

	"pem-block//Headers?": {
		Argsn: 1,
		Doc:   "Returns the headers of a PEM block as a dictionary.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch certData := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(certData.GetKind()) != "pem-block" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
				}
				pb, ok := certData.Value.(*pem.Block)
				if ok {
					headers := make(map[string]interface{}, len(pb.Headers))
					for k, v := range pb.Headers {
						headers[k] = v
					}
					return *env.NewDict(headers)
				}
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to parse certificate"), "x509-parse-certificate")

			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
			}
		},
	},

	"x509-parse-certificate": {
		Argsn: 1,
		Doc:   "Parses a PEM block into an X.509 certificate native value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch certData := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(certData.GetKind()) != "pem-block" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
				}
				pb, ok := certData.Value.(*pem.Block)
				if ok {
					cert, err := x509.ParseCertificate(pb.Bytes)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to parse certificate: %v", err), "x509-parse-certificate")
					}
					return *env.NewNative(ps.Idx, cert, "x509-certificate")
				}
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to parse certificate"), "x509-parse-certificate")

			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-parse-certificate")
			}
		},
	},

	"x509-certificate//Not-after?": {
		Argsn: 1,
		Doc:   "Returns the expiration date (NotAfter) of an X.509 certificate as a time value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewTime(c.NotAfter)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
			}
		},
	},

	"x509-certificate//Not-before?": {
		Argsn: 1,
		Doc:   "Returns the start date (NotBefore) of an X.509 certificate as a time value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewTime(c.NotBefore)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
			}
		},
	},

	"x509-certificate//Is-expired": {
		Argsn: 1,
		Doc:   "Checks if an X.509 certificate has expired. Returns 1 if expired, 0 otherwise.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
				}
				c := cert.Value.(*x509.Certificate)
				if time.Now().After(c.NotAfter) {
					return env.Integer{1}
				}
				return env.Integer{0}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//is-expired")
			}
		},
	},

	"generate-self-signed-certificate": {
		Argsn: 2,
		Doc:   "Generates a self-signed X.509 certificate with a new RSA key pair.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {

			switch keySize := arg0.(type) {
			case env.Integer:
				if keySize.Value < 2048 {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Key size must be at least 2048 bits", "generate-self-signed-certificate")
				}

				switch subjectDict := arg1.(type) {
				case env.Dict:

					privateKey, err := rsa.GenerateKey(rand.Reader, int(keySize.Value))
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to generate RSA key: %v", err), "generate-self-signed-certificate")
					}

					serialNumber, _ := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
					template := x509.Certificate{
						SerialNumber: serialNumber,
						Subject:      pkix.Name{},
						NotBefore:    time.Now(),
						NotAfter:     time.Now().Add(365 * 24 * time.Hour),
						KeyUsage:     x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
						ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
						IsCA:         true,
					}

					if cn, ok := subjectDict.Data["CommonName"]; ok {
						if cnStr, ok := cn.(string); ok {
							template.Subject.CommonName = cnStr
						}
					}
					if org, ok := subjectDict.Data["Organization"]; ok {
						if orgStr, ok := org.(string); ok {
							template.Subject.Organization = []string{orgStr}
						}
					}

					certBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to create certificate: %v", err), "generate-self-signed-certificate")
					}

					objects := []env.Object{
						*env.NewNative(ps.Idx, &x509.Certificate{Raw: certBytes}, "x509-certificate"),
						*env.NewNative(ps.Idx, privateKey, "rsa-private-key"),
					}
					ser := *env.NewTSeries(objects)
					return *env.NewBlock(ser)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.DictType}, "generate-self-signed-certificate")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "generate-self-signed-certificate")
			}
		},
	},

	"encode-to-pem": {
		Argsn: 2,
		Doc:   "Encodes a certificate and private key as PEM-formatted data.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch certObj := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(certObj.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "encode-to-pem")
				}
				cert := certObj.Value.(*x509.Certificate)
				switch keyObj := arg1.(type) {
				case env.Native:
					if ps.Idx.GetWord(keyObj.GetKind()) != "rsa-private-key" {
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "encode-to-pem")
					}
					privateKey := keyObj.Value.(*rsa.PrivateKey)

					certPEM := &bytes.Buffer{}
					err := pem.Encode(certPEM, &pem.Block{
						Type:  "CERTIFICATE",
						Bytes: cert.Raw,
					})
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to encode certificate to PEM: %v", err), "encode-to-pem")
					}

					keyPEM := &bytes.Buffer{}
					err = pem.Encode(keyPEM, &pem.Block{
						Type:  "RSA PRIVATE KEY",
						Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
					})
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to encode private key to PEM: %v", err), "encode-to-pem")
					}

					objects := []env.Object{
						*env.NewNative(ps.Idx, certPEM.Bytes(), "Go-bytes"),
						*env.NewNative(ps.Idx, keyPEM.Bytes(), "Go-bytes"),
					}
					ser := *env.NewTSeries(objects)
					return *env.NewBlock(ser)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "encode-to-pem")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "encode-to-pem")
			}
		},
	},

	"encode-to-p12": {
		Argsn: 3,
		Doc:   "Encodes a certificate and private key into a PKCS#12 (.p12) file with password protection.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch certObj := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(certObj.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "encode-to-p12")
				}
				cert := certObj.Value.(*x509.Certificate)
				switch keyObj := arg1.(type) {
				case env.Native:
					if ps.Idx.GetWord(keyObj.GetKind()) != "rsa-private-key" {
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "encode-to-p12")
					}
					privateKey := keyObj.Value.(*rsa.PrivateKey)
					switch password := arg2.(type) {
					case env.String:
						p12Bytes, err := sslmate.Encode(rand.Reader, privateKey, cert, nil, password.Value)
						if err != nil {
							ps.FailureFlag = true
							return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Failed to encode to .p12: %v", err), "encode-to-p12")
						}
						return *env.NewNative(ps.Idx, p12Bytes, "Go-bytes")
					default:
						ps.FailureFlag = true
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "encode-to-p12")
					}
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "encode-to-p12")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "encode-to-p12")
			}
		},
	},

	"x509-certificate//Subject?": {
		Argsn: 1,
		Doc:   "Returns the subject Distinguished Name (DN) of an X.509 certificate as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//Subject?")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewString(c.Subject.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//Subject?")
			}
		},
	},

	"x509-certificate//Issuer?": {
		Argsn: 1,
		Doc:   "Returns the issuer Distinguished Name (DN) of an X.509 certificate as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//issuer?")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewString(c.Issuer.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//issuer?")
			}
		},
	},

	"x509-certificate//Serial-number?": {
		Argsn: 1,
		Doc:   "Returns the serial number of an X.509 certificate as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//serial-number?")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewString(c.SerialNumber.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//serial-number?")
			}
		},
	},

	"x509-certificate//Signature-algorithm?": {
		Argsn: 1,
		Doc:   "Returns the signature algorithm of an X.509 certificate as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//signature-algorithm?")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewString(c.SignatureAlgorithm.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//signature-algorithm?")
			}
		},
	},

	"x509-certificate//Public-key-algorithm?": {
		Argsn: 1,
		Doc:   "Returns the public key algorithm of an X.509 certificate as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//public-key-algorithm?")
				}
				c := cert.Value.(*x509.Certificate)
				return *env.NewString(c.PublicKeyAlgorithm.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//public-key-algorithm?")
			}
		},
	},

	"x509-certificate//Key-usage?": {
		Argsn: 1,
		Doc:   "Returns the key usage flags of an X.509 certificate as a block of strings.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//key-usage?")
				}
				c := cert.Value.(*x509.Certificate)
				var usages []env.Object
				if c.KeyUsage&x509.KeyUsageDigitalSignature > 0 {
					usages = append(usages, *env.NewString("Digital Signature"))
				}
				if c.KeyUsage&x509.KeyUsageContentCommitment > 0 {
					usages = append(usages, *env.NewString("Content Commitment"))
				}
				if c.KeyUsage&x509.KeyUsageKeyEncipherment > 0 {
					usages = append(usages, *env.NewString("Key Encipherment"))
				}
				if c.KeyUsage&x509.KeyUsageDataEncipherment > 0 {
					usages = append(usages, *env.NewString("Data Encipherment"))
				}
				if c.KeyUsage&x509.KeyUsageKeyAgreement > 0 {
					usages = append(usages, *env.NewString("Key Agreement"))
				}
				if c.KeyUsage&x509.KeyUsageCertSign > 0 {
					usages = append(usages, *env.NewString("Cert Sign"))
				}
				if c.KeyUsage&x509.KeyUsageCRLSign > 0 {
					usages = append(usages, *env.NewString("CRL Sign"))
				}
				if c.KeyUsage&x509.KeyUsageEncipherOnly > 0 {
					usages = append(usages, *env.NewString("Encipher Only"))
				}
				if c.KeyUsage&x509.KeyUsageDecipherOnly > 0 {
					usages = append(usages, *env.NewString("Decipher Only"))
				}
				ser := *env.NewTSeries(usages)
				return *env.NewBlock(ser)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//key-usage?")
			}
		},
	},

	"x509-certificate//Extended-key-usage?": {
		Argsn: 1,
		Doc:   "Returns the extended key usage flags of an X.509 certificate as a block of strings.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//extended-key-usage?")
				}
				c := cert.Value.(*x509.Certificate)
				usages := make([]env.Object, len(c.ExtKeyUsage))
				for i, extKeyUsage := range c.ExtKeyUsage {
					var usageStr string
					switch extKeyUsage {
					case x509.ExtKeyUsageServerAuth:
						usageStr = "Server Authentication"
					case x509.ExtKeyUsageClientAuth:
						usageStr = "Client Authentication"
					case x509.ExtKeyUsageCodeSigning:
						usageStr = "Code Signing"
					case x509.ExtKeyUsageEmailProtection:
						usageStr = "Email Protection"
					case x509.ExtKeyUsageTimeStamping:
						usageStr = "Time Stamping"
					case x509.ExtKeyUsageOCSPSigning:
						usageStr = "OCSP Signing"
					default:
						usageStr = fmt.Sprintf("Unknown (%d)", int(extKeyUsage))
					}
					usages[i] = *env.NewString(usageStr)
				}
				ser := *env.NewTSeries(usages)
				return *env.NewBlock(ser)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//extended-key-usage?")
			}
		},
	},

	"x509-certificate//Dns-names?": {
		Argsn: 1,
		Doc:   "Returns the DNS names from Subject Alternative Names of an X.509 certificate as a block of strings.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//dns-names?")
				}
				c := cert.Value.(*x509.Certificate)
				names := make([]env.Object, len(c.DNSNames))
				for i, name := range c.DNSNames {
					names[i] = *env.NewString(name)
				}
				ser := *env.NewTSeries(names)
				return *env.NewBlock(ser)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//dns-names?")
			}
		},
	},

	"x509-certificate//Ip-addresses?": {
		Argsn: 1,
		Doc:   "Returns the IP addresses from Subject Alternative Names of an X.509 certificate as a block of strings.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//ip-addresses?")
				}
				c := cert.Value.(*x509.Certificate)
				addresses := make([]env.Object, len(c.IPAddresses))
				for i, addr := range c.IPAddresses {
					addresses[i] = *env.NewString(addr.String())
				}
				ser := *env.NewTSeries(addresses)
				return *env.NewBlock(ser)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//ip-addresses?")
			}
		},
	},

	"x509-certificate//Email-addresses?": {
		Argsn: 1,
		Doc:   "Returns the email addresses from Subject Alternative Names of an X.509 certificate as a block of strings.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//email-addresses?")
				}
				c := cert.Value.(*x509.Certificate)
				emails := make([]env.Object, len(c.EmailAddresses))
				for i, email := range c.EmailAddresses {
					emails[i] = *env.NewString(email)
				}
				ser := *env.NewTSeries(emails)
				return *env.NewBlock(ser)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//email-addresses?")
			}
		},
	},

	"x509-certificate//To-pem": {
		Argsn: 1,
		Doc:   "Converts an X.509 certificate to PEM-encoded string format.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//to-pem")
				}
				c := cert.Value.(*x509.Certificate)
				pemBlock := &pem.Block{Type: "CERTIFICATE", Bytes: c.Raw}
				pemBytes := pem.EncodeToMemory(pemBlock)
				return *env.NewString(string(pemBytes))
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//to-pem")
			}
		},
	},

	"private-key//Type?": {
		Argsn: 1,
		Doc:   "Returns the type of a private key as a string.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch key := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(key.GetKind()) != "private-key" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "private-key//type?")
				}
				return *env.NewString(fmt.Sprintf("%T", key.Value))
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "private-key//type?")
			}
		},
	},

	"x509-certificate//To-dict": {
		Argsn: 1,
		Doc:   "Converts an X.509 certificate to a dictionary containing all certificate information for easy display and manipulation.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cert := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(cert.GetKind()) != "x509-certificate" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//to-dict")
				}
				c := cert.Value.(*x509.Certificate)

				certDict := make(map[string]interface{})

				certDict["Subject"] = c.Subject.String()
				certDict["Issuer"] = c.Issuer.String()
				certDict["SerialNumber"] = c.SerialNumber.String()
				certDict["NotBefore"] = c.NotBefore.Format("2006-01-02 15:04:05 MST")
				certDict["NotAfter"] = c.NotAfter.Format("2006-01-02 15:04:05 MST")
				certDict["SignatureAlgorithm"] = c.SignatureAlgorithm.String()
				certDict["PublicKeyAlgorithm"] = c.PublicKeyAlgorithm.String()
				certDict["Version"] = int64(c.Version)
				certDict["IsCA"] = c.IsCA

				// Key Usage
				var keyUsages []interface{}
				if c.KeyUsage&x509.KeyUsageDigitalSignature > 0 {
					keyUsages = append(keyUsages, "Digital Signature")
				}
				if c.KeyUsage&x509.KeyUsageContentCommitment > 0 {
					keyUsages = append(keyUsages, "Content Commitment")
				}
				if c.KeyUsage&x509.KeyUsageKeyEncipherment > 0 {
					keyUsages = append(keyUsages, "Key Encipherment")
				}
				if c.KeyUsage&x509.KeyUsageDataEncipherment > 0 {
					keyUsages = append(keyUsages, "Data Encipherment")
				}
				if c.KeyUsage&x509.KeyUsageKeyAgreement > 0 {
					keyUsages = append(keyUsages, "Key Agreement")
				}
				if c.KeyUsage&x509.KeyUsageCertSign > 0 {
					keyUsages = append(keyUsages, "Cert Sign")
				}
				if c.KeyUsage&x509.KeyUsageCRLSign > 0 {
					keyUsages = append(keyUsages, "CRL Sign")
				}
				if c.KeyUsage&x509.KeyUsageEncipherOnly > 0 {
					keyUsages = append(keyUsages, "Encipher Only")
				}
				if c.KeyUsage&x509.KeyUsageDecipherOnly > 0 {
					keyUsages = append(keyUsages, "Decipher Only")
				}
				certDict["KeyUsage"] = keyUsages

				// Extended Key Usage
				var extKeyUsages []interface{}
				for _, extKeyUsage := range c.ExtKeyUsage {
					var usageStr string
					switch extKeyUsage {
					case x509.ExtKeyUsageServerAuth:
						usageStr = "Server Authentication"
					case x509.ExtKeyUsageClientAuth:
						usageStr = "Client Authentication"
					case x509.ExtKeyUsageCodeSigning:
						usageStr = "Code Signing"
					case x509.ExtKeyUsageEmailProtection:
						usageStr = "Email Protection"
					case x509.ExtKeyUsageTimeStamping:
						usageStr = "Time Stamping"
					case x509.ExtKeyUsageOCSPSigning:
						usageStr = "OCSP Signing"
					default:
						usageStr = fmt.Sprintf("Unknown (%d)", int(extKeyUsage))
					}
					extKeyUsages = append(extKeyUsages, usageStr)
				}
				certDict["ExtendedKeyUsage"] = extKeyUsages

				// Subject Alternative Names
				var dnsNames []interface{}
				for _, name := range c.DNSNames {
					dnsNames = append(dnsNames, name)
				}
				certDict["DNSNames"] = dnsNames

				var ipAddresses []interface{}
				for _, addr := range c.IPAddresses {
					ipAddresses = append(ipAddresses, addr.String())
				}
				certDict["IPAddresses"] = ipAddresses

				var emailAddresses []interface{}
				for _, email := range c.EmailAddresses {
					emailAddresses = append(emailAddresses, email)
				}
				certDict["EmailAddresses"] = emailAddresses

				pemBlock := &pem.Block{Type: "CERTIFICATE", Bytes: c.Raw}
				pemBytes := pem.EncodeToMemory(pemBlock)
				certDict["PEM"] = string(pemBytes)

				certDict["IsExpired"] = time.Now().After(c.NotAfter)

				return *env.NewDict(certDict)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "x509-certificate//to-dict")
			}
		},
	},
}

var Builtins_echarts = map[string]*env.Builtin{

	"bar-chart": {
		Argsn: 0,
		Doc:   "Creates a new ECharts bar chart instance.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			bar := charts.NewBar()
			return *env.NewNative(ps.Idx, bar, "echarts-bar")
		},
	},

	"bar-data": {
		Argsn: 1,
		Doc:   "Converts a block of numbers into ECharts bar data items.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch blk := arg0.(type) {
			case env.Block:
				items, err := blockToBarData(ps, blk)
				if err != nil {
					return err
				}
				return *env.NewNative(ps.Idx, items, "echarts-bar-data")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "bar-data")
			}
		},
	},

	"title-opts": {
		Argsn: 2,
		Doc:   "Creates ECharts title options with title and subtitle.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			title, ok := arg0.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "title-opts")
			}
			subtitle, ok := arg1.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "title-opts")
			}
			titleOpts := opts.Title{
				Title:    title.Value,
				Subtitle: subtitle.Value,
			}
			return *env.NewNative(ps.Idx, titleOpts, "echarts-title-opts")
		},
	},

	"with-title-opts": {
		Argsn: 1,
		Doc:   "Wraps title options into a chart global option.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch nat := arg0.(type) {
			case env.Native:
				titleOpts, ok := nat.Value.(opts.Title)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-title-opts"}, "with-title-opts")
				}
				opt := charts.WithTitleOpts(titleOpts)
				return *env.NewNative(ps.Idx, opt, "echarts-global-opts")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "with-title-opts")
			}
		},
	},

	"echarts-bar//Global-options!": {
		Argsn: 2,
		Doc:   "Sets global options on an ECharts bar chart. Accepts a single option or a block of options.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			barNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-bar//Global-options!")
			}
			bar, ok := barNat.Value.(*charts.Bar)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-bar"}, "echarts-bar//Global-options!")
			}

			// Collect options
			var gopts []charts.GlobalOpts
			switch opt := arg1.(type) {
			case env.Native:
				gopt, ok := opt.Value.(charts.GlobalOpts)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 2, []string{"echarts-global-opts"}, "echarts-bar//Global-options!")
				}
				gopts = append(gopts, gopt)
			case env.Block:
				for i := 0; i < opt.Series.Len(); i++ {
					obj := opt.Series.Get(i)
					nat, ok := obj.(env.Native)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain native echarts-global-opts", "echarts-bar//Global-options!")
					}
					gopt, ok := nat.Value.(charts.GlobalOpts)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain echarts-global-opts natives", "echarts-bar//Global-options!")
					}
					gopts = append(gopts, gopt)
				}
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType, env.BlockType}, "echarts-bar//Global-options!")
			}

			bar.SetGlobalOptions(gopts...)
			return barNat
		},
	},

	"echarts-bar//X-axis!": {
		Argsn: 2,
		Doc:   "Sets the x-axis labels on an ECharts bar chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			barNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-bar//X-axis!")
			}
			bar, ok := barNat.Value.(*charts.Bar)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-bar"}, "echarts-bar//X-axis!")
			}
			switch blk := arg1.(type) {
			case env.Block:
				labels, err := blockToStringSlice(ps, blk)
				if err != nil {
					return err
				}
				bar.SetXAxis(labels)
				return barNat
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "echarts-bar//X-axis!")
			}
		},
	},

	"echarts-bar//Add-series": {
		Argsn: 3,
		Doc:   "Adds a data series to an ECharts bar chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			barNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-bar//Add-series")
			}
			bar, ok := barNat.Value.(*charts.Bar)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-bar"}, "echarts-bar//Add-series")
			}
			name, ok := arg1.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "echarts-bar//Add-series")
			}
			dataNat, ok := arg2.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 3, []env.Type{env.NativeType}, "echarts-bar//Add-series")
			}
			data, ok := dataNat.Value.([]opts.BarData)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 3, []string{"echarts-bar-data"}, "echarts-bar//Add-series")
			}
			bar.AddSeries(name.Value, data)
			return barNat
		},
	},

	"echarts-bar//Render": {
		Argsn: 2,
		Doc:   "Renders an ECharts bar chart to a writer (file, etc.).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			barNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-bar//Render")
			}
			bar, ok := barNat.Value.(*charts.Bar)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-bar"}, "echarts-bar//Render")
			}
			writerNat, ok := arg1.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "echarts-bar//Render")
			}
			writer, ok := writerNat.Value.(io.Writer)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 2, []string{"io.Writer (e.g., file)"}, "echarts-bar//Render")
			}
			err := bar.Render(writer)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "echarts-bar//Render")
			}
			return barNat
		},
	},

	"line-chart": {
		Argsn: 0,
		Doc:   "Creates a new ECharts line chart instance.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			line := charts.NewLine()
			return *env.NewNative(ps.Idx, line, "echarts-line")
		},
	},

	"line-data": {
		Argsn: 1,
		Doc:   "Converts a block of numbers into ECharts line data items.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch blk := arg0.(type) {
			case env.Block:
				items, err := blockToLineData(ps, blk)
				if err != nil {
					return err
				}
				return *env.NewNative(ps.Idx, items, "echarts-line-data")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "line-data")
			}
		},
	},

	"echarts-line//Global-options!": {
		Argsn: 2,
		Doc:   "Sets global options on an ECharts line chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			lineNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-line//Global-options!")
			}
			line, ok := lineNat.Value.(*charts.Line)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-line"}, "echarts-line//Global-options!")
			}

			var gopts []charts.GlobalOpts
			switch opt := arg1.(type) {
			case env.Native:
				gopt, ok := opt.Value.(charts.GlobalOpts)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 2, []string{"echarts-global-opts"}, "echarts-line//Global-options!")
				}
				gopts = append(gopts, gopt)
			case env.Block:
				for i := 0; i < opt.Series.Len(); i++ {
					obj := opt.Series.Get(i)
					nat, ok := obj.(env.Native)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain native echarts-global-opts", "echarts-line//Global-options!")
					}
					gopt, ok := nat.Value.(charts.GlobalOpts)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain echarts-global-opts natives", "echarts-line//Global-options!")
					}
					gopts = append(gopts, gopt)
				}
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType, env.BlockType}, "echarts-line//Global-options!")
			}

			line.SetGlobalOptions(gopts...)
			return lineNat
		},
	},

	"echarts-line//X-axis!": {
		Argsn: 2,
		Doc:   "Sets the x-axis labels on an ECharts line chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			lineNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-line//X-axis!")
			}
			line, ok := lineNat.Value.(*charts.Line)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-line"}, "echarts-line//X-axis!")
			}
			switch blk := arg1.(type) {
			case env.Block:
				labels, err := blockToStringSlice(ps, blk)
				if err != nil {
					return err
				}
				line.SetXAxis(labels)
				return lineNat
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "echarts-line//X-axis!")
			}
		},
	},

	"echarts-line//Add-series": {
		Argsn: 3,
		Doc:   "Adds a data series to an ECharts line chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			lineNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-line//Add-series")
			}
			line, ok := lineNat.Value.(*charts.Line)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-line"}, "echarts-line//Add-series")
			}
			name, ok := arg1.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "echarts-line//Add-series")
			}
			dataNat, ok := arg2.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 3, []env.Type{env.NativeType}, "echarts-line//Add-series")
			}
			data, ok := dataNat.Value.([]opts.LineData)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 3, []string{"echarts-line-data"}, "echarts-line//Add-series")
			}
			line.AddSeries(name.Value, data)
			return lineNat
		},
	},

	"echarts-line//Render": {
		Argsn: 2,
		Doc:   "Renders an ECharts line chart to a writer (file, etc.).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			lineNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-line//Render")
			}
			line, ok := lineNat.Value.(*charts.Line)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-line"}, "echarts-line//Render")
			}
			writerNat, ok := arg1.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "echarts-line//Render")
			}
			writer, ok := writerNat.Value.(io.Writer)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 2, []string{"io.Writer"}, "echarts-line//Render")
			}
			err := line.Render(writer)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "echarts-line//Render")
			}
			return lineNat
		},
	},

	"pie-chart": {
		Argsn: 0,
		Doc:   "Creates a new ECharts pie chart instance.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			pie := charts.NewPie()
			return *env.NewNative(ps.Idx, pie, "echarts-pie")
		},
	},

	"pie-data": {
		Argsn: 1,
		Doc:   "Converts a block of name-value pairs into ECharts pie data items.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch blk := arg0.(type) {
			case env.Block:
				items, err := blockToPieData(ps, blk)
				if err != nil {
					return err
				}
				return *env.NewNative(ps.Idx, items, "echarts-pie-data")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "pie-data")
			}
		},
	},

	"echarts-pie//Global-options!": {
		Argsn: 2,
		Doc:   "Sets global options on an ECharts pie chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			pieNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-pie//Global-options!")
			}
			pie, ok := pieNat.Value.(*charts.Pie)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-pie"}, "echarts-pie//Global-options!")
			}

			var gopts []charts.GlobalOpts
			switch opt := arg1.(type) {
			case env.Native:
				gopt, ok := opt.Value.(charts.GlobalOpts)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 2, []string{"echarts-global-opts"}, "echarts-pie//Global-options!")
				}
				gopts = append(gopts, gopt)
			case env.Block:
				for i := 0; i < opt.Series.Len(); i++ {
					obj := opt.Series.Get(i)
					nat, ok := obj.(env.Native)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain native echarts-global-opts", "echarts-pie//Global-options!")
					}
					gopt, ok := nat.Value.(charts.GlobalOpts)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain echarts-global-opts natives", "echarts-pie//Global-options!")
					}
					gopts = append(gopts, gopt)
				}
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType, env.BlockType}, "echarts-pie//Global-options!")
			}

			pie.SetGlobalOptions(gopts...)
			return pieNat
		},
	},

	"echarts-pie//Add-series": {
		Argsn: 2,
		Doc:   "Adds a data series to an ECharts pie chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			pieNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-pie//Add-series")
			}
			pie, ok := pieNat.Value.(*charts.Pie)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-pie"}, "echarts-pie//Add-series")
			}
			dataNat, ok := arg1.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "echarts-pie//Add-series")
			}
			data, ok := dataNat.Value.([]opts.PieData)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 2, []string{"echarts-pie-data"}, "echarts-pie//Add-series")
			}
			pie.AddSeries("pie", data)
			return pieNat
		},
	},

	"echarts-pie//Render": {
		Argsn: 2,
		Doc:   "Renders an ECharts pie chart to a writer (file, etc.).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			pieNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-pie//Render")
			}
			pie, ok := pieNat.Value.(*charts.Pie)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-pie"}, "echarts-pie//Render")
			}
			writerNat, ok := arg1.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "echarts-pie//Render")
			}
			writer, ok := writerNat.Value.(io.Writer)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 2, []string{"io.Writer"}, "echarts-pie//Render")
			}
			err := pie.Render(writer)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "echarts-pie//Render")
			}
			return pieNat
		},
	},

	"scatter-chart": {
		Argsn: 0,
		Doc:   "Creates a new ECharts scatter chart instance.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			scatter := charts.NewScatter()
			return *env.NewNative(ps.Idx, scatter, "echarts-scatter")
		},
	},

	"scatter-data": {
		Argsn: 1,
		Doc:   "Converts a block of [x y] pairs into ECharts scatter data items.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch blk := arg0.(type) {
			case env.Block:
				items, err := blockToScatterData(ps, blk)
				if err != nil {
					return err
				}
				return *env.NewNative(ps.Idx, items, "echarts-scatter-data")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "scatter-data")
			}
		},
	},

	"echarts-scatter//Global-options!": {
		Argsn: 2,
		Doc:   "Sets global options on an ECharts scatter chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			scatterNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-scatter//Global-options!")
			}
			scatter, ok := scatterNat.Value.(*charts.Scatter)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-scatter"}, "echarts-scatter//Global-options!")
			}

			var gopts []charts.GlobalOpts
			switch opt := arg1.(type) {
			case env.Native:
				gopt, ok := opt.Value.(charts.GlobalOpts)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 2, []string{"echarts-global-opts"}, "echarts-scatter//Global-options!")
				}
				gopts = append(gopts, gopt)
			case env.Block:
				for i := 0; i < opt.Series.Len(); i++ {
					obj := opt.Series.Get(i)
					nat, ok := obj.(env.Native)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain native echarts-global-opts", "echarts-scatter//Global-options!")
					}
					gopt, ok := nat.Value.(charts.GlobalOpts)
					if !ok {
						return evaldo.MakeBuiltinError(ps, "block must contain echarts-global-opts natives", "echarts-scatter//Global-options!")
					}
					gopts = append(gopts, gopt)
				}
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType, env.BlockType}, "echarts-scatter//Global-options!")
			}

			scatter.SetGlobalOptions(gopts...)
			return scatterNat
		},
	},

	"echarts-scatter//X-axis!": {
		Argsn: 2,
		Doc:   "Sets the x-axis labels on an ECharts scatter chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			scatterNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-scatter//X-axis!")
			}
			scatter, ok := scatterNat.Value.(*charts.Scatter)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-scatter"}, "echarts-scatter//X-axis!")
			}
			switch blk := arg1.(type) {
			case env.Block:
				labels, err := blockToStringSlice(ps, blk)
				if err != nil {
					return err
				}
				scatter.SetXAxis(labels)
				return scatterNat
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "echarts-scatter//X-axis!")
			}
		},
	},

	"echarts-scatter//Add-series": {
		Argsn: 3,
		Doc:   "Adds a data series to an ECharts scatter chart.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			scatterNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-scatter//Add-series")
			}
			scatter, ok := scatterNat.Value.(*charts.Scatter)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-scatter"}, "echarts-scatter//Add-series")
			}
			name, ok := arg1.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "echarts-scatter//Add-series")
			}
			dataNat, ok := arg2.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 3, []env.Type{env.NativeType}, "echarts-scatter//Add-series")
			}
			data, ok := dataNat.Value.([]opts.ScatterData)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 3, []string{"echarts-scatter-data"}, "echarts-scatter//Add-series")
			}
			scatter.AddSeries(name.Value, data)
			return scatterNat
		},
	},

	"echarts-scatter//Render": {
		Argsn: 2,
		Doc:   "Renders an ECharts scatter chart to a writer (file, etc.).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			scatterNat, ok := arg0.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "echarts-scatter//Render")
			}
			scatter, ok := scatterNat.Value.(*charts.Scatter)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-scatter"}, "echarts-scatter//Render")
			}
			writerNat, ok := arg1.(env.Native)
			if !ok {
				return evaldo.MakeArgError(ps, 2, []env.Type{env.NativeType}, "echarts-scatter//Render")
			}
			writer, ok := writerNat.Value.(io.Writer)
			if !ok {
				return evaldo.MakeNativeArgError(ps, 2, []string{"io.Writer"}, "echarts-scatter//Render")
			}
			err := scatter.Render(writer)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "echarts-scatter//Render")
			}
			return scatterNat
		},
	},

	"legend-opts": {
		Argsn: 0,
		Doc:   "Creates ECharts legend options.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			legendOpts := opts.Legend{}
			return *env.NewNative(ps.Idx, legendOpts, "echarts-legend-opts")
		},
	},

	"with-legend-opts": {
		Argsn: 1,
		Doc:   "Wraps legend options into a chart global option.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch nat := arg0.(type) {
			case env.Native:
				legendOpts, ok := nat.Value.(opts.Legend)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-legend-opts"}, "with-legend-opts")
				}
				opt := charts.WithLegendOpts(legendOpts)
				return *env.NewNative(ps.Idx, opt, "echarts-global-opts")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "with-legend-opts")
			}
		},
	},

	"tooltip-opts": {
		Argsn: 0,
		Doc:   "Creates ECharts tooltip options.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			tooltipOpts := opts.Tooltip{}
			return *env.NewNative(ps.Idx, tooltipOpts, "echarts-tooltip-opts")
		},
	},

	"with-tooltip-opts": {
		Argsn: 1,
		Doc:   "Wraps tooltip options into a chart global option.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch nat := arg0.(type) {
			case env.Native:
				tooltipOpts, ok := nat.Value.(opts.Tooltip)
				if !ok {
					return evaldo.MakeNativeArgError(ps, 1, []string{"echarts-tooltip-opts"}, "with-tooltip-opts")
				}
				opt := charts.WithTooltipOpts(tooltipOpts)
				return *env.NewNative(ps.Idx, opt, "echarts-global-opts")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "with-tooltip-opts")
			}
		},
	},
}

var Builtins_email = map[string]*env.Builtin{

	"email-message": {
		Argsn: 0,
		Doc:   "Creates a new empty email message object that can be configured with headers, body, and attachments.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __newMessage(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-message//Set-header": {
		Argsn: 3,
		Doc:   "Sets a standard email header field such as Subject, To, From, Cc, or Bcc with the specified value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __setHeader(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-message//Set-address-header": {
		Argsn: 4,
		Doc:   "Sets an email address header with both email address and display name, commonly used for From, To, Cc, and Bcc fields.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __setAddressHeader(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-message//Set-body": {
		Argsn: 3,
		Doc:   "Sets the main body content of the email with the specified MIME content type, supporting plain text and HTML formats.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __setBody(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-message//Attach": {
		Argsn: 2,
		Doc:   "Attaches a file to the email message using a file URI, making the file available as an email attachment.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __attach(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-message//Add-alternative": {
		Argsn: 3,
		Doc:   "Adds alternative content to the email (e.g., HTML version alongside plain text), allowing email clients to choose their preferred format.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __addAlternative(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"new-email-dialer": {
		Argsn: 4,
		Doc:   "Creates a new SMTP dialer configured with server details and authentication credentials for sending emails.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __newDialer(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},

	"gomail-dialer//Dial-and-send": {
		Argsn: 2,
		Doc:   "Connects to the SMTP server and sends the specified email message, handling authentication and delivery.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return __dialAndSend(ps, arg0, arg1, arg2, arg3, arg4)
		},
	},
}

var Builtins_encoding = map[string]*env.Builtin{

	"decode\\hex-string": {
		Argsn: 1,
		Doc:   "Decodes a hexadecimal string to a UTF-8 string.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch hexStr := arg0.(type) {
			case env.String:
				decoded, err := hex.DecodeString(hexStr.Value)
				if err != nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Failed to decode hex string: "+err.Error(), "decode\\hex-string")
				}
				return *env.NewString(string(decoded))
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "decode\\hex-string")
			}
		},
	},

	"encode-to\\hex-string": {
		Argsn: 1,
		Doc:   "Encodes a string to its hexadecimal representation.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch str := arg0.(type) {
			case env.String:
				encoded := hex.EncodeToString([]byte(str.Value))
				return *env.NewString(encoded)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "encode-to\\hex-string")
			}
		},
	},

	"clean\\hex-string": {
		Argsn: 1,
		Doc:   "Removes all whitespace from a hex string and ensures even length.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch hexStr := arg0.(type) {
			case env.String:
				var sb strings.Builder
				for _, r := range hexStr.Value {
					if !unicode.IsSpace(r) {
						sb.WriteRune(r)
					}
				}

				result := sb.String()
				if len(result)%2 != 0 {
					result = result[:len(result)-1]
				}
				return *env.NewString(result)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "clean\\hex-string")
			}
		},
	},

	"charmap\\windows-1250": {
		Argsn: 0,
		Doc:   "Returns the Windows-1250 (CP1250) character encoding for Central European languages.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.Windows1250, "charmap-encoding")
		},
	},

	"charmap\\iso-8859-1": {
		Argsn: 0,
		Doc:   "Returns the ISO-8859-1 (Latin-1) character encoding.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.ISO8859_1, "charmap-encoding")
		},
	},

	"charmap\\iso-8859-2": {
		Argsn: 0,
		Doc:   "Returns the ISO-8859-2 (Latin-2) character encoding for Central European languages.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.ISO8859_2, "charmap-encoding")
		},
	},

	"charmap\\windows-1252": {
		Argsn: 0,
		Doc:   "Returns the Windows-1252 character encoding for Western European languages.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.Windows1252, "charmap-encoding")
		},
	},

	"charmap\\code-page-437": {
		Argsn: 0,
		Doc:   "Returns the Code Page 437 (DOS/IBM PC) character encoding.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.CodePage437, "charmap-encoding")
		},
	},

	"charmap\\code-page-850": {
		Argsn: 0,
		Doc:   "Returns the Code Page 850 (DOS Latin-1) character encoding.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.CodePage850, "charmap-encoding")
		},
	},

	"charmap\\koi8r": {
		Argsn: 0,
		Doc:   "Returns the KOI8-R character encoding for Russian.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, charmap.KOI8R, "charmap-encoding")
		},
	},

	"charmap-encoding//Decoder": {
		Argsn: 1,
		Doc:   "Creates a new text decoder for the given character encoding.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch encoding := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(encoding.GetKind()) != "charmap-encoding" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "charmap-encoding\\new-decoder")
				}
				enc := encoding.Value.(*charmap.Charmap)
				decoder := enc.NewDecoder()
				return *env.NewNative(ps.Idx, decoder, "text-decoder")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "charmap-encoding\\new-decoder")
			}
		},
	},

	"charmap-encoding//Encoder": {
		Argsn: 1,
		Doc:   "Creates a new text encoder for the given character encoding.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch encoding := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(encoding.GetKind()) != "charmap-encoding" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "charmap-encoding\\new-encoder")
				}
				enc := encoding.Value.(*charmap.Charmap)
				encoder := enc.NewEncoder()
				return *env.NewNative(ps.Idx, encoder, "text-encoder")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "charmap-encoding\\new-encoder")
			}
		},
	},

	"text-decoder//Decode": {
		Argsn: 2,
		Doc:   "Decodes a string using the given text decoder.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch decoder := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(decoder.GetKind()) != "text-decoder" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "text-decoder\\string")
				}
				switch input := arg1.(type) {
				case env.String:
					dec := decoder.Value.(*encoding.Decoder)
					decoded, err := dec.String(input.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, "Failed to decode string: "+err.Error(), "text-decoder\\string")
					}
					return *env.NewString(decoded)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "text-decoder\\string")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "text-decoder\\string")
			}
		},
	},

	"text-encoder//Encode": {
		Argsn: 2,
		Doc:   "Encodes a string using the given text encoder.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch encoder := arg0.(type) {
			case env.Native:
				if ps.Idx.GetWord(encoder.GetKind()) != "text-encoder" {
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "text-encoder\\string")
				}
				switch input := arg1.(type) {
				case env.String:
					enc := encoder.Value.(*encoding.Encoder)
					encoded, err := enc.String(input.Value)
					if err != nil {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, "Failed to encode string: "+err.Error(), "text-encoder\\string")
					}
					return *env.NewString(encoded)
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "text-encoder\\string")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "text-encoder\\string")
			}
		},
	},

	"is-space": {
		Argsn: 1,
		Doc:   "Checks if a single character string is a whitespace character.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch str := arg0.(type) {
			case env.String:
				if len(str.Value) == 0 {
					return *env.NewBoolean(false)
				}

				for _, r := range str.Value {
					return *env.NewBoolean(unicode.IsSpace(r))
				}
				return *env.NewBoolean(false)
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "is-space")
			}
		},
	},

	"remove-all-space": {
		Argsn: 1,
		Doc:   "Removes all whitespace characters from a string.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch str := arg0.(type) {
			case env.String:
				var sb strings.Builder
				for _, r := range str.Value {
					if !unicode.IsSpace(r) {
						sb.WriteRune(r)
					}
				}
				return *env.NewString(sb.String())
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "remove-all-space")
			}
		},
	},
}

var Builtins_eyr = map[string]*env.Builtin{

	"eyr": {
		Argsn: 1,
		Doc:   "Evaluates Rye block as Eyr (postfix) stack based code.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg0.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				dialect := ps.Dialect
				ps.Dialect = env.EyrDialect

				ps.ResetStack()
				Eyr_EvalBlock(ps, false)
				ps.Dialect = dialect
				ps.Ser = ser
				return ps.Res
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "eyr")
			}
		},
	},

	"rye0": {
		Argsn: 1,
		Doc:   "Evaluates Rye block as Rye0 dialect.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg0.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				dialect := ps.Dialect
				ps.Dialect = env.Rye0Dialect
				evaldo.Rye0_EvalBlockInj(ps, nil, false)
				ps.Dialect = dialect
				ps.Ser = ser
				return ps.Res
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "rye0")
			}
		},
	},

	"rye00": {
		Argsn: 1,
		Doc:   "Evaluates Rye block as Rye00 dialect (builtins and integers only).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg0.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				dialect := ps.Dialect
				ps.Dialect = env.Rye00Dialect
				evaldo.Rye00_EvalBlockInj(ps, nil, false)
				ps.Dialect = dialect
				ps.Ser = ser
				return ps.Res
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "rye00")
			}
		},
	},

	"eyr\\clear": {
		Argsn: 0,
		Doc:   "Clears the EYR stack.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.ResetStack()
			return env.NewBoolean(false)
		},
	},

	"eyr\\full": {
		Argsn: 1,
		Doc:   "Evaluates Rye block as Eyr (postfix) stack based code.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg0.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				dialect := ps.Dialect
				ps.Dialect = env.EyrDialect
				Eyr_EvalBlock(ps, true)
				ps.Dialect = dialect
				ps.Ser = ser
				return ps.Res
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "eyr\\full")
			}
		},
	},

	"eyr\\loop": {
		Argsn: 2,
		Doc:   "Evaluates Rye block in loop as Eyr code (postfix stack based) N times.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch cond := arg0.(type) {
			case env.Integer:
				switch bloc := arg1.(type) {
				case env.Block:
					ps.Dialect = env.EyrDialect
					ser := ps.Ser
					ps.Ser = bloc.Series
					for i := 0; int64(i) < cond.Value; i++ {
						ps = Eyr_EvalBlock(ps, false)
						ps.Ser.Reset()
					}
					ps.Ser = ser
					return ps.Res
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "eyr\\loop")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "eyr\\loop")
			}
		},
	},

	"to-eyr": {
		Argsn: 1,
		Doc:   "Evaluates Rye block as Eyr (postfix) stack based code.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg0.(type) {
			case env.Block:
				eBlock := env.NewBlock(*env.NewTSeries(make([]env.Object, 0)))
				evaldo.CompileRyeToEyr(&bloc, ps, eBlock)
				return *eBlock
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "eyr")
			}
		},
	},
}

var Builtins_flui = map[string]*env.Builtin{
	"select": {
		Argsn: 1,
		Doc:   "Interactively displays a selection interface for Block, Dict, Table, List, or TableRow. Returns the selected item. Ctrl+C cancels and returns a failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			var obj env.Object
			var esc bool
			switch val := arg0.(type) {
			case env.Block:
				obj, esc = term.DisplayBlock(val, ps.Idx)
			case *env.Block:
				obj, esc = term.DisplayBlock(*val, ps.Idx)
			case env.Dict:
				obj, esc = term.DisplayDict(val, ps.Idx)
			case *env.Dict:
				obj, esc = term.DisplayDict(*val, ps.Idx)
			case env.List:

				bloc := env.NewBlock(*env.NewTSeries(make([]env.Object, len(val.Data))))
				for i, item := range val.Data {
					bloc.Series.S[i] = env.ToRyeValue(item)
				}
				obj, esc = term.DisplayBlock(*bloc, ps.Idx)
			case *env.List:

				bloc := env.NewBlock(*env.NewTSeries(make([]env.Object, len(val.Data))))
				for i, item := range val.Data {
					bloc.Series.S[i] = env.ToRyeValue(item)
				}
				obj, esc = term.DisplayBlock(*bloc, ps.Idx)
			case env.Table:
				obj, esc = term.DisplayTable(val, ps.Idx)
			case *env.Table:
				obj, esc = term.DisplayTable(*val, ps.Idx)
			case env.TableRow:
				obj, esc = term.DisplayTableRow(val, ps.Idx)
			case *env.TableRow:
				obj, esc = term.DisplayTableRow(*val, ps.Idx)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType, env.DictType, env.ListType, env.TableType}, "select")
			}
			if esc {
				ps.FailureFlag = true
				return env.NewError("canceled by user")
			}
			return obj
		},
	},
	"input": {
		Argsn: 1,
		Doc:   "Interactively displays an input field. Takes the max input width, returns the entered string. Ctrl+C cancels and returns a failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {

			term.SaveCurPos()
			switch width := arg0.(type) {
			case env.Integer:
				obj, esc := term.DisplayInputField(0, int(width.Value))
				if esc {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return obj
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "input")
			}
		},
	},
	"input\\integer": {
		Argsn: 1,
		Doc:   "Interactive date input in format YYYY-MM-DD. Use arrow keys to navigate between year/month/day fields and increment/decrement values, or type digits. Returns date string. Ctrl+C cancels and returns a failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			switch initialDate := arg0.(type) {
			case env.String:
				obj, esc := term.DisplayIntInput(initialDate.Value, 0)
				if esc {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return obj
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "input\\integer")
			}
		},
	},
	"datepicker": {
		Argsn: 1,
		Doc:   "Interactive date input in format YYYY-MM-DD. Use arrow keys to navigate between year/month/day fields and increment/decrement values, or type digits. Returns date string. Ctrl+C cancels and returns a failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			switch initialDate := arg0.(type) {
			case env.String:
				obj, esc := term.DisplayDateInput(initialDate.Value, 0)
				if esc {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return obj
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "datepicker")
			}
		},
	},
	"selectbox": {
		Argsn: 1,
		Doc:   "Interactive date input in format YYYY-MM-DD. Use arrow keys to navigate between year/month/day fields and increment/decrement values, or type digits. Returns date string. Ctrl+C cancels and returns a failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			switch options := arg0.(type) {
			case env.Block:
				obj, esc := term.DisplaySelection(options, ps.Idx, 0)
				if esc {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return obj
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "datepicker")
			}
		},
	},
	"textarea": {
		Argsn: 2,
		Doc:   "Interactive multiline text input. Takes width and height (number of lines). Use arrow keys to navigate, Enter for new line, Ctrl+D to submit. Returns string with newlines. Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			switch width := arg0.(type) {
			case env.Integer:
				switch height := arg1.(type) {
				case env.Integer:
					obj, esc := term.DisplayTextArea(int(width.Value), int(height.Value), "")
					if esc {
						ps.FailureFlag = true
						return env.NewError("canceled by user")
					}
					return obj
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "textarea")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "textarea")
			}
		},
	},
	"textarea\\": {
		Argsn: 3,
		Doc:   "Interactive multiline text input with initial text. Takes width, height (number of lines), and initial text string. Use arrow keys to navigate, Enter for new line, Ctrl+D to submit. Returns string with newlines. Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			term.SaveCurPos()
			switch width := arg1.(type) {
			case env.Integer:
				switch height := arg2.(type) {
				case env.Integer:
					switch text := arg0.(type) {
					case env.String:
						obj, esc := term.DisplayTextArea(int(width.Value), int(height.Value), text.Value)
						if esc {
							ps.FailureFlag = true
							return env.NewError("canceled by user")
						}
						return obj
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "textarea\\")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "textarea\\")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "textarea\\")
			}
		},
	},
	"displayx": {
		Argsn: 1,
		Doc:   "Returns a special !!! prefixed JSON representation of a Block for Flutter UI rendering. The JSON format is [\"block\", [[\"type\", \"value\"], ...]]. Used for interactive display in Flutter clients.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Block:
				return blockToDisplayJSON(val, ps.Idx)
			case *env.Block:
				return blockToDisplayJSON(*val, ps.Idx)
			case env.List:

				bloc := env.NewBlock(*env.NewTSeries(make([]env.Object, len(val.Data))))
				for i, item := range val.Data {
					bloc.Series.S[i] = env.ToRyeValue(item)
				}
				return blockToDisplayJSON(*bloc, ps.Idx)
			case *env.List:

				bloc := env.NewBlock(*env.NewTSeries(make([]env.Object, len(val.Data))))
				for i, item := range val.Data {
					bloc.Series.S[i] = env.ToRyeValue(item)
				}
				return blockToDisplayJSON(*bloc, ps.Idx)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType, env.ListType}, "displayx")
			}
		},
	},
}

var Builtins_flui_v2 = map[string]*env.Builtin{

	"select": {
		Argsn: 1,
		Doc:   "Interactively displays a selection interface. Returns the selected item. Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			items, ok := extractItems(arg0, ps.Idx)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType, env.DictType, env.ListType, env.TableType}, "select")
			}

			_, height, termErr := goterm.GetSize(int(os.Stdout.Fd()))
			if termErr != nil {
				height = 20
			}
			pageSize := height - 4

			term.SaveCurPos()

			var widget term.Widget
			if len(items) <= pageSize {
				widget = term.NewSelectWidget(items, ps.Idx)
			} else {
				widget = term.NewPaginatedSelectWidget(items, pageSize, ps.Idx)
			}

			result, canceled := term.RunWidget(widget)
			if canceled {
				ps.FailureFlag = true
				return env.NewError("canceled by user")
			}
			return result
		},
	},

	"input": {
		Argsn: 1,
		Doc:   "Interactively displays an input field. Takes max width, returns entered string. Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch width := arg0.(type) {
			case env.Integer:
				term.SaveCurPos()
				widget := term.NewInputWidget(int(width.Value), ps.Idx)
				result, canceled := term.RunWidget(widget)
				if canceled {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return result
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "input")
			}
		},
	},

	"datepicker": {
		Argsn: 1,
		Doc:   "Interactive date input. Use arrow keys to navigate/change values, or type digits. Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch initialDate := arg0.(type) {
			case env.String:
				term.SaveCurPos()
				widget := term.NewDateWidget(initialDate.Value, ps.Idx)
				result, canceled := term.RunWidget(widget)
				if canceled {
					ps.FailureFlag = true
					return env.NewError("canceled by user")
				}
				return result
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "datepicker")
			}
		},
	},

	"textarea": {
		Argsn: 2,
		Doc:   "Interactive multiline text input. Takes width and height. Ctrl+D to submit, Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch width := arg0.(type) {
			case env.Integer:
				switch height := arg1.(type) {
				case env.Integer:
					term.SaveCurPos()
					widget := term.NewTextAreaWidget(int(width.Value), int(height.Value), "", ps.Idx)
					result, canceled := term.RunWidget(widget)
					if canceled {
						ps.FailureFlag = true
						return env.NewError("canceled by user")
					}
					return result
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "textarea")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "textarea")
			}
		},
	},

	"textarea\\": {
		Argsn: 3,
		Doc:   "Interactive multiline text input with initial text. Ctrl+D to submit, Ctrl+C cancels.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch text := arg0.(type) {
			case env.String:
				switch width := arg1.(type) {
				case env.Integer:
					switch height := arg2.(type) {
					case env.Integer:
						term.SaveCurPos()
						widget := term.NewTextAreaWidget(int(width.Value), int(height.Value), text.Value, ps.Idx)
						result, canceled := term.RunWidget(widget)
						if canceled {
							ps.FailureFlag = true
							return env.NewError("canceled by user")
						}
						return result
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.IntegerType}, "textarea\\")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "textarea\\")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "textarea\\")
			}
		},
	},

	"displayx": {
		Argsn: 1,
		Doc:   "Returns a !!! prefixed JSON representation for Flutter UI rendering.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Block:
				return blockToDisplayJSON(val, ps.Idx)
			case *env.Block:
				return blockToDisplayJSON(*val, ps.Idx)
			case env.List:
				return blockToDisplayJSON(*listToBlock(val), ps.Idx)
			case *env.List:
				return blockToDisplayJSON(*listToBlock(*val), ps.Idx)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType, env.ListType}, "displayx")
			}
		},
	},
}

var Builtins_goroutines = map[string]*env.Builtin{

	"go-with": {
		Argsn: 2,
		Doc:   "Executes a function in a separate goroutine, passing the specified value as an argument.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch arg := arg0.(type) {
			case env.Object:
				switch handler := arg1.(type) {
				case env.Function:
					if handler.Argsn != 1 {
						ps.FailureFlag = true
						return evaldo.MakeBuiltinError(ps, "function with exactly 1 argument required", "go-with")
					}

					psTemp := env.ProgramState{}
					err := copier.Copy(&psTemp, &ps)
					if err != nil {
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to copy program state: %s", err), "go-with")
					}

					psTemp.FailureFlag = false
					psTemp.ErrorFlag = false
					psTemp.ReturnFlag = false

					go func() {
						defer func() {
							if r := recover(); r != nil {

								fmt.Printf("Goroutine panic in go-with: %v\n", r)
							}
						}()
						evaldo.CallFunction_CollectArgs(handler, &psTemp, arg, false, nil)
					}()

					return arg0
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.FunctionType}, "go-with")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeBuiltinError(ps, "First argument should be object type.", "go-with")
			}
		},
	},

	"go": {
		Argsn: 1,
		Doc:   "Executes a function in a separate goroutine without passing any arguments.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch handler := arg0.(type) {
			case env.Function:
				if handler.Argsn != 0 {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "function with 0 arguments required", "go")
				}

				psTemp := env.ProgramState{}
				err := copier.Copy(&psTemp, &ps)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to copy program state: %s", err), "go")
				}

				psTemp.FailureFlag = false
				psTemp.ErrorFlag = false
				psTemp.ReturnFlag = false

				go func() {
					defer func() {
						if r := recover(); r != nil {

							fmt.Printf("Goroutine panic in go: %v\n", r)
						}
					}()
					evaldo.CallFunction_CollectArgs(handler, &psTemp, nil, false, nil)
				}()

				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.FunctionType}, "go")
			}
		},
	},

	"channel": {
		Argsn: 1,
		Doc:   "Creates a new channel with the specified buffer size for goroutine communication.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch buflen := arg0.(type) {
			case env.Integer:
				if buflen.Value < 0 || int64(int(buflen.Value)) != buflen.Value {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "buffer size must be a non-negative integer representable on this platform", "channel")
				}
				ch := make(chan *env.Object, int(buflen.Value))
				return *env.NewNative(ps.Idx, ch, "Rye-channel")
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "channel")
			}
		},
	},

	"Rye-channel//Read": {
		Argsn: 1,
		Doc:   "Reads the next value from a channel, blocking until a value is available or the channel is closed.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch chn := arg0.(type) {
			case env.Native:

				ch, ok := chn.Value.(chan *env.Object)
				if !ok {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Invalid channel type", "Rye-channel//Read")
				}

				msg, ok := <-ch
				if ok {
					return *msg
				} else {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "channel closed", "Rye-channel//Read")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//Read")
			}
		},
	},

	"Rye-channel//Send": {
		Argsn: 2,
		Doc:   "Sends a value through a channel, blocking if the channel is unbuffered or full.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (result env.Object) {

			defer func() {
				if r := recover(); r != nil {
					ps.FailureFlag = true
					result = *env.NewError("send on closed channel")
				}
			}()
			switch chn := arg0.(type) {
			case env.Native:
				ch, ok := chn.Value.(chan *env.Object)
				if !ok {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Invalid channel type", "Rye-channel//Send")
				}
				ch <- &arg1
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//Send")
			}
		},
	},

	"Rye-channel//Close": {
		Argsn: 1,
		Doc:   "Closes a channel, preventing further sends. Buffered values remain readable until the channel is drained.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (result env.Object) {
			defer func() {
				if r := recover(); r != nil {
					ps.FailureFlag = true
					result = evaldo.MakeBuiltinError(ps, "channel already closed", "Rye-channel//Close")
				}
			}()
			switch chn := arg0.(type) {
			case env.Native:
				ch, ok := chn.Value.(chan *env.Object)
				if !ok || ch == nil {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Invalid channel type or nil channel", "Rye-channel//Close")
				}
				close(ch)
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//Close")
			}
		},
	},

	"mutex": {
		Argsn: 0,
		Doc:   "Creates a new mutex for synchronizing access to shared resources between goroutines.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			mtx := &RyeMutex{}
			return *env.NewNative(ps.Idx, mtx, "Rye-mutex")
		},
	},

	"waitgroup": {
		Argsn: 0,
		Doc:   "Creates a new waitgroup for coordinating multiple goroutines to wait for completion.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var wg sync.WaitGroup
			return *env.NewNative(ps.Idx, &wg, "Rye-waitgroup")
		},
	},

	"Rye-mutex//Lock": {
		Argsn: 1,
		Doc:   "Acquires the lock on a mutex, blocking until the lock becomes available.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch mtx := arg0.(type) {
			case env.Native:
				mtx.Value.(*RyeMutex).Lock()
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-mutex//Lock")
			}
		},
	},

	"Rye-mutex//Unlock": {
		Argsn: 1,
		Doc:   "Releases the lock on a mutex, allowing other goroutines to acquire it.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch mtx := arg0.(type) {
			case env.Native:
				err := mtx.Value.(*RyeMutex).Unlock()
				if err != nil {
					ps.FailureFlag = true
					return *env.NewError(err.Error())
				}
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-mutex//Unlock")
			}
		},
	},

	"Rye-waitgroup//Add": {
		Argsn: 2,
		Doc:   "Adds the specified count to the waitgroup counter, indicating how many goroutines to wait for.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch wg := arg0.(type) {
			case env.Native:
				switch count := arg1.(type) {
				case env.Integer:
					wg.Value.(*sync.WaitGroup).Add(int(count.Value))
					return arg0
				default:
					ps.FailureFlag = true
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "Rye-waitgroup//Add")
				}
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//Add")
			}
		},
	},

	"Rye-waitgroup//Done": {
		Argsn: 1,
		Doc:   "Decrements the waitgroup counter by one, indicating that a goroutine has completed.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch wg := arg0.(type) {
			case env.Native:
				wg.Value.(*sync.WaitGroup).Done()
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//Done")
			}
		},
	},

	"Rye-waitgroup//Wait": {
		Argsn: 1,
		Doc:   "Blocks until the waitgroup counter reaches zero, meaning all goroutines have completed.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch wg := arg0.(type) {
			case env.Native:
				wg.Value.(*sync.WaitGroup).Wait()
				return arg0
			default:
				ps.FailureFlag = true
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//Wait")
			}
		},
	},

	"select\\fn": {
		Argsn: 1,
		Doc:   "Selects a channel or default function and returns its result. Selecting a drained closed channel fails without calling a handler.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return runChannelSelect(ps, arg0, true)
		},
	},

	"select": {
		Argsn: 1,
		Doc:   "Selects a channel or default block and returns its result. Selecting a drained closed channel fails without running a handler.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return runChannelSelect(ps, arg0, false)
		},
	},
}

var Builtins_gpio = map[string]*env.Builtin{}

var Builtins_html = map[string]*env.Builtin{

	"unescape\\html": {
		Argsn: 1,
		Doc:   "Converts HTML entities to their character equivalents.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			text, ok := arg0.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "unescape\\html")
			}
			mkd := html.UnescapeString(text.Value)
			return *env.NewString(mkd)
		},
	},

	"escape\\html": {
		Argsn: 1,
		Doc:   "Converts special characters to HTML entities.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			text, ok := arg0.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "unescape\\html")
			}
			mkd := html.EscapeString(text.Value)
			return *env.NewString(mkd)
		},
	},

	"html->markdown": {
		Argsn: 1,
		Doc:   "Converts HTML text to markdown format.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			text, ok := arg0.(env.String)
			if !ok {
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "html->markdown")
			}
			mkd, err := htmltomarkdown.ConvertString(text.Value)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "html->markdown")
			}
			return *env.NewString(mkd)
		},
	},

	"reader//Parse-html": {
		Argsn: 2,
		Doc:   "Parses HTML using a streaming approach with tag handlers.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			rm, err := load_html_Dict(ps, arg1.(env.Block))
			trace8("*** _--- GOT RM ++**")

			if err != nil {
				ps.FailureFlag = true
				return evaldo.MakeBuiltinError(ps, "Error to load html dict.", "reader//parse-html")
			}
			return do_html(ps, arg0.(env.Native).Value.(io.Reader), rm)
		},
	},

	"rye-html-start//Attr?": {
		Argsn: 2,
		Doc:   "Retrieves an attribute value by name or index from an HTML element.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch tok1 := arg0.(type) {
			case env.Native:
				switch tok := tok1.Value.(type) {
				case html.Token:
					switch n := arg1.(type) {
					case env.Integer:
						if int(n.Value) < len(tok.Attr) {
							return *env.NewString(tok.Attr[int(n.Value)].Val)
						} else {
							return evaldo.MakeBuiltinError(ps, "Attribute index out of bounds.", "rye-html-start//Attr?")
						}
					case env.Word:
						attrName := ps.Idx.GetWord(n.Index)
						for _, a := range tok.Attr {
							if a.Key == attrName {
								return *env.NewString(a.Val)
							}
						}
						return evaldo.MakeBuiltinError(ps, "Attribute '"+attrName+"' not found.", "rye-html-start//Attr?")
					case env.String:
						attrName := n.Value
						for _, a := range tok.Attr {
							if a.Key == attrName {
								return *env.NewString(a.Val)
							}
						}
						return evaldo.MakeBuiltinError(ps, "Attribute '"+attrName+"' not found.", "rye-html-start//Attr?")
					default:
						return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.WordType, env.StringType}, "rye-html-start//Attr?")
					}
				default:
					return evaldo.MakeBuiltinError(ps, "Token value is not matching.", "rye-html-start//Attr?")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "rye-html-start//Attr?")
			}
		},
	},

	"rye-html-start//Attrs?": {
		Argsn: 1,
		Doc:   "Returns a dict of all attributes from an HTML element.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch tok1 := arg0.(type) {
			case env.Native:
				switch tok := tok1.Value.(type) {
				case html.Token:
					data := make(map[string]any)
					for _, attr := range tok.Attr {
						data[attr.Key] = *env.NewString(attr.Val)
					}
					return *env.NewDict(data)
				default:
					return evaldo.MakeBuiltinError(ps, "Token value is not matching.", "rye-html-start//Attrs?")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "rye-html-start//Attrs?")
			}
		},
	},

	"rye-html-start//Name?": {
		Argsn: 1,
		Doc:   "Returns the name of an HTML element.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch tok1 := arg0.(type) {
			case env.Native:
				switch tok := tok1.Value.(type) {
				case html.Token:
					return *env.NewString(tok.Data)
				default:
					return evaldo.MakeBuiltinError(ps, "Not xml-start element.", "rye-html-start//Name?")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "rye-html-start//Name?")
			}
		},
	},
}

var Builtins_imap = map[string]*env.Builtin{

	"imap-uri//Open": {
		Argsn: 1,
		Doc:   "Opens an IMAP client connection. URI format: imap[s]://user[:pass]@host[:port][/mailbox].",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch uri := arg0.(type) {
			case env.Uri:
				scheme := ps.Idx.GetWord(uri.Scheme.Index)
				parsed, err := parseIMAPURI(scheme, uri.GetPath())
				if err != nil {
					return evaldo.MakeBuiltinError(ps, err.Error(), "imap-uri//Open")
				}
				return imapNewClient(ps, parsed, "", "", "password", "imap-uri//Open")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.UriType}, "imap-uri//Open")
			}
		},
	},

	"imap-uri//Open\\pwd": {
		Argsn: 2,
		Doc:   "Opens an IMAP client connection with a separate password parameter.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch uri := arg0.(type) {
			case env.Uri:
				switch password := arg1.(type) {
				case env.String:
					scheme := ps.Idx.GetWord(uri.Scheme.Index)
					parsed, err := parseIMAPURI(scheme, uri.GetPath())
					if err != nil {
						return evaldo.MakeBuiltinError(ps, err.Error(), "imap-uri//Open\\pwd")
					}
					return imapNewClient(ps, parsed, password.Value, "", "password", "imap-uri//Open\\pwd")
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-uri//Open\\pwd")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.UriType}, "imap-uri//Open\\pwd")
			}
		},
	},

	"imap-uri//Open\\oauth2": {
		Argsn: 2,
		Doc:   "Opens an IMAP client connection with OAuth2 (XOAUTH2/OAUTHBEARER) authentication.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch uri := arg0.(type) {
			case env.Uri:
				switch token := arg1.(type) {
				case env.String:
					scheme := ps.Idx.GetWord(uri.Scheme.Index)
					parsed, err := parseIMAPURI(scheme, uri.GetPath())
					if err != nil {
						return evaldo.MakeBuiltinError(ps, err.Error(), "imap-uri//Open\\oauth2")
					}
					return imapNewClient(ps, parsed, "", token.Value, "oauth2", "imap-uri//Open\\oauth2")
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-uri//Open\\oauth2")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.UriType}, "imap-uri//Open\\oauth2")
			}
		},
	},

	"imap-client": {
		Argsn: 4,
		Doc:   "Create an IMAP client connection with username, password, server, and port.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch username := arg0.(type) {
			case env.String:
				switch password := arg1.(type) {
				case env.String:
					switch server := arg2.(type) {
					case env.String:
						switch port := arg3.(type) {
						case env.Integer:
							parsed := &imapURI{
								user:        username.Value,
								password:    password.Value,
								host:        server.Value,
								port:        int(port.Value),
								implicitTLS: int(port.Value) == 993,
							}
							return imapNewClient(ps, parsed, "", "", "password", "imap-client")
						default:
							return evaldo.MakeArgError(ps, 4, []env.Type{env.IntegerType}, "imap-client")
						}
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "imap-client")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-client")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "imap-client")
			}
		},
	},

	"imap-client\\oauth2": {
		Argsn: 4,
		Doc:   "Create an IMAP client connection with OAuth2 authentication (email, access_token, server, port).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch email := arg0.(type) {
			case env.String:
				switch token := arg1.(type) {
				case env.String:
					switch server := arg2.(type) {
					case env.String:
						switch port := arg3.(type) {
						case env.Integer:
							parsed := &imapURI{
								user:        email.Value,
								host:        server.Value,
								port:        int(port.Value),
								implicitTLS: int(port.Value) == 993,
							}
							return imapNewClient(ps, parsed, "", token.Value, "oauth2", "imap-client\\oauth2")
						default:
							return evaldo.MakeArgError(ps, 4, []env.Type{env.IntegerType}, "imap-client\\oauth2")
						}
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "imap-client\\oauth2")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-client\\oauth2")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "imap-client\\oauth2")
			}
		},
	},

	"imap-client//Select-folder": {
		Argsn: 2,
		Doc:   "Selects a folder for IMAP operations (e.g., 'INBOX').",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Select-folder")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Select-folder")
			}
			switch folder := arg1.(type) {
			case env.String:
				if _, err := client.Select(folder.Value, nil).Wait(); err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to select folder: %s", err), "imap-client//Select-folder")
				}
				return arg0
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-client//Select-folder")
			}
		},
	},

	"imap-client//Get-folders": {
		Argsn: 1,
		Doc:   "Gets the list of available folders.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Get-folders")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Get-folders")
			}
			mailboxes, err := client.List("", "*", nil).Collect()
			if err != nil {
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to get folders: %s", err), "imap-client//Get-folders")
			}
			result := make([]env.Object, len(mailboxes))
			for i, mailbox := range mailboxes {
				result[i] = *env.NewString(mailbox.Mailbox)
			}
			return *env.NewBlock(*env.NewTSeries(result))
		},
	},

	"imap-client//Mailbox-info": {
		Argsn: 1,
		Doc:   "Gets information about the currently selected folder.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Mailbox-info")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Mailbox-info")
			}
			info, err := imapMailboxInfo(client)
			if err != nil {
				return evaldo.MakeBuiltinError(ps, err.Error(), "imap-client//Mailbox-info")
			}
			return info
		},
	},

	"imap-client//Search-emails": {
		Argsn: 2,
		Doc:   "Searches for emails using IMAP search criteria and returns matching UIDs.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Search-emails")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Search-emails")
			}
			switch criteriaValue := arg1.(type) {
			case env.String:
				criteria, err := imapParseSearch(criteriaValue.Value)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("invalid search criteria: %s", err), "imap-client//Search-emails")
				}
				data, err := client.UIDSearch(criteria, nil).Wait()
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("search failed: %s", err), "imap-client//Search-emails")
				}
				uids := data.AllUIDs()
				result := make([]env.Object, len(uids))
				for i, uid := range uids {
					result[i] = *env.NewInteger(int64(uid))
				}
				return *env.NewBlock(*env.NewTSeries(result))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.StringType}, "imap-client//Search-emails")
			}
		},
	},

	"imap-client//Get-overviews": {
		Argsn: 2,
		Doc:   "Gets email overviews (headers only, fast) for a block of UIDs.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Get-overviews")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Get-overviews")
			}
			switch uidBlock := arg1.(type) {
			case env.Block:
				uids, argErr := imapUIDsFromBlock(ps, uidBlock, "imap-client//Get-overviews")
				if argErr != nil {
					return argErr
				}
				overviews, err := imapFetchOverviews(client, uids)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to get overviews: %s", err), "imap-client//Get-overviews")
				}
				return *env.NewBlock(*env.NewTSeries(overviews))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "imap-client//Get-overviews")
			}
		},
	},

	"imap-client//Get-emails": {
		Argsn: 2,
		Doc:   "Gets full emails with bodies and attachments (slower) for a block of UIDs.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Get-emails")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Get-emails")
			}
			switch uidBlock := arg1.(type) {
			case env.Block:
				uids, argErr := imapUIDsFromBlock(ps, uidBlock, "imap-client//Get-emails")
				if argErr != nil {
					return argErr
				}
				emails, err := imapFetchEmails(client, uids)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to get emails: %s", err), "imap-client//Get-emails")
				}
				return *env.NewBlock(*env.NewTSeries(emails))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "imap-client//Get-emails")
			}
		},
	},

	"imap-client//Get-raw-emails": {
		Argsn: 2,
		Doc:   "Gets complete raw RFC 822 messages for a block of UIDs.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Get-raw-emails")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Get-raw-emails")
			}
			switch uidBlock := arg1.(type) {
			case env.Block:
				uids, argErr := imapUIDsFromBlock(ps, uidBlock, "imap-client//Get-raw-emails")
				if argErr != nil {
					return argErr
				}
				emails, err := imapFetchRawEmails(client, uids)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to get raw emails: %s", err), "imap-client//Get-raw-emails")
				}
				return *env.NewBlock(*env.NewTSeries(emails))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "imap-client//Get-raw-emails")
			}
		},
	},

	"imap-client//Mark-seen": {
		Argsn: 2,
		Doc:   "Marks an email as read/seen by UID.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Mark-seen")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Mark-seen")
			}
			switch uid := arg1.(type) {
			case env.Integer:
				cmd := client.Store(imap.UIDSetNum(imap.UID(uid.Value)), &imap.StoreFlags{
					Op:     imap.StoreFlagsAdd,
					Silent: true,
					Flags:  []imap.Flag{imap.FlagSeen},
				}, nil)
				if err := cmd.Close(); err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to mark email as seen: %s", err), "imap-client//Mark-seen")
				}
				return arg0
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "imap-client//Mark-seen")
			}
		},
	},

	"imap-client//Move-email": {
		Argsn: 3,
		Doc:   "Moves an email to another folder by UID.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Move-email")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Move-email")
			}
			switch uid := arg1.(type) {
			case env.Integer:
				switch folder := arg2.(type) {
				case env.String:
					if _, err := client.Move(imap.UIDSetNum(imap.UID(uid.Value)), folder.Value).Wait(); err != nil {
						return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to move email: %s", err), "imap-client//Move-email")
					}
					return arg0
				default:
					return evaldo.MakeArgError(ps, 3, []env.Type{env.StringType}, "imap-client//Move-email")
				}
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "imap-client//Move-email")
			}
		},
	},

	"imap-client//Delete-email": {
		Argsn: 2,
		Doc:   "Marks an email for deletion by UID (use expunge to permanently delete).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Delete-email")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Delete-email")
			}
			switch uid := arg1.(type) {
			case env.Integer:
				cmd := client.Store(imap.UIDSetNum(imap.UID(uid.Value)), &imap.StoreFlags{
					Op:     imap.StoreFlagsAdd,
					Silent: true,
					Flags:  []imap.Flag{imap.FlagDeleted},
				}, nil)
				if err := cmd.Close(); err != nil {
					return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to delete email: %s", err), "imap-client//Delete-email")
				}
				return arg0
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "imap-client//Delete-email")
			}
		},
	},

	"imap-client//Expunge": {
		Argsn: 1,
		Doc:   "Permanently removes emails marked for deletion.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Expunge")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Expunge")
			}
			if err := client.Expunge().Close(); err != nil {
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to expunge: %s", err), "imap-client//Expunge")
			}
			return arg0
		},
	},

	"imap-client//Close": {
		Argsn: 1,
		Doc:   "Logs out and closes the IMAP client connection.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			client, ok := imapClientFrom(arg0)
			if !ok {
				if _, native := arg0.(env.Native); native {
					return evaldo.MakeBuiltinError(ps, "Expected imap-client", "imap-client//Close")
				}
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "imap-client//Close")
			}
			_ = client.Logout().Wait()
			if err := client.Close(); err != nil {
				return evaldo.MakeBuiltinError(ps, fmt.Sprintf("failed to close connection: %s", err), "imap-client//Close")
			}
			return env.Void{}
		},
	},
}

var Builtins_js_interop = map[string]*env.Builtin{}

var Builtins_json = map[string]*env.Builtin{

	"parse-json": {
		Argsn: 1,
		Doc:   "Parses JSON string into Rye values.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch input := arg0.(type) {
			case env.String:
				var m any
				err := json.Unmarshal([]byte(input.Value), &m)
				if err != nil {
					return evaldo.MakeBuiltinError(ps, "Failed to Unmarshal.", "_parse_json")

				}
				return env.ToRyeValue(m)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "_parse_json")
			}
		},
	},

	"parse-json\\lines": {
		Argsn: 1,
		Doc:   "Parses JSON string into Rye values.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch input := arg0.(type) {
			case env.String:
				var vals []any
				decoder := json.NewDecoder(strings.NewReader(input.Value))
				for decoder.More() {
					var m any
					err := decoder.Decode(&m)
					if err != nil {
						return evaldo.MakeBuiltinError(ps, "Failed to Unmarshal.", "_parse_json\\lines")
					}
					vals = append(vals, env.ToRyeValue(m))
				}
				return *env.NewList(vals)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.StringType}, "_parse_json\\lines")
			}
		},
	},

	"to-json": {
		Argsn: 1,
		Doc:   "Converts a Rye value to a JSON string. Supports block (like list) and context (like dict).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewString(RyeToJSONWithIdxs(arg0, ps.Idx))
		},
	},

	"to-json\\lines": {
		Argsn: 1,
		Doc:   "Converts a table to JSON with each row on a separate line.",
		Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewString(RyeToJSONLines(arg0))
		},
	},
}

var Builtins_mail = map[string]*env.Builtin{

	"reader//Parse-email": {
		Argsn: 1,
		Doc:   "Parses email data from a reader.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch reader := arg0.(type) {
			case env.Native:
				email, err := parsemail.Parse(reader.Value.(io.Reader))
				if err != nil {
					return evaldo.MakeBuiltinError(ps, err.Error(), "reader//parse-email")
				}
				return *env.NewNative(ps.Idx, email, "parsed-email")
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "reader//parse-email")
			}
		},
	},

	"parsed-email//Subject?": {
		Argsn: 1,
		Doc:   "Gets the subject from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch email := arg0.(type) {
			case env.Native:
				return *env.NewString(email.Value.(parsemail.Email).Subject)
			default:
				return *evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "parsed-email//Subject?")
			}
		},
	},

	"parsed-email//Message-id?": {
		Argsn: 1,
		Doc:   "Gets the message ID from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch email := arg0.(type) {
			case env.Native:
				return *env.NewString(email.Value.(parsemail.Email).MessageID)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "parsed-email//message-id?")
			}
		},
	},

	"parsed-email//Html-body?": {
		Argsn: 1,
		Doc:   "Gets the HTML body from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch email := arg0.(type) {
			case env.Native:
				return *env.NewString(email.Value.(parsemail.Email).HTMLBody)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "parsed-email//html-body?")
			}
		},
	},

	"parsed-email//Text-body?": {
		Argsn: 1,
		Doc:   "Gets the plain text body from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch email := arg0.(type) {
			case env.Native:
				return *env.NewString(email.Value.(parsemail.Email).TextBody)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.NativeType}, "parsed-email//text-body?")
			}
		},
	},

	"parsed-email//Attachments?": {
		Argsn: 1,
		Doc:   "Gets the attachments from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, arg0, "smtpd")
		},
	},

	"parsed-email//Embedded-files?": {
		Argsn: 1,
		Doc:   "Gets the embedded files from a parsed email.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewNative(ps.Idx, arg0, "smtpd")
		},
	},
}

var Builtins_match = map[string]*env.Builtin{

	"match-block": {
		Argsn: 2,
		Doc:   "Tries to match and deconstruct a value into multiple values, with support for literal values, type checking, get-words, code evaluation, and nested blocks. First argument can be any value. If it doesn't match, returns failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			value := arg0

			// Convert value to a block if it's not already
			var valueBlock env.Block
			switch v := value.(type) {
			case env.Block:
				valueBlock = v
			default:

				valueBlock = env.Block{
					Series: *env.NewTSeries([]env.Object{value}),
				}
			}

			switch pattern := arg1.(type) {
			case env.Block:
				return matchBlock(ps, valueBlock, pattern)
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "match-block")
			}
		},
	},

	"match": {
		Argsn: 2,
		Doc:   "Matches a value against a series of pattern/action pairs. Pattern can be a single element or block. Returns the result of the first matching action, or failure if none match.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			value := arg0

			switch patternsBlock := arg1.(type) {
			case env.Block:

				if patternsBlock.Series.Len()%2 != 0 {
					return evaldo.MakeBuiltinError(ps, "Patterns block must contain an even number of elements (pairs)", "match")
				}

				for i := 0; i < patternsBlock.Series.Len(); i += 2 {
					pattern := patternsBlock.Series.Get(i)
					action := patternsBlock.Series.Get(i + 1)

					actionBlock, actionOk := action.(env.Block)
					if !actionOk {
						return evaldo.MakeBuiltinError(ps, "Action must be a block", "match")
					}

					oldFailureFlag := ps.FailureFlag
					ps.FailureFlag = false

					matchResult, _ := matchValue(ps, value, pattern, matchMode{0})

					if !ps.FailureFlag {

						ps.FailureFlag = oldFailureFlag

						ser := ps.Ser
						ps.Ser = actionBlock.Series
						evaldo.EvalBlockInj(ps, value, true)
						ps.Ser = ser
						return ps.Res
					}

					ps.FailureFlag = oldFailureFlag
					_ = matchResult
				}

				ps.FailureFlag = true
				return evaldo.MakeBuiltinError(ps, "No pattern matched the value", "match")
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "match")
			}
		},
	},
}

var Builtins_math = map[string]*env.Builtin{

	"mod": {
		Argsn: 2,
		Doc:   "Returns the remainder of dividing x by y.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			fa, fb, errPos := assureFloats(arg0, arg1)
			if errPos > 0 {
				return evaldo.MakeArgError(ps, errPos, []env.Type{env.IntegerType, env.BlockType}, "mod")
			}
			return *env.NewDecimal(math.Mod(fa, fb))
		},
	},

	"pow": {
		Argsn: 2,
		Doc:   "Returns base raised to the power of exponent.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch base := arg0.(type) {
			case env.Complex:
				switch exp := arg1.(type) {
				case env.Complex:
					return *env.NewComplex(cmplx.Pow(base.Value, exp.Value))
				case env.Integer:
					return *env.NewComplex(cmplx.Pow(base.Value, complex(float64(exp.Value), 0)))
				case env.Decimal:
					return *env.NewComplex(cmplx.Pow(base.Value, complex(exp.Value, 0)))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "pow")
				}
			case env.Integer:
				switch exp := arg1.(type) {
				case env.Complex:
					return *env.NewComplex(cmplx.Pow(complex(float64(base.Value), 0), exp.Value))
				case env.Integer:
					return *env.NewDecimal(math.Pow(float64(base.Value), float64(exp.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Pow(float64(base.Value), exp.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "pow")
				}
			case env.Decimal:
				switch exp := arg1.(type) {
				case env.Complex:
					return *env.NewComplex(cmplx.Pow(complex(base.Value, 0), exp.Value))
				case env.Integer:
					return *env.NewDecimal(math.Pow(base.Value, float64(exp.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Pow(base.Value, exp.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "pow")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "pow")
			}
		},
	},

	"log2": {
		Argsn: 1,
		Doc:   "Returns the binary logarithm (base-2) of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Log2(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Log2(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "log2")
			}
		},
	},

	"log10": {
		Argsn: 1,
		Doc:   "Returns the decimal logarithm (base-10) of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Log10(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Log10(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "log10")
			}
		},
	},

	"log": {
		Argsn: 1,
		Doc:   "Returns the natural logarithm of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				if val.Value <= 0 {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Can't compute logarithm of zero or negative number.", "log")
				}
				return *env.NewDecimal(math.Log(float64(val.Value)))
			case env.Decimal:
				if val.Value <= 0 {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Can't compute logarithm of zero or negative number.", "log")
				}
				return *env.NewDecimal(math.Log(val.Value))
			case env.Complex:
				if val.Value == complex(0, 0) {
					ps.FailureFlag = true
					return evaldo.MakeBuiltinError(ps, "Can't compute logarithm of zero.", "log")
				}
				return *env.NewComplex(cmplx.Log(val.Value))
			case env.Vector:
				data := make(govector.Vector, len(val.Value))
				for i, v := range val.Value {
					data[i] = math.Log(v)
				}
				return *env.NewVector(data)
			case env.Matrix:
				data := make([]float64, len(val.Data))
				for i, v := range val.Data {
					data[i] = math.Log(v)
				}
				return *env.NewMatrixWithData(val.Rows, val.Cols, data)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType, env.VectorType, env.MatrixType}, "log")
			}
		},
	},

	"log1p": {
		Argsn: 1,
		Doc:   "Returns the natural logarithm of 1 plus its argument x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Log1p(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Log1p(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "log1p")
			}
		},
	},

	"logb": {
		Argsn: 1,
		Doc:   "Returns the binary exponent of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Logb(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Logb(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "logb")
			}
		},
	},

	"sq": {
		Argsn: 1,
		Doc:   "Returns the square of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Pow(float64(val.Value), 2.0))
			case env.Decimal:
				return *env.NewDecimal(math.Pow(val.Value, 2.0))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "sq")
			}
		},
	},

	"sin": {
		Argsn: 1,
		Doc:   "Returns the sine of the radian argument.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Sin(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Sin(val.Value))
			case env.Complex:
				return *env.NewComplex(cmplx.Sin(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "sin")
			}
		},
	},

	"cos": {
		Argsn: 1,
		Doc:   "Returns the cosine of the radian argument.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Cos(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Cos(val.Value))
			case env.Complex:
				return *env.NewComplex(cmplx.Cos(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "cos")
			}
		},
	},

	"tan": {
		Argsn: 1,
		Doc:   "Returns the tangent of the radian argument.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Tan(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Tan(val.Value))
			case env.Complex:
				return *env.NewComplex(cmplx.Tan(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType}, "tan")
			}
		},
	},

	"sqrt": {
		Argsn: 1,
		Doc:   "Returns the square root of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Sqrt(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Sqrt(val.Value))
			case env.Complex:
				return *env.NewComplex(cmplx.Sqrt(val.Value))
			case env.Vector:
				data := make(govector.Vector, len(val.Value))
				for i, v := range val.Value {
					data[i] = math.Sqrt(v)
				}
				return *env.NewVector(data)
			case env.Matrix:
				data := make([]float64, len(val.Data))
				for i, v := range val.Data {
					data[i] = math.Sqrt(v)
				}
				return *env.NewMatrixWithData(val.Rows, val.Cols, data)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType, env.VectorType, env.MatrixType}, "sqrt")
			}
		},
	},

	"abs": {
		Argsn: 1,
		Doc:   "Returns the absolute value of a number.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewInteger(int64(math.Abs(float64(val.Value))))
			case env.Decimal:
				return *env.NewDecimal(math.Abs(val.Value))
			case env.Complex:
				return *env.NewDecimal(cmplx.Abs(val.Value))
			case env.Vector:
				data := make(govector.Vector, len(val.Value))
				for i, v := range val.Value {
					data[i] = math.Abs(v)
				}
				return *env.NewVector(data)
			case env.Matrix:
				data := make([]float64, len(val.Data))
				for i, v := range val.Data {
					data[i] = math.Abs(v)
				}
				return *env.NewMatrixWithData(val.Rows, val.Cols, data)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType, env.VectorType, env.MatrixType}, "abs")
			}
		},
	},

	"acos": {
		Argsn: 1,
		Doc:   "Returns the arccosine (inverse cosine) in radians.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				if val.Value < -1.0 || val.Value > 1.0 {
					return evaldo.MakeBuiltinError(ps, "Invalid input: Acos is only defined for -1 <= x <= 1.", "acos")
				}
				return *env.NewDecimal(math.Acos(float64(val.Value)))
			case env.Decimal:
				if val.Value < -1.0 || val.Value > 1.0 {
					return evaldo.MakeBuiltinError(ps, "Invalid input: Acos is only defined for -1 <= x <= 1.", "acos")
				}
				return *env.NewDecimal(math.Acos(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "acos")
			}
		},
	},

	"acosh": {
		Argsn: 1,
		Doc:   "Returns the inverse hyperbolic cosine.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				if val.Value < 1.0 {
					return evaldo.MakeBuiltinError(ps, " Acosh is only defined for x >= 1.", "acosh")
				}
				return *env.NewDecimal(math.Log(float64(val.Value) + math.Sqrt(float64(val.Value)*float64(val.Value)-1)))
			case env.Decimal:
				if val.Value < 1.0 {
					return evaldo.MakeBuiltinError(ps, " Acosh is only defined for x >= 1.", "acosh")
				}
				return *env.NewDecimal(math.Log(val.Value + math.Sqrt(val.Value*val.Value-1)))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "acosh")
			}
		},
	},

	"asin": {
		Argsn: 1,
		Doc:   "Returns the arcsine (inverse sine) in radians.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				if val.Value < -1.0 || val.Value > 1.0 {
					return evaldo.MakeBuiltinError(ps, "Invalid input: Asin is only defined for -1 <= x <= 1.", "asin")
				}
				return *env.NewDecimal(math.Asin(float64(val.Value)))
			case env.Decimal:
				if val.Value < -1.0 || val.Value > 1.0 {
					return evaldo.MakeBuiltinError(ps, "Invalid input: Asin is only defined for -1 <= x <= 1.", "asin")
				}
				return *env.NewDecimal(math.Asin(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "asin")
			}
		},
	},

	"asinh": {
		Argsn: 1,
		Doc:   "Returns the inverse hyperbolic sine.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Log(float64(val.Value) + math.Sqrt(float64(val.Value)*float64(val.Value)+1)))
			case env.Decimal:
				return *env.NewDecimal(math.Log(val.Value + math.Sqrt(val.Value*val.Value+1)))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "asinh")
			}
		},
	},

	"atan": {
		Argsn: 1,
		Doc:   "Returns the arctangent (inverse tangent) in radians.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Atan(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Atan(val.Value))
			default:
				return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "atan")
			}
		},
	},

	"atan2": {
		Argsn: 2,
		Doc:   "Returns the arc tangent of y/x, using the signs of the two to determine the quadrant of the return value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Atan2(float64(val.Value), float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Atan2(float64(val.Value), val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "atan2")
				}
			case env.Decimal:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Atan2(val.Value, float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Atan2(val.Value, val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "atan2")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "atan2")
			}
		},
	},

	"atanh": {
		Argsn: 1,
		Doc:   "Returns the inverse hyperbolic tangent.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Atanh(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Atanh(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "atanh")
			}
		},
	},

	"ceil": {
		Argsn: 1,
		Doc:   "Returns the least integer value greater than or equal to x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(float64(val.Value))
			case env.Decimal:
				return *env.NewDecimal(math.Ceil(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "ceil")
			}
		},
	},

	"cbrt": {
		Argsn: 1,
		Doc:   "Returns the cube root of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Cbrt(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Cbrt(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "cbrt")
			}
		},
	},

	"copysign": {
		Argsn: 2,
		Doc:   "Returns a value with the magnitude of x and the sign of y.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Copysign(float64(val.Value), float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Copysign(float64(val.Value), val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "copysign")
				}
			case env.Decimal:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Copysign(val.Value, float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Copysign(val.Value, val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "copysign")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "copysign")
			}
		},
	},

	"dim": {
		Argsn: 2,
		Doc:   "Returns the maximum of x-y or 0.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(util.GetDimValue(float64(val.Value), float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(util.GetDimValue(float64(val.Value), val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "dim")
				}
			case env.Decimal:
				switch val2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(util.GetDimValue(val.Value, float64(val2.Value)))
				case env.Decimal:
					return *env.NewDecimal(util.GetDimValue(val.Value, val2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "dim")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "dim")
			}
		},
	},

	"round\\to": {
		Argsn: 2,
		Doc:   "Rounds a decimal to the specified number of decimal places.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Decimal:
				switch precision := arg1.(type) {
				case env.Integer:
					ratio := math.Pow(10, float64(precision.Value))
					return *env.NewDecimal(math.Round(val.Value*ratio) / ratio)
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "round\\to")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.DecimalType}, "round\\to")
			}
		},
	},

	"round": {
		Argsn: 1,
		Doc:   "Rounds a decimal to the nearest integer.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Decimal:
				return *env.NewDecimal(math.Round(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.DecimalType}, "round\\to")
			}
		},
	},

	"roundtoeven": {
		Argsn: 1,
		Doc:   "Returns the nearest integer, rounding ties to even.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Decimal:
				return *env.NewDecimal(math.RoundToEven(val.Value))
			case env.Integer:
				return *env.NewDecimal(math.RoundToEven(float64(val.Value)))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.DecimalType, env.IntegerType}, "roundtoeven")
			}
		},
	},

	"erf": {
		Argsn: 1,
		Doc:   "Returns the error function of value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Erf(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Erf(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "erf")
			}
		},
	},

	"erfc": {
		Argsn: 1,
		Doc:   "Returns the complementary error function of value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Erfc(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Erfc(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "erfc")
			}
		},
	},

	"erfcinv": {
		Argsn: 1,
		Doc:   "Returns the inverse of erfc(x) function.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Erfcinv(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Erfcinv(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "erfcinv")
			}
		},
	},

	"erfinv": {
		Argsn: 1,
		Doc:   "Returns the inverse error function of value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Erfinv(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Erfinv(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "erfinv")
			}
		},
	},

	"exp": {
		Argsn: 1,
		Doc:   "Returns e**x, the base-e exponential of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Exp(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Exp(val.Value))
			case env.Complex:
				return *env.NewComplex(cmplx.Exp(val.Value))
			case env.Vector:
				data := make(govector.Vector, len(val.Value))
				for i, v := range val.Value {
					data[i] = math.Exp(v)
				}
				return *env.NewVector(data)
			case env.Matrix:
				data := make([]float64, len(val.Data))
				for i, v := range val.Data {
					data[i] = math.Exp(v)
				}
				return *env.NewMatrixWithData(val.Rows, val.Cols, data)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType, env.ComplexType, env.VectorType, env.MatrixType}, "exp")
			}
		},
	},

	"exp2": {
		Argsn: 1,
		Doc:   "Returns 2**x, the base-2 exponential of x.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Exp2(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Exp2(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "exp2")
			}
		},
	},

	"expm1": {
		Argsn: 1,
		Doc:   "Returns e**x - 1, the base-e exponential of x minus 1. It is more accurate than exp(x) - 1 when x is near zero.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Expm1(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Expm1(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "expm1")
			}
		},
	},

	"fma": {
		Argsn: 3,
		Doc:   "Returns x * y + z, computed with only one rounding. (That is, FMA returns the fused multiply-add of x, y, and z.)",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val1 := arg0.(type) {
			case env.Integer:
				switch val2 := arg1.(type) {
				case env.Integer:
					switch val3 := arg2.(type) {
					case env.Integer:
						return *env.NewDecimal(math.FMA(float64(val1.Value), float64(val2.Value), float64(val3.Value)))
					case env.Decimal:
						return *env.NewDecimal(math.FMA(float64(val1.Value), float64(val2.Value), val3.Value))
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.IntegerType, env.DecimalType}, "fma")
					}
				case env.Decimal:
					switch val3 := arg2.(type) {
					case env.Integer:
						return *env.NewDecimal(math.FMA(float64(val1.Value), val2.Value, float64(val3.Value)))
					case env.Decimal:
						return *env.NewDecimal(math.FMA(float64(val1.Value), val2.Value, val3.Value))
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.IntegerType, env.DecimalType}, "fma")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "fma")
				}
			case env.Decimal:
				switch val2 := arg1.(type) {
				case env.Integer:
					switch val3 := arg2.(type) {
					case env.Integer:
						return *env.NewDecimal(math.FMA(val1.Value, float64(val2.Value), float64(val3.Value)))
					case env.Decimal:
						return *env.NewDecimal(math.FMA(val1.Value, float64(val2.Value), val3.Value))
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.IntegerType, env.DecimalType}, "fma")
					}
				case env.Decimal:
					switch val3 := arg2.(type) {
					case env.Integer:
						return *env.NewDecimal(math.FMA(val1.Value, val2.Value, float64(val3.Value)))
					case env.Decimal:
						return *env.NewDecimal(math.FMA(val1.Value, val2.Value, val3.Value))
					default:
						return evaldo.MakeArgError(ps, 3, []env.Type{env.IntegerType, env.DecimalType}, "fma")
					}
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "fma")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "fma")
			}
		},
	},

	"j0": {
		Argsn: 1,
		Doc:   "Returns the order-zero Bessel function of the first kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.J0(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.J0(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "j0")
			}
		},
	},

	"j1": {
		Argsn: 1,
		Doc:   "Returns the order-one Bessel function of the first kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.J1(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.J1(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "j1")
			}
		},
	},

	"y0": {
		Argsn: 1,
		Doc:   "Returns the order-zero Bessel function of the second kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Y0(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Y0(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "y0")
			}
		},
	},

	"y1": {
		Argsn: 1,
		Doc:   "Returns the order-one Bessel function of the second kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(math.Y1(float64(val.Value)))
			case env.Decimal:
				return *env.NewDecimal(math.Y1(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "y1")
			}
		},
	},

	"yn": {
		Argsn: 2,
		Doc:   "Returns the order-n Bessel function of the second kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch v1 := arg0.(type) {
			case env.Integer:
				switch v2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Yn(int(v1.Value), float64(v2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Yn(int(v1.Value), v2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "yn")
				}
			case env.Decimal:
				switch v2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Yn(int(v1.Value), float64(v2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Yn(int(v1.Value), v2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "yn")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "yn")
			}
		},
	},

	"jn": {
		Argsn: 2,
		Doc:   "Returns the order-n Bessel function of the first kind.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch v1 := arg0.(type) {
			case env.Integer:
				switch v2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Jn(int(v1.Value), float64(v2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Jn(int(v1.Value), v2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "jn")
				}
			case env.Decimal:
				switch v2 := arg1.(type) {
				case env.Integer:
					return *env.NewDecimal(math.Jn(int(v1.Value), float64(v2.Value)))
				case env.Decimal:
					return *env.NewDecimal(math.Jn(int(v1.Value), v2.Value))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType, env.DecimalType}, "jn")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "jn")
			}
		},
	},

	"trunc": {
		Argsn: 1,
		Doc:   "Returns the integer value of input.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				return *env.NewDecimal(float64(val.Value))
			case env.Decimal:
				return *env.NewDecimal(math.Trunc(val.Value))
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "trunc")
			}
		},
	},

	"pi": {
		Argsn: 0,
		Doc:   "Returns the mathematical constant π (pi).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return *env.NewDecimal(float64(math.Pi))
		},
	},

	"deg->rad": {
		Argsn: 1,
		Doc:   "Converts degrees to radians.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var fa float64
			switch a := arg0.(type) {
			case env.Decimal:
				fa = a.Value
			case env.Integer:
				fa = float64(a.Value)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "deg->rad")
			}
			return *env.NewDecimal(fa * float64(math.Pi) / 180.0)
		},
	},

	"is-near": {
		Argsn: 2,
		Doc:   "Returns true if two decimals are close.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			fa, fb, errPos := assureFloats(arg0, arg1)
			if errPos > 0 {
				return evaldo.MakeArgError(ps, errPos, []env.Type{env.IntegerType, env.BlockType}, "is-near")
			}
			const epsilon = 0.0000000000001 // math.SmallestNonzeroFloat64
			if math.Abs(fa-fb) <= (epsilon) {
				return env.NewBoolean(true)
			} else {
				return env.NewBoolean(false)
			}
		},
	},

	"near-zero": {
		Argsn: 1,
		Doc:   "Returns true if a decimal is close to zero.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var fa float64
			switch a := arg0.(type) {
			case env.Decimal:
				fa = a.Value
			case env.Integer:
				fa = float64(a.Value)
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType, env.BlockType}, "near-zero")
			}
			// const epsilon = math.SmallestNonzeroFloat64
			const epsilon = 0.0000000000001 // math.SmallestNonzeroFloat64
			if math.Abs(fa) <= epsilon {
				return env.NewBoolean(true)
			} else {
				return env.NewBoolean(false)
			}
		},
	},

	"is-prime": {
		Argsn: 1,
		Doc:   "Returns true if the integer is a prime number.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val := arg0.(type) {
			case env.Integer:
				if val.Value <= 1 {
					return *env.NewBoolean(false)
				}
				if primes.IsPrime(int(val.Value)) {
					return *env.NewBoolean(true)
				} else {
					return *env.NewBoolean(false)
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "is-prime")
			}
		},
	},

	"to-eyr": {
		Argsn: 1,
		Doc:   "Converts math dialect to Eyr dialect.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return DialectMath(ps, arg0)
		},
	},

	"calc": {
		Argsn: 1,
		Doc:   "Evaluates expressions in math dialect.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			res := DialectMath(ps, arg0)
			switch block := res.(type) {
			case env.Block:

				ps.ResetStack()
				ser := ps.Ser
				ps.Ser = block.Series
				Eyr_EvalBlock(ps, false)
				ps.Ser = ser
				return ps.Res
			default:
				return res
			}
		},
	},

	"gcd": {
		Argsn: 2,
		Doc:   "Returns the greatest common divisor of two integers using Euclidean algorithm.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch val1 := arg0.(type) {
			case env.Integer:
				switch val2 := arg1.(type) {
				case env.Integer:
					a := val1.Value
					b := val2.Value

					if a < 0 {
						a = -a
					}
					if b < 0 {
						b = -b
					}

					for b != 0 {
						temp := b
						b = a % b
						a = temp
					}

					return *env.NewInteger(a)
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.IntegerType}, "gcd")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.IntegerType}, "gcd")
			}
		},
	},

	"outer-product": {
		Argsn: 2,
		Doc:   "Computes the outer product of two vectors (blocks), returning a matrix (block of blocks) where each element [i,j] = a[i] * b[j]. Similar to numpy.outer().",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch vec1 := arg0.(type) {
			case env.Block:
				switch vec2 := arg1.(type) {
				case env.Block:

					result := make([]env.Object, vec1.Series.Len())

					for i := 0; i < vec1.Series.Len(); i++ {

						val1 := vec1.Series.Get(i)
						var f1 float64
						var isDecimal1 bool

						switch v1 := val1.(type) {
						case env.Integer:
							f1 = float64(v1.Value)
							isDecimal1 = false
						case env.Decimal:
							f1 = v1.Value
							isDecimal1 = true
						default:
							return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Element at position %d in first block must be integer or decimal", i), "outer-product")
						}

						row := make([]env.Object, vec2.Series.Len())

						for j := 0; j < vec2.Series.Len(); j++ {

							val2 := vec2.Series.Get(j)
							var f2 float64
							var isDecimal2 bool

							switch v2 := val2.(type) {
							case env.Integer:
								f2 = float64(v2.Value)
								isDecimal2 = false
							case env.Decimal:
								f2 = v2.Value
								isDecimal2 = true
							default:
								return evaldo.MakeBuiltinError(ps, fmt.Sprintf("Element at position %d in second block must be integer or decimal", j), "outer-product")
							}

							product := f1 * f2

							if isDecimal1 || isDecimal2 {
								row[j] = *env.NewDecimal(product)
							} else {
								row[j] = *env.NewInteger(int64(product))
							}
						}

						result[i] = *env.NewBlock(*env.NewTSeries(row))
					}

					return *env.NewBlock(*env.NewTSeries(result))
				default:
					return evaldo.MakeArgError(ps, 2, []env.Type{env.BlockType}, "outer-product")
				}
			default:
				return evaldo.MakeArgError(ps, 1, []env.Type{env.BlockType}, "outer-product")
			}
		},
	},
}