lib

var Assert = []sim.NativeFunction{
	{
		Name:      "assert.contains",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 2:
				if err := ValidateArgs(args, sim.String, sim.String); err != nil {
					return sim.NullValue, err
				}
			case 3:
				if err := ValidateArgs(args, sim.String, sim.String, sim.String); err != nil {
					return sim.NullValue, err
				}
				msg = args[2].String()
			default:
				return sim.NullValue, fmt.Errorf("expected 2 or 3 args, got %d", ln)
			}

			a := args[0].String()
			b := args[1].String()

			if !strings.Contains(b, a) {
				if msg != "" {
					return sim.NullValue, errors.New(msg)
				}
				return sim.NullValue, fmt.Errorf("'%s' not contained in '%s'", a, b)
			}
			return sim.NullValue, nil
		},
	},

	{
		Name:      "assert.equal",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 2:
			case 3:
				a3 := args[2]
				if a3.Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected error message to be a string, got %v", a3.TypeName())
				}
				msg = a3.String()
			default:
				return sim.NullValue, fmt.Errorf("expected 2 or 3 args, got %d", ln)

			}

			a := args[0]
			b := args[1]

			if !areEqual(a, b) {
				if msg != "" {
					return sim.NullValue, errors.New(msg)
				}
				return sim.NullValue, fmt.Errorf("values are different: %v, %v", serializeOrErr(a), serializeOrErr(b))
			}
			return sim.NullValue, nil
		},
	},
	{
		Name:      "assert.isTrue",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 1:
			case 2:
				if args[1].Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected error message to be a string, got %v", args[1].TypeName())
				}
				msg = args[1].String()
			default:
				return sim.NullValue, fmt.Errorf("expected 1 or 2 args, got %d", ln)
			}

			a := args[0]

			switch a.Type {
			case sim.Bool:
				if a.ToBool() {
					return sim.TrueValue, nil
				}
			}

			if msg != "" {
				return sim.NullValue, errors.New(msg)
			}
			return sim.NullValue, fmt.Errorf("expected true, got %v", a)
		},
	},
	{
		Name:      "assert.isFalse",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 1:
			case 2:
				if args[1].Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected error message to be a string, got %v", args[1].TypeName())
				}
				msg = args[1].String()
			default:
				return sim.NullValue, fmt.Errorf("expected 1 or 2 args, got %d", ln)
			}

			a := args[0]

			switch a.Type {
			case sim.Bool:
				if !a.ToBool() {
					return sim.TrueValue, nil
				}
			}

			if msg != "" {
				return sim.NullValue, errors.New(msg)
			}
			return sim.NullValue, fmt.Errorf("expected false, got %v", a)
		},
	},
	{
		Name:      "assert.isNull",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 1:
			case 2:
				if args[1].Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected error message to be a string, got %v", args[1].TypeName())
				}
				msg = args[1].String()
			default:
				return sim.NullValue, fmt.Errorf("expected 1 or 2 args, got %d", ln)
			}

			a := args[0]

			switch a.Type {
			case sim.Null, sim.Undefined:
			default:
				if msg != "" {
					return sim.NullValue, errors.New(msg)
				}
				return sim.NullValue, fmt.Errorf("expected null, got %v", a)
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "assert.isNotNull",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var msg string
			ln := len(args)
			switch ln {
			case 1:
			case 2:
				if args[1].Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected error message to be a string, got %v", args[1].TypeName())
				}
				msg = args[1].String()
			default:
				return sim.NullValue, fmt.Errorf("expected 1 or 2 args, got %d", ln)
			}

			a := args[0]

			switch a.Type {
			case sim.Null, sim.Undefined:
				if msg != "" {
					return sim.NullValue, errors.New(msg)
				}
				return sim.NullValue, fmt.Errorf("%v is null", a)
			default:
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "assert.exception",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			if a.Type != sim.String {
				return sim.NullValue, fmt.Errorf("expected argument 1 to be a string, got %s", a.TypeName())
			}

			expected := a.String()

			v := args[1]
			err := runFuncOrClosure(vm, v)
			if err == nil {
				return sim.NullValue, fmt.Errorf("expected exception: %s", expected)
			}

			if expected != "" && !strings.Contains(err.Error(), expected) {
				return sim.NullValue, fmt.Errorf("invalid exception, does not contain '%s': %s", expected, err.Error())
			}

			vm.Error = nil

			return sim.NullValue, nil
		},
	},
	{
		Name:      "assert.int",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be a string, got %s", args[1].TypeName())
			}

			a := args[0]
			msg := args[1].String()

			var v int64
			var err error

			switch a.Type {
			case sim.Int:
				v = a.ToInt()
			case sim.String:
				v, err = strconv.ParseInt(a.String(), 0, 64)
				if err != nil {
					return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not int", a.TypeName()))
				}
			default:
				return sim.NullValue, errors.New(msg)
			}

			return sim.NewInt64(v), nil
		},
	},
	{
		Name:      "assert.float",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be a string, got %s", args[1].TypeName())
			}

			a := args[0]
			msg := args[1].String()

			var v int64
			var err error

			switch a.Type {
			case sim.Int:
				v = a.ToInt()
			case sim.String:
				v, err = strconv.ParseInt(a.String(), 0, 64)
				if err != nil {
					return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not float", a.TypeName()))
				}
			default:
				return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not float", a.TypeName()))
			}

			return sim.NewInt64(v), nil
		},
	},
	{
		Name:      "assert.string",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be a string, got %s", args[1].TypeName())
			}

			a := args[0]
			msg := args[1].String()

			var v string

			switch a.Type {
			case sim.Int, sim.Float, sim.Bool, sim.String:
				v = a.String()
			default:
				return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not a string", a.TypeName()))
			}

			return sim.NewString(v), nil
		},
	},
	{
		Name:      "assert.bool",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be a string, got %s", args[1].TypeName())
			}

			a := args[0]
			msg := args[1].String()
			var v sim.Value

			switch a.Type {

			case sim.Bool:
				v = a

			case sim.Int:
				switch a.ToInt() {
				case 0:
					v = sim.FalseValue
				case 1:
					v = sim.TrueValue
				default:
					return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not bool", a.TypeName()))
				}

			case sim.String:
				s := a.String()
				s = strings.Trim(s, " ")
				switch s {
				case "true", "1":
					v = sim.TrueValue
				case "false", "0":
					v = sim.FalseValue
				default:
					return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not bool", a.TypeName()))
				}

			default:
				return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not bool", a.TypeName()))

			}

			return v, nil
		},
	},
	{
		Name:      "assert.object",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be a string, got %s", args[1].TypeName())
			}

			a := args[0]
			msg := args[1].String()

			switch a.Type {
			case sim.Map:
			default:
				return sim.NullValue, fmt.Errorf(msg, showAssertMessage("%v is not an object", a.TypeName()))
			}

			return a, nil
		},
	},
}

var Async = []sim.NativeFunction{
	{
		Name:        "go",
		Arguments:   1,
		Permissions: []string{"async"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return launchGoroutine(args, vm, nil)
		},
	},
}

var Atomic = []sim.NativeFunction{
	{
		Name:      "atomic.addInt",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int, sim.Int); err != nil {
				return sim.NullValue, err
			}

			i := args[0]
			v := args[1]

			// Handle both pointer and direct int64 values
			var ptr *int64
			switch val := i.Internal.(type) {
			case *int64:
				ptr = val
			case int64:

				newVal := val + v.ToInt()
				i.Internal = newVal
				return sim.NewInt64(newVal), nil
			default:
				return sim.NullValue, fmt.Errorf("expected an int, got %T", i.Internal)
			}

			atomic.AddInt64(ptr, v.ToInt())

			return i, nil
		},
	},
	{
		Name:      "atomic.storeInt",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int, sim.Int); err != nil {
				return sim.NullValue, err
			}

			i := args[0]
			v := args[1]

			// Handle both pointer and direct int64 values
			var ptr *int64
			switch val := i.Internal.(type) {
			case *int64:
				ptr = val
			case int64:

				newVal := v.ToInt()
				i.Internal = newVal
				return sim.NewInt64(newVal), nil
			default:
				return sim.NullValue, fmt.Errorf("expected an int, got %T", i.Internal)
			}

			atomic.StoreInt64(ptr, v.ToInt())

			return i, nil
		},
	},
	{
		Name:      "atomic.loadInt",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			i := args[0]

			switch val := i.Internal.(type) {
			case *int64:
				v := atomic.LoadInt64(val)
				return sim.NewInt64(v), nil
			case int64:

				return sim.NewInt64(val), nil
			default:
				return sim.NullValue, fmt.Errorf("expected an int, got %T", i.Internal)
			}
		},
	},
}

var Base64 = []sim.NativeFunction{
	{
		Name:      "base64.encode",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.Bytes, sim.String:
				encoder := base64.RawStdEncoding
				encoded := encoder.EncodeToString(a.ToBytes())
				return sim.NewString(encoded), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
	{
		Name:      "base64.encodeWithPadding",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.Bytes, sim.String:
				encoder := base64.StdEncoding.WithPadding(base64.StdPadding)
				encoded := encoder.EncodeToString(a.ToBytes())
				return sim.NewString(encoded), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
	{
		Name:      "base64.encodeURLWithPadding",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.Bytes, sim.String:
				encoder := base64.RawURLEncoding.WithPadding(base64.StdPadding)
				encoded := encoder.EncodeToString(a.ToBytes())
				return sim.NewString(encoded), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
	{
		Name:      "base64.decode",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.String:
				encoder := base64.RawStdEncoding
				decoded, err := encoder.DecodeString(a.String())
				if err != nil {
					return sim.NullValue, err
				}
				return sim.NewBytes(decoded), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
	{
		Name:      "base64.decodeWithPadding",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.String:
				encoder := base64.StdEncoding.WithPadding(base64.StdPadding)
				encoded, err := encoder.DecodeString(a.String())
				if err != nil {
					return sim.NullValue, err
				}
				return sim.NewBytes(encoded), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
}

var Binary = []sim.NativeFunction{
	{
		Name:      "binary.putInt16LittleEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.LittleEndian.PutUint16(b, uint16(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.putInt32LittleEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.LittleEndian.PutUint32(b, uint32(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.putInt64LittleEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.LittleEndian.PutUint64(b, uint64(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.putInt16BigEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.BigEndian.PutUint16(b, uint16(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.putInt32BigEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.BigEndian.PutUint32(b, uint32(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.putInt64BigEndian",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := args[1].ToInt()
			binary.BigEndian.PutUint64(b, uint64(i))
			return sim.NullValue, nil
		},
	},
	{
		Name:      "binary.int16LittleEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.LittleEndian.Uint16(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
	{
		Name:      "binary.int32LittleEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.LittleEndian.Uint32(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
	{
		Name:      "binary.int64LittleEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.LittleEndian.Uint64(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
	{
		Name:      "binary.int16BigEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.BigEndian.Uint16(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
	{
		Name:      "binary.int32BigEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.BigEndian.Uint32(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
	{
		Name:      "binary.int64BigEndian",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			i := binary.BigEndian.Uint64(b)
			return sim.NewInt64(int64(i)), nil
		},
	},
}

var Bufio = []sim.NativeFunction{
	{
		Name:      "bufio.newScanner",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToObject()

			reader, ok := r.(io.Reader)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a io.Reader, got %v", args[0])
			}

			s := bufio.NewScanner(reader)

			return sim.NewObject(&scanner{s}), nil
		},
	},
	{
		Name:      "bufio.newReader",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToObject()

			reader, ok := r.(io.Reader)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a io.Reader, got %v", args[0])
			}

			s := bufio.NewReader(reader)

			return sim.NewObject(&bufioReader{s}), nil
		},
	},
	{
		Name:      "bufio.newWriter",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToObject()

			w, ok := r.(io.Writer)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a io.Writer, got %v", args[0])
			}

			s := bufio.NewWriter(w)

			return sim.NewObject(&bufioWriter{s}), nil
		},
	},
}

var Bytecode = []sim.NativeFunction{
	{
		Name:      "bytecode.compile",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()

			var fs filesystem.FS

			l := len(args)

			if l > 1 {
				filesystem, ok := args[1].ToObjectOrNil().(*FileSystemObj)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected a filesystem, got %v", args[1])
				}
				fs = filesystem.FS
			} else {
				fs = vm.FileSystem
			}

			p, err := sim.Compile(fs, path)
			if err != nil {
				return sim.NullValue, fmt.Errorf("compiling %s: %w", path, err)
			}

			if err := ValidatePermissions(p, vm); err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(&program{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.compileStr",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			code := args[0].String()

			p, err := sim.CompileStr(code)
			if err != nil {
				return sim.NullValue, errors.New(err.Error())
			}

			if err := ValidatePermissions(p, vm); err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(&program{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.hash",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.Bool, sim.Bool, sim.Object); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()

			var fs filesystem.FS

			l := len(args)

			if l > 1 {
				filesystem, ok := args[1].ToObjectOrNil().(*FileSystemObj)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected a filesystem, got %v", args[1])
				}
				fs = filesystem.FS
			} else {
				fs = vm.FileSystem
			}

			hash, err := parser.Hash(fs, path)
			if err != nil {
				return sim.NullValue, fmt.Errorf("compiling %s: %w", path, err)
			}

			s := base64.StdEncoding.EncodeToString(hash)
			return sim.NewString(s), nil
		},
	},
	{
		Name:      "bytecode.parseStr",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			code := args[0].String()

			p, err := sim.ParseStr(code)
			if err != nil {
				return sim.NullValue, errors.New(err.Error())
			}

			return sim.NewObject(&astProgram{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.loadProgram",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			p, err := binary.Load(args[0].ToBytes())
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(&program{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.load",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			l := len(args)
			path := args[0].String()
			var fs filesystem.FS

			if l > 1 {
				filesystem, ok := args[1].ToObjectOrNil().(*FileSystemObj)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected a filesystem, got %v", args[1])
				}
				fs = filesystem.FS
			} else {
				fs = vm.FileSystem
			}

			f, err := fs.Open(path)
			if err != nil {
				return sim.NullValue, err
			}
			defer f.Close()

			p, err := binary.Read(f)
			if err != nil {
				return sim.NullValue, err
			}

			p.Name = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))

			return sim.NewObject(&program{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.readProgram",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r, ok := args[0].ToObjectOrNil().(io.Reader)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be io.Reader, got %T", args[0].ToObjectOrNil())
			}

			p, err := binary.Read(r)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(&program{prog: p}), nil
		},
	},
	{
		Name:      "bytecode.writeProgram",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object, sim.Object); err != nil {
				return sim.NullValue, err
			}

			w, ok := args[0].ToObjectOrNil().(io.Writer)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be io.Reader, got %T", args[0].ToObjectOrNil())
			}

			p, ok := args[1].ToObjectOrNil().(*program)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected parameter 2 to be a program, got %T", args[0].ToObjectOrNil())
			}

			if err := binary.Write(w, p.prog); err != nil {
				return sim.NullValue, err
			}

			return sim.NullValue, nil
		},
	},
}

var Bytes = []sim.NativeFunction{
	{
		Name:      "bytes.newReader",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToBytes()

			s := bytes.NewReader(r)

			reader := NewReader(s)

			return sim.NewObject(reader), nil
		},
	},
	{
		Name:      "bytes.replace",
		Arguments: 4,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes, sim.Bytes, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := bytes.Replace(args[0].ToBytes(), args[1].ToBytes(), args[2].ToBytes(), int(args[3].ToInt()))
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "bytes.replaceAll",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := bytes.ReplaceAll(args[0].ToBytes(), args[1].ToBytes(), args[2].ToBytes())
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "Bytes.prototype.copyAt",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if args[0].Type != sim.Int {
				return sim.NullValue, fmt.Errorf("expected arg 1 to be int, got %s", args[0].TypeName())
			}

			switch args[1].Type {
			case sim.Bytes, sim.Array, sim.String:
			default:
				return sim.NullValue, fmt.Errorf("expected arg 2 to be bytes, got %s", args[1].TypeName())
			}

			a := this.ToBytes()
			start := int(args[0].ToInt())
			b := args[1].ToBytes()

			lenB := len(b)

			if lenB+start > len(a) {
				return sim.NullValue, fmt.Errorf("the array has not enough capacity")
			}

			for i := 0; i < lenB; i++ {
				a[i+start] = b[i]
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "Bytes.prototype.append",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if this.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected byte array, got %s", this.TypeName())
			}
			a := this.ToBytes()

			b := args[0]
			if b.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected array, got %s", b.TypeName())
			}

			c := append(a, b.ToBytes()...)

			return sim.NewBytes(c), nil
		},
	},
	{
		Name:      "Bytes.prototype.indexOf",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if this.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected byte array, got %s", this.TypeName())
			}
			a := this.ToBytes()
			v := byte(args[0].ToInt())

			for i, j := range a {
				if j == v {
					return sim.NewInt(i), nil
				}
			}

			return sim.NewInt(-1), nil
		},
	},
	{
		Name: "Bytes.prototype.reverse",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if this.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected byte array, got %s", this.TypeName())
			}
			a := this.ToBytes()
			l := len(a) - 1

			for i, k := 0, l/2; i <= k; i++ {
				a[i], a[l-i] = a[l-i], a[i]
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "Bytes.prototype.slice",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if this.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected string array, got %s", this.TypeName())
			}
			a := this.ToBytes()
			l := len(a)

			switch len(args) {
			case 0:
				a = a[0:]
			case 1:
				a = a[int(args[0].ToInt()):]
			case 2:
				start := int(args[0].ToInt())
				if start < 0 || start > l {
					return sim.NullValue, fmt.Errorf("index out of range")
				}

				end := start + int(args[1].ToInt())
				if end < 0 || end > l {
					return sim.NullValue, fmt.Errorf("index out of range")
				}

				a = a[start:end]
			default:
				return sim.NullValue, fmt.Errorf("expected 0, 1 or 2 params, got %d", len(args))
			}

			return sim.NewBytes(a), nil
		},
	},
	{
		Name:      "Bytes.prototype.range",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if this.Type != sim.Bytes {
				return sim.NullValue, fmt.Errorf("expected array, called on %s", this.TypeName())
			}
			a := this.ToBytes()
			l := len(a)

			switch len(args) {
			case 0:
				a = a[0:]
			case 1:
				a = a[int(args[0].ToInt()):]
			case 2:
				start := int(args[0].ToInt())
				if start < 0 || start > l {
					return sim.NullValue, fmt.Errorf("index out of range")
				}

				end := int(args[1].ToInt())
				if end < 0 || end > l {
					return sim.NullValue, fmt.Errorf("index out of range")
				}

				a = a[start:end]
			default:
				return sim.NullValue, fmt.Errorf("expected 0, 1 or 2 params, got %d", len(args))
			}

			return sim.NewBytes(a), nil
		},
	},
}

var CSV = []sim.NativeFunction{
	{
		Name:      "csv.newReader",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r, ok := args[0].ToObject().(io.Reader)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}

			reader := csv.NewReader(r)

			return sim.NewObject(&csvReader{reader}), nil
		},
	},
	{
		Name:      "csv.newWriter",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			w, ok := args[0].ToObject().(io.Writer)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}

			writer := csv.NewWriter(w)

			return sim.NewObject(&csvWriter{writer}), nil
		},
	},
}

var Caching = []sim.NativeFunction{
	{
		Name:      "caching.newCache",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			l := len(args)

			var d time.Duration

			switch l {
			case 0:
				d = 1 * time.Minute
			case 1:
				var a = args[0]
				switch a.Type {
				case sim.Int:
					dd, err := ToDuration(a)
					if err != nil {
						return sim.NullValue, err
					}
					d = dd
				case sim.Object:
					dur, ok := a.ToObject().(Duration)
					if !ok {
						return sim.NullValue, fmt.Errorf("expected duration, got %s", a.TypeName())
					}
					d = time.Duration(dur)
				}
			default:
				return sim.NullValue, fmt.Errorf("expected 0 or 1 arguments, got %d", l)
			}
			return sim.NewObject(newCacheObj(d)), nil
		},
	},
}

var Console = []sim.NativeFunction{
	{
		Name:      "console.debug",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return consoleLog(true, args, vm)
		},
	},
	{
		Name:      "console.enableDebug",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			debugEnabled = true
			return sim.NullValue, nil
		},
	},
	{
		Name:      "console.disableDebug",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			debugEnabled = false
			return sim.NullValue, nil
		},
	},
	{
		Name:      "console.log",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return consoleLog(false, args, vm)
		},
	},
	{
		Name:      "console.enableTrace",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			traceEnabled = true
			return sim.NullValue, nil
		},
	},
	{
		Name:      "console.disableTrace",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			traceEnabled = false
			return sim.NullValue, nil
		},
	},
}

var Convert = []sim.NativeFunction{
	{
		Name:      "parseInt",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 0, 1, 2); err != nil {
				return sim.NullValue, err
			}

			if len(args) == 0 {
				return sim.NewFloat(math.NaN()), nil
			}

			var a sim.Value
			var radix int

			switch len(args) {
			case 0:
				return sim.NewFloat(math.NaN()), nil

			case 1:
				a = args[0]
				radix = 10
			case 2:
				a = args[0]
				radix = int(args[1].ToInt())
			}

			if radix == 0 {
				radix = 10
			}
			if radix < 2 || radix > 36 {
				return sim.NewFloat(math.NaN()), nil
			}

			var str string
			switch a.Type {
			case sim.String:
				str = a.String()
			case sim.Int, sim.Float, sim.Rune:
				str = a.String()
			default:
				return sim.NewFloat(math.NaN()), nil
			}

			str = strings.TrimLeft(str, " \t\n\r\v\f")

			if str == "" {
				return sim.NewFloat(math.NaN()), nil
			}

			if radix == 10 && len(str) > 2 && strings.ToLower(str[:2]) == "0x" {
				radix = 16
				str = str[2:]
			}

			sign := 1
			switch str[0] {
			case '-':
				sign = -1
				str = str[1:]
			case '+':
				str = str[1:]
			}

			if str == "" {
				return sim.NewFloat(math.NaN()), nil
			}

			result := int64(0)
			parsedAnyDigit := false
			for _, char := range str {
				digit := -1

				if char >= '0' && char <= '9' {
					digit = int(char - '0')
				} else if char >= 'a' && char <= 'z' {
					digit = int(char - 'a' + 10)
				} else if char >= 'A' && char <= 'Z' {
					digit = int(char - 'A' + 10)
				}

				if digit == -1 || digit >= radix {
					break
				}

				parsedAnyDigit = true
				result = result*int64(radix) + int64(digit)
			}

			if !parsedAnyDigit {
				return sim.NewFloat(math.NaN()), nil
			}

			return sim.NewInt64(int64(sign) * result), nil
		},
	},
	{
		Name:      "parseFloat",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 1); err != nil {
				return sim.NullValue, err
			}

			a := args[0]
			var str string
			switch a.Type {
			case sim.String:
				str = a.String()
			case sim.Int, sim.Float, sim.Rune:
				str = a.String()
			default:
				return sim.NewFloat(math.NaN()), nil
			}

			str = strings.TrimLeft(str, " \t\n\r\v\f")

			if str == "" {
				return sim.NewFloat(math.NaN()), nil
			}

			if str == "Infinity" || str == "+Infinity" {
				return sim.NewFloat(math.Inf(1)), nil
			}
			if str == "-Infinity" {
				return sim.NewFloat(math.Inf(-1)), nil
			}
			if str == "NaN" {
				return sim.NewFloat(math.NaN()), nil
			}

			sign := 1.0
			if len(str) > 0 {
				switch str[0] {
				case '-':
					sign = -1
					str = str[1:]
				case '+':
					str = str[1:]
				}
			}

			if str == "" {
				return sim.NewFloat(math.NaN()), nil
			}

			hasDecimal := false
			hasExponent := false
			result := 0.0
			decimalPlaces := 0.0
			exponentPart := ""
			inExponent := false
			parsedAnyDigit := false

			for i, char := range str {
				if (char == 'e' || char == 'E') && !hasExponent && i > 0 && parsedAnyDigit {
					hasExponent = true
					inExponent = true
					continue
				}

				if inExponent {
					if char == '+' || char == '-' || (char >= '0' && char <= '9') {
						exponentPart += string(char)
						continue
					} else {
						break
					}
				}

				if char == '.' && !hasDecimal && !inExponent {
					hasDecimal = true
					continue
				}

				if char >= '0' && char <= '9' {
					parsedAnyDigit = true
					if hasDecimal {
						decimalPlaces++
						result = result + float64(char-'0')/math.Pow(10, decimalPlaces)
					} else {
						result = result*10 + float64(char-'0')
					}
				} else {

					if i == 0 {
						return sim.NewFloat(math.NaN()), nil
					}
					break
				}
			}

			if !parsedAnyDigit {
				return sim.NewFloat(math.NaN()), nil
			}

			if hasExponent && exponentPart != "" {
				if exp, err := strconv.ParseInt(exponentPart, 10, 64); err == nil {
					result *= math.Pow(10, float64(exp))
				}
			}

			return sim.NewFloat(sign * result), nil
		},
	},
	{
		Name:      "convert.toByte",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			var r sim.Value

			switch a.Type {
			case sim.String:
			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to byte", a.Type)
			}

			s := a.String()
			if len(s) != 1 {
				return sim.NullValue, fmt.Errorf("can't convert %v to int", a.Type)
			}

			return r, nil
		},
	},
	{
		Name:      "convert.toRune",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]

			switch a.Type {
			case sim.String:
				s := a.String()
				if len(s) != 1 {
					return sim.NullValue, fmt.Errorf("can't convert %v to rune", s)
				}
				return sim.NewRune(rune(s[0])), nil
			case sim.Int:
				i := a.ToInt()
				if i > 255 {
					return sim.NullValue, fmt.Errorf("can't convert %v to rune", i)
				}
				return sim.NewRune(rune(i)), nil
			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to byte", a.Type)
			}
		},
	},
	{
		Name:      "convert.toInt",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			var r sim.Value

			switch a.Type {
			case sim.Int:
				r = a
			case sim.Float:
				r = sim.NewInt64(a.ToInt())
			case sim.Rune:
				r = sim.NewInt64(a.ToInt())
			case sim.String:
				s := a.String()
				s = strings.Trim(s, " ")
				if len(s) > 1 {
					s = strings.TrimLeft(s, "0")
				}
				i, err := strconv.ParseInt(s, 0, 64)
				if err != nil {
					return sim.NullValue, err
				}
				r = sim.NewInt64(i)
			case sim.Func:
				r = sim.NewInt64(a.ToInt())
			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to int", a.Type)
			}

			return r, nil
		},
	},
	{
		Name:      "convert.toFloat",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Int:
				return sim.NewFloat(a.ToFloat()), nil
			case sim.Float:
				return a, nil
			case sim.String:
				s := a.String()
				s = strings.Trim(s, " ")
				if len(s) > 1 {
					s = strings.TrimLeft(s, "0")
				}
				f, err := strconv.ParseFloat(s, 64)
				if err != nil {
					return sim.NullValue, err
				}
				return sim.NewFloat(f), nil
			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to int", a.Type)
			}
		},
	},
	{
		Name:      "convert.toBool",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]

			switch a.Type {
			case sim.Bool:
				return a, nil

			case sim.Int:
				switch a.ToInt() {
				case 0:
					return sim.FalseValue, nil
				case 1:
					return sim.TrueValue, nil
				default:
					return sim.NullValue, fmt.Errorf("can't convert %v to bool", a.Type)
				}

			case sim.String:
				s := a.String()
				s = strings.Trim(s, " ")
				switch s {
				case "true", "1":
					return sim.TrueValue, nil
				case "false", "0":
					return sim.FalseValue, nil
				default:
					return sim.NullValue, fmt.Errorf("can't convert %v to bool", s)
				}

			case sim.Null, sim.Undefined:
				return sim.FalseValue, nil

			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to bool", a.Type)

			}
		},
	},
	{
		Name:      "convert.toString",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			return sim.NewString(a.String()), nil
		},
	},
	{
		Name:      "convert.toBytes",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			var r sim.Value

			switch a.Type {
			case sim.String:
				r = sim.NewBytes(a.ToBytes())
			case sim.Bytes:
				r = a
			default:
				return sim.NullValue, fmt.Errorf("can't convert %v to int", a.Type)
			}

			return r, nil
		},
	},
	{
		Name:      "convert.toSafeString",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]

			switch a.Type {
			case sim.Bytes:
				encoder := base64.RawStdEncoding
				encoded := encoder.EncodeToString(a.ToBytes())
				return sim.NewString(encoded), nil

			case sim.Null, sim.Undefined:
				return sim.NewString(""), nil

			default:
				return sim.NewString(a.String()), nil
			}
		},
	},
}

var Crypt = []sim.NativeFunction{
	{
		Name:      "crypto.signSHA1_RSA_PCKS1",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].ToBytes()
			text := args[1].String()

			h := sha1.New()
			h.Write([]byte(text))
			sum := h.Sum(nil)

			block, _ := pem.Decode(key)
			if block == nil {
				return sim.NullValue, fmt.Errorf("error parsing private key")
			}

			privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
			if err != nil {
				return sim.NullValue, fmt.Errorf("error parsing private key: %w", err)
			}

			sig, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, sum)
			if err != nil {
				return sim.NullValue, fmt.Errorf("error signing: %w", err)
			}

			return sim.NewBytes(sig), nil
		},
	},
	{
		Name:      "crypto.signSHA1",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String()
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.checkSignSHA1",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String()
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))
			ok := hash == args[1].String()

			return sim.NewBool(ok), nil
		},
	},
	{
		Name:      "crypto.signSHA1Salted",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String() + getGlobalPassword()
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.checkSignSHA1Salted",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String() + getGlobalPassword()
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))
			ok := hash == args[1].String()

			return sim.NewBool(ok), nil
		},
	},
	{
		Name:        "crypto.signTempSHA1",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {

			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String() + tempSignKey
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.checkTempSignSHA1",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := args[0].String() + tempSignKey
			h := sha1.New()
			h.Write([]byte(s))
			hash := hex.EncodeToString(h.Sum(nil))

			ok := hash == args[1].String()
			return sim.NewBool(ok), nil
		},
	},
	{
		Name:        "crypto.setGlobalPassword",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {

			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			setGlobalPassword(args[0].String())
			return sim.NullValue, nil
		},
	},
	{
		Name:      "crypto.hmacSHA256",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			msg := args[0].ToBytes()
			key := args[1].ToBytes()

			sig := hmac.New(sha256.New, key)
			sig.Write(msg)
			hash := sig.Sum(nil)

			return sim.NewBytes(hash), nil
		},
	},
	{
		Name:      "crypto.hmacSHA512",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			msg := args[0].ToBytes()
			key := args[1].ToBytes()

			sig := hmac.New(sha512.New, key)
			sig.Write(msg)
			hash := sig.Sum(nil)

			return sim.NewBytes(hash), nil
		},
	},
	{
		Name:      "crypto.hashSHA",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			h := sha1.New()
			h.Write([]byte(args[0].String()))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.hashSHA256",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			h := sha256.New()
			h.Write([]byte(args[0].String()))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.hashSHA512",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			h := sha512.New()
			h.Write([]byte(args[0].String()))
			hash := hex.EncodeToString(h.Sum(nil))
			return sim.NewString(hash), nil
		},
	},
	{
		Name:      "crypto.encryptString",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			var pwd string
			switch len(args) {
			case 0:
				return sim.NullValue, fmt.Errorf("expected 1 argument, got 0")
			case 1:
				pwd = getGlobalPassword()
				if pwd == "" {
					return sim.NullValue, fmt.Errorf("no password configured")
				}
			case 2:
				pwd = args[1].String()
			}

			s, err := Encrypts(args[0].String(), pwd)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewString(s), nil
		},
	},
	{
		Name:      "crypto.decryptString",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			var pwd string
			switch len(args) {
			case 0:
				return sim.NullValue, fmt.Errorf("expected 1 argument, got 0")
			case 1:
				pwd = getGlobalPassword()
				if pwd == "" {
					return sim.NullValue, fmt.Errorf("no password configured")
				}
			case 2:
				pwd = args[1].String()
			}

			s, err := Decrypts(args[0].String(), pwd)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewString(s), nil
		},
	},
	{
		Name:      "crypto.encrypt",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			var pwd string
			switch len(args) {
			case 0:
				return sim.NullValue, fmt.Errorf("expected 1 argument, got 0")
			case 1:
				pwd = getGlobalPassword()
				if pwd == "" {
					return sim.NullValue, fmt.Errorf("no password configured")
				}

			case 2:
				pwd = args[1].String()
			}

			b, err := Encrypt(args[0].ToBytes(), []byte(pwd))
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "crypto.decrypt",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			var pwd string
			switch len(args) {
			case 0:
				return sim.NullValue, fmt.Errorf("expected 1 argument, got 0")
			case 1:
				pwd = getGlobalPassword()
				if pwd == "" {
					return sim.NullValue, fmt.Errorf("no password configured")
				}

			case 2:
				pwd = args[1].String()
			}

			b, err := Decrypt(args[0].ToBytes(), []byte(pwd))
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "crypto.encryptTripleDES",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes); err != nil {
				return sim.NullValue, err
			}
			b, err := EncryptTripleDESCBC(args[0].ToBytes(), args[1].ToBytes())
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "crypto.decryptTripleDES",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes, sim.Bytes); err != nil {
				return sim.NullValue, err
			}
			b, err := DecryptTripleDESCBC(args[0].ToBytes(), args[1].ToBytes())
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "crypto.hashPassword",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			s := HashPassword(args[0].String())
			return sim.NewString(s), nil
		},
	},
	{
		Name:      "crypto.compareHashAndPassword",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			ok := CheckHashPasword(args[0].String(), args[1].String())
			return sim.NewBool(ok), nil
		},
	},
	{
		Name:      "crypto.rand",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			ln := int(args[0].ToInt())
			v, err := rand.Int(rand.Reader, big.NewInt(int64(ln)))
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewInt64(v.Int64()), nil
		},
	},
	{
		Name:      "crypto.random",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			b := Random(int(args[0].ToInt()))
			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "crypto.randomAlphanumeric",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			ln := int(args[0].ToInt())
			if ln < 1 {
				return sim.NullValue, fmt.Errorf("invalid len: %d", ln)
			}
			s := RandomAlphanumeric(ln)
			return sim.NewString(s), nil
		},
	},
}

var Encoding = []sim.NativeFunction{
	{
		Name:      "encoding.newDecoderCP850",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.CodePage850.NewDecoder()
			return sim.NewObject(&decoder{d}), nil
		},
	},
	{
		Name:      "encoding.newEncoderCP850",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.CodePage850.NewEncoder()
			return sim.NewObject(&encoder{d}), nil
		},
	},
	{
		Name:      "encoding.newDecoderISO8859_1",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.ISO8859_1.NewDecoder()
			return sim.NewObject(&decoder{d}), nil
		},
	},
	{
		Name:      "encoding.newEncoderISO8859_1",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.ISO8859_1.NewEncoder()
			return sim.NewObject(&encoder{d}), nil
		},
	},
	{
		Name:      "encoding.newDecoderWindows1252",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.Windows1252.NewDecoder()
			return sim.NewObject(&decoder{d}), nil
		},
	},
	{
		Name:      "encoding.newEncoderWindows1252",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := charmap.Windows1252.NewEncoder()
			return sim.NewObject(&encoder{d}), nil
		},
	},
	{
		Name:      "encoding.newDecoderUTF16_LE",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewDecoder()
			return sim.NewObject(&decoder{d}), nil
		},
	},
	{
		Name:      "encoding.newEncoderUTF16_LE",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			e := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder()
			return sim.NewObject(&encoder{e}), nil
		},
	},
}

var ErrFileNotFound = errors.New("file not found")

var ErrInvalidType = errors.New("invalid value type")

var ErrNoFileSystem = errors.New("there is no filesystem")

var ErrReadOnly = errors.New("readonly property")

var ErrReadOnlyOrUndefined = errors.New("undefined or readonly property")

var ErrUnauthorized = errors.New("unauthorized")

var ErrUndefined = errors.New("undefined")

var Errors = []sim.NativeFunction{
	{
		Name:      "errors.action",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Map); err != nil {
				return sim.NullValue, err
			}

			var statusError int
			code, ok := args[0].ToMap().Map[sim.NewString("code")]
			if ok {
				if code.Type != sim.Int {
					return sim.NullValue, fmt.Errorf("expected code to be int, got %s", code.TypeName())
				}
				statusError = int(code.ToInt())
			} else {
				statusError = http.StatusBadRequest
			}

			wrap := make(map[sim.Value]sim.Value)
			wrap[sim.NewString("actionError")] = args[0]

			obj := sim.NewMapValues(wrap, false).ExportMarshal(0)

			buf := &bytes.Buffer{}

			encoder := json.NewEncoder(buf)

			if err := encoder.Encode(obj); err != nil {
				return sim.NullValue, err
			}

			buf.Truncate(buf.Len() - 1)

			err := sim.NewCodeError(statusError, buf.String())

			err.Kind = "ActionError"

			return sim.NewObject(err), nil
		},
	},
	{
		Name:      "errors.is",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object, sim.String); err != nil {
				return sim.NullValue, err
			}
			e, ok := args[0].ToObjectOrNil().(*sim.VMError)
			if !ok {
				return sim.FalseValue, nil
			}
			return sim.NewBool(e.Is(args[1].String())), nil
		},
	},
	{
		Name:      "errors.wrap",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			msg := args[0].String()

			e, ok := args[1].ToObjectOrNil().(error)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected arg 2 to be an error. Got %s", args[1].TypeName())
			}

			err := sim.Wrap(0, msg, e)

			return sim.NewObject(err), nil
		},
	},
	{
		Name:      "errors.wrapCode",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			code := args[0].ToInt()

			msg := args[1].String()

			e, ok := args[2].ToObjectOrNil().(error)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected arg 2 to be an error. Got %s", args[2].TypeName())
			}

			err := sim.Wrap(int(code), msg, e)

			return sim.NewObject(err), nil
		},
	},
	{
		Name:      "errors.unwrap",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			e, ok := args[0].ToObjectOrNil().(*sim.VMError)
			if !ok {
				return sim.FalseValue, nil
			}

			e = e.Wrapped

			if e == nil {
				return sim.NullValue, nil
			}

			return sim.NewObject(e), nil
		},
	},
	{
		Name:      "errors.rethrow",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			ln := len(args)

			if ln == 0 {
				return sim.NullValue, fmt.Errorf("expected at least one argument, got 0")
			}

			e, ok := args[0].ToObjectOrNil().(*sim.VMError)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected error, got %s", args[0].String())
			}

			if ln > 1 {
				a := args[1]
				if a.Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected parameter 1 to be a string, got %s", a.Type)
				}
				details := a.String()
				if ln > 2 {
					values := make([]interface{}, ln-2)
					for i, a := range args[2:] {
						v := a.Export(0)
						if t, ok := v.(*sim.VMError); ok {

							v = t.ErrorMessage()
						}
						values[i] = v
					}
					details = fmt.Sprintf(details, values...)
				}

				if e.Details == "" {
					e.Details = details
				} else {
					e.Details += "\n" + details
				}
			}

			e.IsRethrow = true

			return sim.NullValue, e
		},
	},
	{
		Name:      "errors.newError",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			argsLen := len(args)
			if argsLen < 1 {
				return sim.NullValue, fmt.Errorf("expected at least 1 parameter, got %d", len(args))
			}

			m := args[0]
			if m.Type != sim.String {
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be a string, got %s", m.Type)
			}

			return newCodeError(0, m.String(), args[1:], vm)
		},
	},
	{
		Name:      "errors.newCode",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			argsLen := len(args)
			if argsLen < 1 {
				return sim.NullValue, fmt.Errorf("expected at least 1 parameter, got %d", len(args))
			}

			code := args[0]
			if code.Type != sim.Int {
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be a int, got %s", code.Type)
			}

			var msg string
			var fmtArgs []sim.Value

			if argsLen > 1 {
				m := args[1]
				if m.Type != sim.String {
					return sim.NullValue, fmt.Errorf("expected parameter 2 to be a string, got %s", m.Type)
				}
				msg = m.ToString()
				fmtArgs = args[2:]
			} else {
				msg = fmt.Sprintf("Error %d", code.ToInt())
				fmtArgs = args[1:]
			}

			return codeErrorf(int(code.ToInt()), msg, fmtArgs, vm)
		},
	},
	{
		Name:      "errors.notFound",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return newHTTPCodeError(404, args, vm)
		},
	},
	{
		Name:      "errors.badRequest",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return newHTTPCodeError(400, args, vm)
		},
	},
	{
		Name:      "errors.unauthorized",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return newHTTPCodeError(401, args, vm)
		},
	},
	{
		Name:      "errors.internalError",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return newHTTPCodeError(500, args, vm)
		},
	},
}

var FSNotify = []sim.NativeFunction{
	{
		Name:        "fsnotify.newWatcher",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			v := args[0]
			switch v.Type {
			case sim.Func:
			case sim.Object:
			default:
				return sim.NullValue, fmt.Errorf("%v is not a function", v.TypeName())
			}

			w, err := newFileWatcher(v, vm)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(w), nil
		},
	},
}

var FilePath = []sim.NativeFunction{
	{
		Name:      "filepath.clean",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			s := args[0].String()
			if s == "" {
				return args[0], nil
			}

			if s[0] != '/' {
				return sim.NullValue, fmt.Errorf("relative paths are not allowed")
			}

			v := filepath.Clean(s)
			return sim.NewString(v), nil
		},
	},
	{
		Name:      "filepath.join",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var parts []string

			for i, v := range args {
				if v.IsNilOrEmpty() {
					continue
				}
				if v.Type != sim.String {
					return sim.NullValue, fmt.Errorf("argument %d is not a string (%s)", i+1, v.TypeName())
				}
				parts = append(parts, v.String())
			}

			path := filepath.Join(parts...)
			return sim.NewString(path), nil
		},
	},
	{
		Name:      "filepath.joinAbs",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var parts []string

			for i, v := range args {
				if v.IsNilOrEmpty() {
					continue
				}
				if v.Type != sim.String {
					return sim.NullValue, fmt.Errorf("argument %d is not a string (%s)", i, v.TypeName())
				}
				s := v.String()
				if strings.HasPrefix(s, "/") {
					parts = nil
				}

				parts = append(parts, s)
			}

			path := filepath.Join(parts...)
			return sim.NewString(path), nil
		},
	},
	{
		Name:      "filepath.abs",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}

			path, err := fs.Abs(args[0].String())
			if err != nil {
				return sim.NullValue, fmt.Errorf("abs %s: %w", args[0].String(), err)
			}

			return sim.NewString(path), nil
		},
	},
	{
		Name:      "filepath.ext",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()
			ext := filepath.Ext(path)
			return sim.NewString(ext), nil
		},
	},
	{
		Name:      "filepath.base",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()
			name := filepath.Base(path)
			return sim.NewString(name), nil
		},
	},
	{
		Name:      "filepath.baseWithoutExt",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()
			name := filepath.Base(path)
			if i := strings.LastIndexByte(name, '.'); i != -1 {
				name = name[:i]
			}
			return sim.NewString(name), nil
		},
	},
	{
		Name:      "filepath.replaceExt",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()

			i := strings.LastIndexByte(path, '.')

			if i != -1 {
				path = path[:i] + args[1].String()
			} else {
				path += args[1].String()
			}

			return sim.NewString(path), nil
		},
	},
	{
		Name:      "filepath.dir",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			path := args[0].String()
			name := filepath.Dir(path)
			return sim.NewString(name), nil
		},
	},
}

var FileUtil = []sim.NativeFunction{
	{
		Name:      "fileutil.isDirEmpty",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}
			if err := ValidateArgRange(args, 1, 2); err != nil {
				return sim.NullValue, err
			}

			fs, ok := args[1].ToObject().(*FileSystemObj)
			if !ok {
				return sim.NullValue, fmt.Errorf("invalid filesystem argument, got %v", args[1])
			}

			name := args[0].String()

			f, err := fs.FS.Open(name)
			if err != nil {
				return sim.NullValue, err
			}
			defer f.Close()

			_, err = f.Readdir(1)
			if err != nil {
				if err == io.EOF {
					return sim.NewBool(true), nil
				}
				return sim.NullValue, err
			}

			return sim.NewBool(false), nil
		},
	},
	{
		Name:      "fileutil.copyFile",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}
			if err := ValidateArgRange(args, 2, 3); err != nil {
				return sim.NullValue, err
			}

			src := args[0].String()
			dst := args[1].String()

			var fs filesystem.FS

			if len(args) == 3 {
				ofs, ok := args[2].ToObjectOrNil().(*FileSystemObj)
				if !ok {
					return sim.NullValue, fmt.Errorf("invalid filesystem argument, got %v", args[2])
				}
				fs = ofs.FS
			}

			if fs == nil {
				fs = vm.FileSystem
				if fs == nil {
					return sim.NullValue, fmt.Errorf("no filesystem")
				}
			}

			r, err := fs.Open(src)
			if err != nil {
				return sim.NullValue, err
			}

			defer r.Close()

			w, err := fs.OpenForWrite(dst)
			if err != nil {
				return sim.NullValue, err
			}

			defer w.Close()

			if _, err := io.Copy(w, r); err != nil {
				return sim.NullValue, err
			}

			return sim.NullValue, nil
		},
	},
}

var GZIP = []sim.NativeFunction{
	{
		Name:      "gzip.newWriter",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			w, ok := args[0].ToObjectOrNil().(io.Writer)
			if !ok {
				return sim.NullValue, fmt.Errorf("exepected a Writer, got %s", args[0].TypeName())
			}

			g := gzip.NewWriter(w)
			v := &gzipWriter{g}
			return sim.NewObject(v), nil
		},
	},
	{
		Name:      "gzip.newReader",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			r, ok := args[0].ToObjectOrNil().(io.Reader)
			if !ok {
				return sim.NullValue, fmt.Errorf("exepected a reader, got %s", args[0].TypeName())
			}

			gr, err := gzip.NewReader(r)
			if err != nil {
				return sim.NullValue, err
			}
			v := &gzipReader{gr}
			return sim.NewObject(v), nil
		},
	},
}

var HASH = []sim.NativeFunction{
	{
		Name: "hash.newMD5",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			hash := md5.New()
			return sim.NewObject(hasher{hash}), nil
		},
	},
	{
		Name: "hash.newSHA256",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			hash := sha256.New()
			return sim.NewObject(hasher{hash}), nil
		},
	},
}

var HEX = []sim.NativeFunction{
	{
		Name:      "hex.encodeToString",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			b := args[0].ToBytes()
			s := hex.EncodeToString(b)
			return sim.NewString(s), nil
		},
	},
}

var HTML = []sim.NativeFunction{
	{
		Name:      "html.encode",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.Bytes:
				encoder := base64.RawStdEncoding
				encoded := encoder.EncodeToString(a.ToBytes())
				return sim.NewString(encoded), nil
			case sim.String:
				return sim.NewString(html.EscapeString(a.String())), nil
			default:
				return sim.NewString(a.String()), nil
			}
		},
	},
	{
		Name:      "html.decode",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NullValue, nil
			case sim.String:
				return sim.NewString(html.UnescapeString(a.String())), nil
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %v", a.Type)
			}
		},
	},
}

var HTTP = []sim.NativeFunction{
	{
		Name: "->http.OK",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(200), nil
		},
	},
	{
		Name: "->http.REDIRECT",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(302), nil
		},
	},
	{
		Name: "->http.PERMANENT_REDIRECT",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(301), nil
		},
	},
	{
		Name: "->http.REDIRECT",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(302), nil
		},
	},
	{
		Name: "->http.BAD_REQUEST",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(400), nil
		},
	},
	{
		Name: "->http.UNAUTHORIZED",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(401), nil
		},
	},
	{
		Name: "->http.NOT_FOUND",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(404), nil
		},
	},
	{
		Name: "->http.TIMEOUT",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(408), nil
		},
	},
	{
		Name: "->http.INTERNAL_ERROR",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(500), nil
		},
	},
	{
		Name: "->http.UNAVAILABLE",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(503), nil
		},
	},
	{
		Name: "->http.FORM_ERROR",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(http.StatusBadRequest), nil
		},
	},
	{
		Name: "->http.SameSiteDefaultMode",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(int(http.SameSiteDefaultMode)), nil
		},
	},
	{
		Name: "->http.SameSiteDefaultMode",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(int(http.SameSiteDefaultMode)), nil
		},
	},

	{
		Name: "->http.SameSiteLaxMode",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(int(http.SameSiteLaxMode)), nil
		},
	},
	{
		Name: "->http.SameSiteStrictMode",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(int(http.SameSiteStrictMode)), nil
		},
	},
	{
		Name: "->http.SameSiteNoneMode",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewInt(int(http.SameSiteNoneMode)), nil
		},
	},
	{
		Name:      "http.cacheBreaker",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			cacheMut.RLock()
			v := sim.NewString(cacheBreaker)
			cacheMut.RUnlock()
			return v, nil
		},
	},
	{
		Name:        "http.resetCacheBreaker",
		Arguments:   0,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			cacheMut.Lock()
			cacheBreaker = RandString(9)
			lastModifiedDate = time.Now()
			cacheMut.Unlock()
			return sim.NullValue, nil
		},
	},
	{
		Name:        "http.newServer",
		Arguments:   0,
		Permissions: []string{"netListen"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			s := &server{
				vm:                vm,
				handler:           -1,
				readTimeout:       10 * time.Second,
				writeTimeout:      10 * time.Second,
				readHeaderTimeout: 10 * time.Second,
				idleTimeout:       100 * time.Second,
			}

			return sim.NewObject(s), nil
		},
	},
	{
		Name:      "http.newResponseRecorder",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r, ok := args[0].ToObjectOrNil().(*request)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a request, got %v", args[0].TypeName())
			}

			w := &responseWriter{
				writer:  httptest.NewRecorder(),
				request: r.request,
			}

			return sim.NewObject(w), nil
		},
	},
	{
		Name:      "http.newCookie",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			c := &cookie{}
			return sim.NewObject(c), nil
		},
	},
	{
		Name:      "http.encodeURIComponent",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			v := args[0].String()
			u := url.QueryEscape(v)
			return sim.NewString(u), nil
		},
	},
	{
		Name:      "http.decodeURIComponent",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			v := args[0].String()
			u, err := url.QueryUnescape(v)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewString(u), nil
		},
	},
	{
		Name:      "http.newClient",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			c := &client{client: &http.Client{}}
			return sim.NewObject(c), nil
		},
	},
	{
		Name:        "http.newRequest",
		Arguments:   -1,
		Permissions: []string{"networking"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 2, 3); err != nil {
				return sim.NullValue, err
			}

			if !isStringLike(args[0]) {
				return sim.NullValue, fmt.Errorf("expected argument 1 to be string, got %v", args[0].Type)
			}

			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected argument 2 to be string, got %v", args[1].Type)
			}

			var method string
			var urlStr string
			var queryMap map[sim.Value]sim.Value
			var reader io.Reader
			var contentType string

			switch len(args) {
			case 2:
				method = args[0].String()
				urlStr = args[1].String()
			case 3:
				method = args[0].String()
				urlStr = args[1].String()
				form := url.Values{}

				v := args[2]

				switch v.Type {
				case sim.Null, sim.Undefined:
				case sim.String:
					switch method {
					case "POST", "PUT", "PATCH":
					default:
						return sim.NullValue, fmt.Errorf("can only pass a data string with POST, PUT or PATCH")
					}
					reader = strings.NewReader(v.String())
					contentType = "application/json; charset=UTF-8"
				case sim.Map:
					m := v.ToMap()
					if method == "GET" {
						queryMap = m.Map
					} else {
						m.RLock()
						for k, v := range m.Map {
							if v.IsNilOrEmpty() {
								continue
							}
							vs, err := serialize(v)
							if err != nil {
								return sim.NullValue, fmt.Errorf("error serializing parameter: %v", v.Type)
							}
							form.Add(k.String(), vs)
						}
						m.RUnlock()
						reader = strings.NewReader(form.Encode())
						contentType = "application/x-www-form-urlencoded"
					}
				case sim.Object:
					r, ok := v.ToObject().(io.Reader)
					if !ok {
						return sim.NullValue, fmt.Errorf("invalid argument 3 type: got %v", v.TypeName())
					}
					reader = r
				default:
					return sim.NullValue, fmt.Errorf("expected argument 3 to be object, got %v", v.Type)
				}
			}

			r, err := http.NewRequest(method, urlStr, reader)
			if err != nil {
				return sim.NullValue, err
			}

			switch method {
			case "GET":
				if queryMap != nil {
					q := r.URL.Query()
					for k, v := range queryMap {
						if v.IsNilOrEmpty() {
							continue
						}
						vs, err := serialize(v)
						if err != nil {
							return sim.NullValue, fmt.Errorf("error serializing parameter: %v", v.Type)
						}
						q.Add(k.String(), vs)
					}
					r.URL.RawQuery = q.Encode()
				}
			}

			return sim.NewObject(&request{request: r, defaultContentType: contentType}), nil
		},
	},
	{
		Name:        "http.get",
		Arguments:   -1,
		Permissions: []string{"networking"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			client := &http.Client{}
			timeout := 20 * time.Second

			ln := len(args)

			if ln == 0 {
				return sim.NullValue, fmt.Errorf("expected 1 to 3 arguments, got %d", len(args))
			}

			a := args[0]
			if a.Type != sim.String {
				return sim.NullValue, fmt.Errorf("expected argument 0 to be string, got %s", a.TypeName())
			}
			url := a.String()

			if ln == 0 {
			} else if ln > 1 {
				a := args[1]
				switch a.Type {
				case sim.Undefined, sim.Null:
				case sim.Int, sim.Object:
					var err error
					timeout, err = ToDuration(args[1])
					if err != nil {
						return sim.NullValue, err
					}
				default:
					return sim.NullValue, fmt.Errorf("expected argument 1 to be duration")
				}
			}

			if ln > 2 {
				b := args[2]
				switch b.Type {
				case sim.Null, sim.Undefined:
				case sim.Object:
					t, ok := args[2].ToObjectOrNil().(*tlsConfig)
					if !ok {
						return sim.NullValue, fmt.Errorf("expected argument 2 to be tls.Config")
					}
					client.Transport = getTransport(t.conf)
				default:
					return sim.NullValue, fmt.Errorf("expected argument 2 to be string, got %s", b.TypeName())
				}
			}

			client.Timeout = timeout
			resp, err := client.Get(url)
			if err != nil {
				return sim.NullValue, err
			}

			b, err := io.ReadAll(resp.Body)

			err2 := resp.Body.Close()

			if err != nil {
				return sim.NullValue, err
			}

			if err2 != nil {
				return sim.NullValue, err2
			}

			if !isHTTPSuccess(resp.StatusCode) {
				return sim.NullValue, fmt.Errorf("http Error %d: %v", resp.StatusCode, string(b))
			}

			return sim.NewString(string(b)), nil
		},
	},
	{
		Name:        "http.post",
		Arguments:   -1,
		Permissions: []string{"networking"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 1, 2, 3, 4); err != nil {
				return sim.NullValue, err
			}

			if !isStringLike(args[0]) {
				return sim.NullValue, fmt.Errorf("expected argument 0 to be string, got %s", args[0].TypeName())
			}

			u := args[0].String()

			data := url.Values{}

			ln := len(args)

			if ln > 1 {
				a := args[1]
				switch a.Type {
				case sim.Undefined, sim.Null:
				case sim.Map:
					m := args[1].ToMap()
					m.RLock()
					for k, v := range m.Map {
						data.Add(k.String(), v.String())
					}
					m.RUnlock()
				default:
					return sim.NullValue, fmt.Errorf("expected argument 1 to be an object, got %s", args[1].TypeName())
				}
			}

			client := &http.Client{}
			timeout := 20 * time.Second

			if ln > 2 {
				a := args[2]
				switch a.Type {
				case sim.Undefined, sim.Null:
				case sim.Int, sim.Object:
					var err error
					timeout, err = ToDuration(args[2])
					if err != nil {
						return sim.NullValue, err
					}
				default:
					return sim.NullValue, fmt.Errorf("expected argument 1 to be duration")
				}
			}

			if ln > 3 {
				b := args[3]
				switch b.Type {
				case sim.Null, sim.Undefined:
				case sim.Object:
					t, ok := args[3].ToObjectOrNil().(*tlsConfig)
					if !ok {
						return sim.NullValue, fmt.Errorf("expected argument 2 to be tls.Config")
					}
					client.Transport = getTransport(t.conf)
				default:
					return sim.NullValue, fmt.Errorf("expected argument 2 to be string, got %s", b.TypeName())
				}
			}

			client.Timeout = timeout

			resp, err := client.PostForm(u, data)
			if err != nil {
				return sim.NullValue, err
			}

			b, err := io.ReadAll(resp.Body)
			resp.Body.Close()
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewString(string(b)), nil
		},
	},
	{
		Name:      "http.sendFile",
		Arguments: 6,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String, sim.String, sim.String, sim.String, sim.Bytes); err != nil {
				return sim.NullValue, err
			}

			url := args[0].String()
			user := args[1].String()
			password := args[2].String()
			param := args[3].String()
			name := args[4].String()
			data := args[5].ToBytes()

			body := &bytes.Buffer{}
			w := multipart.NewWriter(body)

			part, err := w.CreateFormFile(param, filepath.Base(name))
			if err != nil {
				return sim.NullValue, err
			}

			if _, err := part.Write(data); err != nil {
				return sim.NullValue, err
			}

			w.Close()

			r, err := http.NewRequest("POST", url, body)
			if err != nil {
				return sim.NullValue, err
			}

			r.SetBasicAuth(user, password)

			r.Header.Add("Content-Type", w.FormDataContentType())

			client := &http.Client{}
			res, err := client.Do(r)
			if err != nil {
				return sim.NullValue, err
			}

			defer res.Body.Close()

			resBuf, err := io.ReadAll(res.Body)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewBytes(resBuf), nil
		},
	},
	{
		Name:        "http.getJSON",
		Arguments:   1,
		Permissions: []string{"networking"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			url := args[0].String()

			resp, err := http.Get(url)
			if err != nil {
				return sim.NullValue, err
			}

			b, err := io.ReadAll(resp.Body)
			resp.Body.Close()
			if err != nil {
				return sim.NullValue, err
			}

			v, err := unmarshal(b)
			if err != nil {
				return sim.NullValue, err
			}

			return v, nil
		},
	},
	{
		Name:      "http.parseURL",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			if len(args) == 0 {
				u := &url.URL{}
				return sim.NewObject(&URL{url: u}), nil
			}

			rawURL := args[0].String()
			u, err := url.Parse(rawURL)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewObject(&URL{u}), nil
		},
	},

	{
		Name:      "http.escapeQuery",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			str := url.QueryEscape(args[0].String())
			return sim.NewString(str), nil
		},
	},
	{
		Name:      "http.unescapeQuery",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			str, err := url.QueryUnescape(args[0].String())
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewString(str), nil
		},
	},
}

var HTTPUTIL = []sim.NativeFunction{
	{
		Name:      "httputil.newSingleHostReverseProxy",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]
			u, ok := a.ToObjectOrNil().(*URL)
			if !ok {
				return sim.NullValue, fmt.Errorf("invalid argument 1: expected http.URL, got %v", a.TypeName())
			}

			p := &reverseProxy{
				proxy: httputil.NewSingleHostReverseProxy(u.url),
			}

			return sim.NewObject(p), nil
		},
	},
}

var I18N = []sim.NativeFunction{
	{
		Name:      "T",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]

			switch a.Type {
			case sim.Null, sim.Undefined:
				return sim.NewString(""), nil
			case sim.Int, sim.Float, sim.Bool:
				return sim.NewString(a.ToString()), nil
			case sim.String:
			default:
				return sim.NullValue, fmt.Errorf("expected string as fist argument, got %s", a.TypeName())
			}

			text := a.ToString()

			if text == "" {
				return a, nil
			}

			lang := vm.Language

			value := text
			if vm.Translations != nil {
				value = vm.Translations.Translate(lang, text)
			} else {

				cleanText := text
				if strings.HasPrefix(text, "::") {
					cleanText = text[2:]
				}
				value = cleanText

				if i := strings.Index(value, "::"); i != -1 {
					value = value[i+2:]
				}
			}

			if len(args) > 1 {
				params := make([]interface{}, len(args)-1)
				for i, v := range args[1:] {
					params[i] = v.Export(0)
				}
				value = fmt.Sprintf(value, params...)
			}

			return sim.NewString(value), nil
		},
	},
	{
		Name:      "i18n.createStore",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			store := sim.NewTranslationStore()
			wrapper := &translationStoreWrapper{store}
			return sim.NewObject(wrapper), nil
		},
	},
	{
		Name:      "i18n.setCurrentStore",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if args[0].Type == sim.Null || args[0].Type == sim.Undefined {
				vm.Translations = nil
				return sim.NullValue, nil
			}

			if args[0].Type == sim.Object {
				if wrapper, ok := args[0].ToObjectOrNil().(*translationStoreWrapper); ok {
					vm.Translations = wrapper.store
					return sim.NullValue, nil
				}
			}

			return sim.NullValue, fmt.Errorf("expected TranslationStore or null, got %s", args[0].TypeName())
		},
	},
	{
		Name:      "i18n.getCurrentStore",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.NullValue, nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return sim.NewObject(wrapper), nil
		},
	},
	{
		Name:      "i18n.set",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				vm.Translations = sim.NewTranslationStore()
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.set(args, vm)
		},
	},
	{
		Name:      "i18n.setBatch",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				vm.Translations = sim.NewTranslationStore()
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.setBatch(args, vm)
		},
	},
	{
		Name:      "i18n.get",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.NewString(""), nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.get(args, vm)
		},
	},
	{
		Name:      "i18n.clear",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.NullValue, nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.clear(args, vm)
		},
	},
	{
		Name:      "i18n.languages",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.NewArrayValues([]sim.Value{}), nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.languages(args, vm)
		},
	},
	{
		Name:      "i18n.hasLanguage",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.FalseValue, nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.hasLanguage(args, vm)
		},
	},
	{
		Name:      "i18n.getLanguageData",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.Translations == nil {
				return sim.NullValue, nil
			}

			wrapper := &translationStoreWrapper{vm.Translations}
			return wrapper.getLanguageData(args, vm)
		},
	},
}

var IO = []sim.NativeFunction{
	{
		Name:      "io.readAll",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToObject()

			reader, ok := r.(io.Reader)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a io.Reader, got %v", args[0])
			}

			b, err := ReadAll(reader, vm)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewBytes(b), nil
		},
	},
	{
		Name:      "io.newBuffer",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewObject(NewBuffer()), nil
		},
	},
	{
		Name:      "io.copy",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object, sim.Object); err != nil {
				return sim.NullValue, err
			}

			dst, ok := args[0].ToObject().(io.Writer)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}

			src, ok := args[1].ToObject().(io.Reader)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}

			i, err := io.Copy(dst, src)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewInt64(i), nil
		},
	},
	{
		Name:      "io.newRootedFS",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}
			fs, ok := args[1].ToObject().(*FileSystemObj)
			if !ok {
				return sim.NullValue, fmt.Errorf("invalid filesystem argument, got %v", args[1])
			}
			root := args[0].String()
			rFS, err := filesystem.NewRootedFS(root, fs.FS)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewObject(NewFileSystem(rFS)), nil
		},
	},
	{
		Name:      "io.newRestrictedFS",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			fs, ok := args[0].ToObject().(*FileSystemObj)
			if !ok {
				return sim.NullValue, fmt.Errorf("invalid filesystem argument, got %v", args[1])
			}

			rFS, err := filesystem.NewRestrictedFS(fs.FS)
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewObject(NewFileSystem(rFS)), nil
		},
	},
	{
		Name: "io.newVirtualFS",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args); err != nil {
				return sim.NullValue, err
			}

			fs := filesystem.NewVirtualFS()
			return sim.NewObject(NewFileSystem(fs)), nil
		},
	},
	{
		Name:      "io.newReadOnlyFS",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			fs, ok := args[0].ToObject().(*FileSystemObj)
			if !ok {
				return sim.NullValue, fmt.Errorf("invalid filesystem argument, got %v", args[1])
			}

			rfs := filesystem.NewReadOnlyFS(fs.FS)
			return sim.NewObject(NewFileSystem(rfs)), nil
		},
	},
}

var Image = []sim.NativeFunction{
	{
		Name:      "image.config",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 1); err != nil {
				return sim.NullValue, err
			}

			a := args[0]
			var r io.Reader

			switch a.Type {
			case sim.Object:
				var ok bool
				r, ok = a.ToObject().(io.Reader)
				if !ok {
					return sim.NullValue, ErrInvalidType
				}
			case sim.Bytes:
				r = bytes.NewBuffer(a.ToBytes())
			}

			conf, format, err := image.DecodeConfig(r)
			if err != nil {
				return sim.NullValue, err
			}

			obj := imageConfig{
				config: conf,
				format: format,
			}

			return sim.NewObject(obj), nil
		},
	},
	{
		Name:      "image.decode",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 1); err != nil {
				return sim.NullValue, err
			}

			a := args[0]
			var r io.Reader

			switch a.Type {
			case sim.Object:
				var ok bool
				r, ok = a.ToObject().(io.Reader)
				if !ok {
					return sim.NullValue, ErrInvalidType
				}
			case sim.Bytes:
				r = bytes.NewBuffer(a.ToBytes())
			}

			img, format, err := image.Decode(r)
			if err != nil {
				return sim.NullValue, err
			}

			obj := imageObj{
				img:    img,
				format: format,
			}

			return sim.NewObject(obj), nil
		},
	},
}

var JSON = []sim.NativeFunction{
	{
		Name:      "json.marshal",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			ln := len(args)
			if ln == 0 || ln > 3 {
				return sim.NullValue, fmt.Errorf("expected 1, 2 or 3 arguments, got %d", len(args))
			}

			var indent bool
			var escapeHTML bool

			if ln > 1 {
				v := args[1]
				if v.Type != sim.Bool {
					return sim.NullValue, fmt.Errorf("expected arg 2 to be boolean, got %s", v.TypeName())
				}
				indent = v.ToBool()
			}

			if ln > 2 {
				v := args[2]
				if v.Type != sim.Bool {
					return sim.NullValue, fmt.Errorf("expected arg 3 to be boolean, got %s", v.TypeName())
				}
				escapeHTML = v.ToBool()
			}

			obj := args[0].ExportMarshal(0)

			buf := &bytes.Buffer{}

			encoder := json.NewEncoder(buf)

			if indent {
				encoder.SetIndent("", "    ")
			}

			encoder.SetEscapeHTML(escapeHTML)

			if err := encoder.Encode(obj); err != nil {
				return sim.NullValue, err
			}

			buf.Truncate(buf.Len() - 1)

			return sim.NewString(buf.String()), nil
		},
	},
	{
		Name:      "json.unmarshal",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) != 1 {
				return sim.NullValue, fmt.Errorf("expected 1 argument, got %d", len(args))
			}

			a := args[0]

			switch a.Type {
			case sim.String, sim.Bytes:
			default:
				return sim.NullValue, fmt.Errorf("expected argument to be string or byte[], got %v", args[0].Type)
			}

			if a.String() == "" {
				return sim.NullValue, nil
			}

			v, err := unmarshal(a.ToBytes())
			if err != nil {
				return sim.NullValue, err
			}

			return v, nil
		},
	},
}

var JSRegex = []sim.NativeFunction{
	{
		Name:      "jsregex.match",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			result := jsregex.Match(args[0].String(), args[1].String())
			if result == nil {
				return sim.NullValue, nil
			}

			values := make([]sim.Value, len(result))
			for i, s := range result {
				values[i] = sim.NewString(s)
			}
			return sim.NewArrayValues(values), nil
		},
	},
	{
		Name:      "jsregex.matchAll",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			result := jsregex.MatchAll(args[0].String(), args[1].String())
			if result == nil {
				return sim.NullValue, nil
			}

			values := make([]sim.Value, len(result))
			for i, match := range result {
				matchValues := make([]sim.Value, len(match))
				for j, s := range match {
					matchValues[j] = sim.NewString(s)
				}
				values[i] = sim.NewArrayValues(matchValues)
			}
			return sim.NewArrayValues(values), nil
		},
	},
	{
		Name:      "jsregex.replace",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			result := jsregex.Replace(args[0].String(), args[1].String(), args[2].String())
			return sim.NewString(result), nil
		},
	},
	{
		Name:      "jsregex.replaceAll",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			result := jsregex.ReplaceAll(args[0].String(), args[1].String(), args[2].String())
			return sim.NewString(result), nil
		},
	},
	{
		Name:      "jsregex.search",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			result := jsregex.Search(args[0].String(), args[1].String())
			return sim.NewInt(result), nil
		},
	},
	{
		Name:      "jsregex.split",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 2, 3); err != nil {
				return sim.NullValue, err
			}
			if err := ValidateOptionalArgs(args, sim.String, sim.String, sim.Int); err != nil {
				return sim.NullValue, err
			}

			var result []string
			if len(args) == 3 {
				limit := int(args[2].ToInt())
				result = jsregex.Split(args[0].String(), args[1].String(), limit)
			} else {
				result = jsregex.Split(args[0].String(), args[1].String())
			}

			values := make([]sim.Value, len(result))
			for i, s := range result {
				values[i] = sim.NewString(s)
			}
			return sim.NewArrayValues(values), nil
		},
	},
	{
		Name:      "jsregex.newRegExp",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			re, err := jsregex.NewJSRegExp(args[0].String())
			if err != nil {
				return sim.NullValue, err
			}

			wrapper := &jsRegExpWrapper{re: re}
			return sim.NewObject(wrapper), nil
		},
	},
	{
		Name:      "jsregex.newJSString",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			wrapper := &jsStringWrapper{text: jsregex.JSString(args[0].String())}
			return sim.NewObject(wrapper), nil
		},
	},
}

var JWT = []sim.NativeFunction{
	{
		Name:      "jwt.verify",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			tokenString := args[0].String()

			publicKey, ok := args[1].ToObjectOrNil().(*rsaPublicKey)
			if !ok {
				return sim.NullValue, errors.New("invalid public key")
			}

			token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
				if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
					return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
				}
				return publicKey.key, nil
			})

			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewBool(token.Valid), nil
		},
	},
	{
		Name:      "jwt.newWithClaims",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.Map); err != nil {
				return sim.NullValue, err
			}

			var signMethod jwt.SigningMethod

			switch args[0].String() {
			case "HS256":
				signMethod = jwt.SigningMethodHS256
			case "RS256":
				signMethod = jwt.SigningMethodRS256
			default:
				return sim.NullValue, fmt.Errorf("invalid signing method, got %s", args[0].String())
			}

			m := args[1].ToMap().Map

			claims := jwt.MapClaims{}

			for k, v := range m {
				claims[k.String()] = v.Export(0)
			}

			token := jwt.NewWithClaims(signMethod, claims)

			return sim.NewObject(&jwtToken{token: token}), nil
		},
	},
}

var Locale = []sim.NativeFunction{
	{
		Name:      "->locale.currentLocalizer",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			loc := vm.Localizer
			if loc == nil {
				loc = defaultLocalizer
			}
			c := sim.NewObject(loc)
			return c, nil
		},
	},
	{
		Name:      "->locale.currentLanguage",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			s := sim.NewString(vm.Language)
			return s, nil
		},
	},
	{
		Name:      "->locale.defaultLocalizer",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			c := sim.NewObject(defaultLocalizer)
			return c, nil
		},
	},
	{
		Name:        "locale.setDefaultLocalizer",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			loc, ok := args[0].ToObjectOrNil().(*localizer)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}
			defaultLocalizer = loc
			return sim.NullValue, nil
		},
	},
	{
		Name:        "locale.setCurrentLocalizer",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			loc, ok := args[0].ToObjectOrNil().(*localizer)
			if !ok {
				return sim.NullValue, ErrInvalidType
			}
			vm.Localizer = loc
			return sim.NullValue, nil
		},
	},
	{
		Name:      "locale.setCurrentLanguage",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			vm.Language = args[0].String()
			return sim.NullValue, nil
		},
	},
	{
		Name:      "locale.newCulture",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			name := args[0].String()
			c := sim.NewObject(&culture{culture: locale.NewCulture(name)})
			return c, nil
		},
	},
	{
		Name:      "locale.newLocalizer",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			lt := sim.NewObject(&localizer{})
			return lt, nil
		},
	},
	{
		Name:      "locale.parseNumber",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			a := args[0]

			switch a.Type {
			case sim.Int, sim.Float:
				return a, nil
			case sim.String:
			default:
				return sim.NullValue, fmt.Errorf("expected string, got %d", a.Type)
			}

			loc := vm.Localizer
			if loc == nil {
				loc = defaultLocalizer
			}

			v, err := loc.ParseNumber(a.String())
			if err != nil {
				return sim.NullValue, err
			}

			if v == float64(int64(v)) {
				return sim.NewInt(int(v)), nil
			}
			return sim.NewFloat(v), nil
		},
	},
	{
		Name:      "locale.parseDate",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 1, 2); err != nil {
				return sim.NullValue, err
			}

			switch args[0].Type {
			case sim.String:
				break
			case sim.Int:
				return sim.NewObject(TimeObj(time.Unix(args[0].ToInt(), 0))), nil
			}

			value := args[0].String()

			var format string
			if len(args) == 2 {
				switch args[1].Type {
				case sim.Null, sim.Undefined:
					format = ""
				case sim.String:
					format = args[1].String()
				default:
					return sim.NullValue, ErrInvalidType
				}
			} else {
				if IsNumeric(value) {
					i, err := strconv.ParseInt(value, 10, 64)
					if err != nil {
						panic(err)
					}
					return sim.NewObject(TimeObj(time.Unix(i, 0))), nil
				}
				format = ""
			}

			loc := vm.Localizer
			if loc == nil {
				loc = defaultLocalizer
			}

			v, err := loc.ParseDate(value, format, vm.Location)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(TimeObj(v)), nil
		},
	},
	{
		Name:      "locale.format",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) != 2 {
				return sim.NullValue, fmt.Errorf("expected 2 arguments, got %d", len(args))
			}

			a := args[0]
			if a.Type != sim.String {
				return sim.NullValue, fmt.Errorf("expected argument 1 to be a string, got %v", a.TypeName())
			}

			loc := vm.Localizer
			if loc == nil {
				loc = defaultLocalizer
			}

			b := args[1].Export(0)
			s := loc.Format(vm.Language, a.String(), b, vm.Translations)
			return sim.NewString(s), nil
		},
	},
}

var LockManager = []sim.NativeFunction{
	{
		Name:      "lockManager.lock",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) < 1 || len(args) > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 arguments, got %d", len(args))
			}
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			contextId := ""
			if len(args) > 1 {
				contextId = args[1].String()
			}
			lock := lockStore.getLock(key)
			lock.Lock(contextId)

			return sim.NullValue, nil
		},
	},
	{
		Name:      "lockManager.unlock",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) < 1 || len(args) > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 arguments, got %d", len(args))
			}
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			contextId := ""
			if len(args) > 1 {
				contextId = args[1].String()
			}
			lock := lockStore.getLock(key)
			if err := lock.Unlock(contextId); err != nil {
				return sim.NullValue, err
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "lockManager.rLock",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) < 1 || len(args) > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 arguments, got %d", len(args))
			}
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			contextId := ""
			if len(args) > 1 {
				contextId = args[1].String()
			}
			lock := lockStore.getLock(key)
			lock.RLock(contextId)

			return sim.NullValue, nil
		},
	},
	{
		Name:      "lockManager.rUnlock",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) < 1 || len(args) > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 arguments, got %d", len(args))
			}
			if err := ValidateOptionalArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			contextId := ""
			if len(args) > 1 {
				contextId = args[1].String()
			}
			lock := lockStore.getLock(key)
			if err := lock.RUnlock(contextId); err != nil {
				return sim.NullValue, err
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:      "lockManager.exec",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args[:1], sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			fn := args[1]

			lock := lockStore.getLock(key)
			lock.Lock("")
			defer func() {
				if err := lock.Unlock(""); err != nil {

					fmt.Printf("Error unlocking in exec: %v\n", err)
				}
			}()

			switch fn.Type {
			case sim.Func:
				return vm.RunFuncIndex(int(fn.ToFunction()))
			case sim.Object:
				closure, ok := fn.ToObject().(*sim.Closure)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected function or closure, got %v", fn.TypeName())
				}
				return vm.RunClosure(closure)
			default:
				return sim.NullValue, fmt.Errorf("expected argument 2 to be function or closure, got %s", fn.TypeName())
			}
		},
	},
	{
		Name:      "lockManager.execReentrant",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args[:2], sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			key := args[0].String()
			contextId := args[1].String()
			fn := args[2]

			lock := lockStore.getLock(key)
			lock.Lock(contextId)
			defer func() {
				if err := lock.Unlock(contextId); err != nil {

					fmt.Printf("Error unlocking in execReentrant: %v\n", err)
				}
			}()

			switch fn.Type {
			case sim.Func:
				return vm.RunFuncIndex(int(fn.ToFunction()))
			case sim.Object:
				closure, ok := fn.ToObject().(*sim.Closure)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected function or closure, got %v", fn.TypeName())
				}
				return vm.RunClosure(closure)
			default:
				return sim.NullValue, fmt.Errorf("expected argument 3 to be function or closure, got %s", fn.TypeName())
			}
		},
	},
	{
		Name:      "lockManager.freeze",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args); err != nil {
				return sim.NullValue, err
			}

			// Create a mutex and lock it twice, which will cause a permanent deadlock
			var mu sync.Mutex
			mu.Lock()
			mu.Lock()

			return sim.NullValue, nil
		},
	},
}

var Markdown = []sim.NativeFunction{
	{
		Name:      "markdown.toHTML",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			text := args[0].ToString()
			html := parseBasicMarkdown(text)
			return sim.NewString(html), nil
		},
	},
	{
		Name:      "markdown.toHTMLFull",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			text := args[0].ToString()

			htmlFlags := 0
			htmlFlags |= blackfriday.HTML_USE_XHTML
			htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
			htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
			htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES

			extensions := 0
			extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
			extensions |= blackfriday.EXTENSION_TABLES
			extensions |= blackfriday.EXTENSION_FENCED_CODE
			extensions |= blackfriday.EXTENSION_AUTOLINK
			extensions |= blackfriday.EXTENSION_STRIKETHROUGH
			extensions |= blackfriday.EXTENSION_SPACE_HEADERS
			extensions |= blackfriday.EXTENSION_HEADER_IDS
			extensions |= blackfriday.EXTENSION_BACKSLASH_LINE_BREAK
			extensions |= blackfriday.EXTENSION_DEFINITION_LISTS

			renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
			output := blackfriday.MarkdownOptions([]byte(text), renderer, blackfriday.Options{
				Extensions: extensions,
			})

			return sim.NewString(string(output)), nil
		},
	},
}

var Math = []sim.NativeFunction{
	{
		Name:      "math.pow",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Float, sim.Float); err != nil {
				return sim.NullValue, err
			}
			v := math.Pow(args[0].ToFloat(), args[1].ToFloat())
			return sim.NewFloat(v), nil
		},
	},
	{
		Name:      "math.abs",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			v := math.Abs(args[0].ToFloat())
			return sim.NewFloat(v), nil
		},
	},
	{
		Name:      "math.floor",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			v := math.Floor(args[0].ToFloat())
			return sim.NewInt64(int64(v)), nil
		},
	},
	{
		Name:      "math.ceil",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			v := math.Ceil(args[0].ToFloat())
			return sim.NewInt64(int64(v)), nil
		},
	},
	{
		Name:      "math.round",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {

			l := len(args)
			if l > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 params, got %d", l)
			}

			f := args[0]
			switch f.Type {
			case sim.Float, sim.Int:
			default:
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be a number, got %s", f.TypeName())
			}

			if l == 1 {
				v := math.Round(f.ToFloat())
				return sim.NewInt64(int64(v)), nil
			}

			d := args[1]
			if d.Type != sim.Int {
				return sim.NullValue, fmt.Errorf("expected parameter 2 to be int, got %s", d.TypeName())
			}

			i := math.Pow10(int(d.ToInt()))
			v := math.Round(f.ToFloat()*i) / i
			return sim.NewFloat(v), nil
		},
	},
	{
		Name:      "math.trunc",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {

			l := len(args)
			if l > 2 {
				return sim.NullValue, fmt.Errorf("expected 1 or 2 params, got %d", l)
			}

			f := args[0]
			switch f.Type {
			case sim.Float, sim.Int:
			default:
				return sim.NullValue, fmt.Errorf("expected parameter 1 to be a number, got %s", f.TypeName())
			}

			if l == 1 {
				v := math.Trunc(f.ToFloat())
				return sim.NewInt64(int64(v)), nil
			}

			d := args[1]
			if d.Type != sim.Int {
				return sim.NullValue, fmt.Errorf("expected parameter 2 to be int, got %s", d.TypeName())
			}

			i := math.Pow10(int(d.ToInt()))
			v := math.Trunc(f.ToFloat()*i) / i
			return sim.NewFloat(v), nil
		},
	},
	{
		Name:      "math.rand",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}
			v := rand.Intn(int(args[0].ToInt()))
			return sim.NewInt(v), nil
		},
	},
	{
		Name:      "math.median",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			values := make([]float64, len(args))

			for i, v := range args {
				switch v.Type {
				case sim.Int, sim.Float:
					values[i] = v.ToFloat()
				default:
					return sim.NullValue, fmt.Errorf("element at %d is not a number: %s", i, v.TypeName())
				}
			}

			r := median(values)
			return sim.NewFloat(r), nil
		},
	},
	{
		Name:      "math.min",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var min float64
			var found bool

			for i, v := range args {
				switch v.Type {
				case sim.Null, sim.Undefined:

				case sim.Int, sim.Float:
					k := v.ToFloat()
					if !found {
						found = true
						min = k
					} else {
						if i == 0 {
							min = k
						} else if k < min {
							min = k
						}
					}

				default:
					return sim.NullValue, fmt.Errorf("element at %d is not a number: %s", i, v.TypeName())
				}
			}

			if !found {
				return sim.UndefinedValue, nil
			}

			return sim.NewFloat(min), nil
		},
	},
	{
		Name:      "math.max",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			var max float64
			var found bool

			for i, v := range args {
				switch v.Type {
				case sim.Null, sim.Undefined:

				case sim.Int, sim.Float:
					k := v.ToFloat()
					if !found {
						found = true
						max = k
					} else {
						if i == 0 {
							max = k
						} else if k > max {
							max = k
						}
					}
				default:
					return sim.NullValue, fmt.Errorf("element at %d is not a number: %s", i, v.TypeName())
				}
			}

			if !found {
				return sim.UndefinedValue, nil
			}

			return sim.NewFloat(max), nil
		},
	},
	{
		Name:      "math.standardDev",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			values := make([]float64, len(args))
			for i, v := range args {
				switch v.Type {
				case sim.Int, sim.Float:
					values[i] = v.ToFloat()
				default:
					return sim.NullValue, fmt.Errorf("element at %d is not a number: %s", i, v.TypeName())
				}
			}

			m := median(values)
			d := stdDev(values, m)
			return sim.NewFloat(d), nil
		},
	},
}

var Multipart = []sim.NativeFunction{
	{
		Name:      "multipart.newWriter",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Object); err != nil {
				return sim.NullValue, err
			}

			r := args[0].ToObject()

			w, ok := r.(io.Writer)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected a io.Writer, got %v", args[0])
			}

			m := multipart.NewWriter(w)
			return sim.NewObject(&multipartWriter{m}), nil
		},
	},
}

var Net = []sim.NativeFunction{
	{
		Name:      "net.inCIDR",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			cidr := args[0].String()

			ip := net.ParseIP(args[1].String())

			_, ipnet, err := net.ParseCIDR(cidr)
			if err != nil {
				return sim.NullValue, err
			}

			v := ipnet.Contains(ip)

			return sim.NewBool(v), nil
		},
	},
	{
		Name:        "net.listen",
		Arguments:   2,
		Permissions: []string{"netListen"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			listener, err := newNetListener(args[0].String(), args[1].String(), vm)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(listener), nil
		},
	},
	{
		Name:        "net.listenTCP",
		Arguments:   2,
		Permissions: []string{"netListen"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.Object); err != nil {
				return sim.NullValue, err
			}

			addr, ok := args[1].ToObject().(*tcpAddr)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected param 2 to be TCPAddr, got %s", args[1].TypeName())
			}

			listener, err := newTCPListener(args[0].String(), addr.addr, vm)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(listener), nil
		},
	},
	{
		Name:      "net.resolveTCPAddr",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			addr, err := net.ResolveTCPAddr(args[0].String(), args[1].String())
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(&tcpAddr{addr: addr}), nil
		},
	},
	{
		Name:      "net.dialTCP",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOrNilArgs(args, sim.String, sim.Object, sim.Object); err != nil {
				return sim.NullValue, err
			}

			network := args[0].String()

			var localAddr *net.TCPAddr

			lArg := args[1].ToObjectOrNil()
			if lArg != nil {
				ltcpAddr, ok := lArg.(*tcpAddr)
				if !ok {
					return sim.NullValue, fmt.Errorf("expected param 2 to be TCPAddr, got %s", args[1].TypeName())
				}
				localAddr = ltcpAddr.addr
			}

			remoteAddr, ok := args[2].ToObject().(*tcpAddr)
			if !ok {
				return sim.NullValue, fmt.Errorf("expected param 3 to be TCPAddr, got %s", args[1].TypeName())
			}

			conn, err := net.DialTCP(network, localAddr, remoteAddr.addr)
			if err != nil {
				return sim.NullValue, err
			}

			tc := newTCPConn(conn, vm)

			return sim.NewObject(tc), nil
		},
	},
	{
		Name:      "net.dial",
		Arguments: 2,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}
			conn, err := net.Dial(args[0].String(), args[1].String())
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(newNetConn(conn, vm)), nil
		},
	},
	{
		Name:      "net.dialTimeout",
		Arguments: 3,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if !isStringLike(args[0]) {
				return sim.NullValue, fmt.Errorf("expected param 1 to be string, got %s", args[0].TypeName())
			}
			if !isStringLike(args[1]) {
				return sim.NullValue, fmt.Errorf("expected param 2 to be string, got %s", args[1].TypeName())
			}

			d, err := ToDuration(args[2])
			if err != nil {
				return sim.NullValue, err
			}

			conn, err := net.DialTimeout(args[0].String(), args[1].String(), d)
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewObject(newNetConn(conn, vm)), nil
		},
	},
	{
		Name:        "net.getIPAddress",
		Arguments:   0,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			addrs, err := net.InterfaceAddrs()
			if err != nil {
				return sim.NullValue, err
			}

			for _, address := range addrs {
				if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
					if ipnet.IP.To4() != nil {
						return sim.NewString(ipnet.IP.String()), nil
					}
				}
			}

			return sim.NullValue, fmt.Errorf("no IP address found")
		},
	},
	{
		Name:        "net.getMacAddress",
		Arguments:   0,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			addrs, err := net.InterfaceAddrs()
			if err != nil {
				return sim.NullValue, err
			}

			var ip string

			for _, address := range addrs {
				if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
					if ipnet.IP.To4() != nil {
						ip = ipnet.IP.String()
						break
					}
				}
			}

			if ip == "" {
				return sim.NullValue, fmt.Errorf("no IP address found")
			}

			interfaces, err := net.Interfaces()
			if err != nil {
				return sim.NullValue, err
			}

			var hardwareName string

			for _, interf := range interfaces {
				if addrs, err := interf.Addrs(); err == nil {
					for _, addr := range addrs {

						if strings.Contains(addr.String(), ip) {
							hardwareName = interf.Name
							break
						}
					}
				}
			}

			if hardwareName == "" {
				return sim.NullValue, fmt.Errorf("no network hardware found")
			}

			netInterface, err := net.InterfaceByName(hardwareName)
			if err != nil {
				return sim.NullValue, err
			}

			macAddress := netInterface.HardwareAddr

			hwAddr, err := net.ParseMAC(macAddress.String())
			if err != nil {
				return sim.NullValue, err
			}

			return sim.NewString(hwAddr.String()), nil
		},
	},
}

var Number = []sim.NativeFunction{
	{
		Name: "->Number.MAX_VALUE",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewFloat(math.MaxFloat64), nil
		},
	},
	{
		Name: "->Number.MIN_VALUE",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewFloat(math.SmallestNonzeroFloat64), nil
		},
	},
	{
		Name: "->Number.NaN",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewFloat(math.NaN()), nil
		},
	},
	{
		Name: "->Number.NEGATIVE_INFINITY",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewFloat(math.Inf(-1)), nil
		},
	},
	{
		Name: "Number.POSITIVE_INFINITY",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewFloat(math.Inf(1)), nil
		},
	},
	{
		Name:      "Number.prototype.format",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			switch this.Type {
			case sim.Int, sim.Float:
				break
			default:
				return sim.NullValue, fmt.Errorf("expected byte array, got %s", this.TypeName())
			}

			format := args[0].ToString()

			loc := vm.Localizer
			if loc == nil {
				loc = defaultLocalizer
			}

			num := this.Export(0)

			s := loc.Format(vm.Language, format, num, vm.Translations)

			return sim.NewString(s), nil
		},
	},
	{
		Name:      "Number.prototype.toFixed",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			var precision int = 0

			if len(args) > 0 {
				precision = int(args[0].ToInt())
			}

			if precision < 0 || precision > 100 {
				return sim.NullValue, fmt.Errorf("toFixed() digits argument must be between 0 and 100")
			}

			// Convert to float64 to handle both int and float
			var num float64
			if this.Type == sim.Int {
				num = float64(this.ToInt())
			} else {
				num = this.ToFloat()
			}

			s := fmt.Sprintf("%."+strconv.Itoa(precision)+"f", num)
			return sim.NewString(s), nil
		},
	},
	{
		Name:      "Number.prototype.toString",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			radix := 10
			if len(args) > 0 {
				radix = int(args[0].ToInt())
			}

			if radix < 2 || radix > 36 {
				return sim.NullValue, fmt.Errorf("toString() radix argument must be between 2 and 36")
			}

			var result string
			if this.Type == sim.Int {
				result = strconv.FormatInt(this.ToInt(), radix)
			} else {
				if radix != 10 {
					return sim.NullValue, fmt.Errorf("toString() radix argument only supported for integers")
				}
				result = strconv.FormatFloat(this.ToFloat(), 'g', -1, 64)
			}

			return sim.NewString(result), nil
		},
	},
	{
		Name:      "Number.prototype.toExponential",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			var precision int = -1 // -1 means use as many digits as necessary

			if len(args) > 0 {
				precision = int(args[0].ToInt())
				if precision < 0 || precision > 100 {
					return sim.NullValue, fmt.Errorf("toExponential() fractionDigits argument must be between 0 and 100")
				}
			}

			// Convert to float64
			var num float64
			if this.Type == sim.Int {
				num = float64(this.ToInt())
			} else {
				num = this.ToFloat()
			}

			var result string
			if precision == -1 {
				result = strconv.FormatFloat(num, 'e', -1, 64)
			} else {
				result = strconv.FormatFloat(num, 'e', precision, 64)
			}

			return sim.NewString(result), nil
		},
	},
	{
		Name:      "Number.prototype.toPrecision",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			// Convert to float64
			var num float64
			if this.Type == sim.Int {
				num = float64(this.ToInt())
			} else {
				num = this.ToFloat()
			}

			if len(args) == 0 {
				result := strconv.FormatFloat(num, 'g', -1, 64)
				return sim.NewString(result), nil
			}

			precision := int(args[0].ToInt())
			if precision < 1 || precision > 100 {
				return sim.NullValue, fmt.Errorf("toPrecision() precision argument must be between 1 and 100")
			}

			result := strconv.FormatFloat(num, 'g', precision, 64)
			return sim.NewString(result), nil
		},
	},
	{
		Name: "Number.prototype.valueOf",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args); err != nil {
				return sim.NullValue, err
			}

			return this, nil
		},
	},
	{
		Name:      "Number",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgRange(args, 0, 1); err != nil {
				return sim.NullValue, err
			}

			if len(args) == 0 {
				return sim.NewInt(0), nil
			}

			arg := args[0]
			switch arg.Type {
			case sim.Int, sim.Float:
				return arg, nil
			case sim.String:
				str := strings.TrimSpace(arg.ToString())
				if str == "" {
					return sim.NewInt(0), nil
				}

				if str == "Infinity" || str == "+Infinity" {
					return sim.NewFloat(math.Inf(1)), nil
				}
				if str == "-Infinity" {
					return sim.NewFloat(math.Inf(-1)), nil
				}
				if str == "NaN" {
					return sim.NewFloat(math.NaN()), nil
				}

				str = strings.TrimLeft(str, " \t\n\r\v\f")

				if str == "" {
					return sim.NewInt(0), nil
				}

				sign := 1.0
				switch str[0] {
				case '-':
					sign = -1
					str = str[1:]
				case '+':
					str = str[1:]
				}

				if str == "" {
					return sim.NewFloat(math.NaN()), nil
				}

				hasDecimal := false
				result := 0.0
				decimalPlaces := 0.0

				for i, char := range str {
					if char == '.' && !hasDecimal {
						hasDecimal = true
						continue
					}

					if char >= '0' && char <= '9' {
						if hasDecimal {
							decimalPlaces++
							result = result + float64(char-'0')/math.Pow(10, decimalPlaces)
						} else {
							result = result*10 + float64(char-'0')
						}
					} else {

						if i == 0 {
							return sim.NewFloat(math.NaN()), nil
						}
						break
					}
				}

				result *= sign

				if !hasDecimal && result >= math.MinInt64 && result <= math.MaxInt64 {
					return sim.NewInt64(int64(result)), nil
				}
				return sim.NewFloat(result), nil
			case sim.Bool:
				if arg.ToBool() {
					return sim.NewInt(1), nil
				}
				return sim.NewInt(0), nil
			case sim.Null:
				return sim.NewInt(0), nil
			case sim.Undefined:
				return sim.NewFloat(math.NaN()), nil
			default:
				return sim.NewFloat(math.NaN()), nil
			}
		},
	},
	{
		Name:      "isNaN",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) != 1 {
				return sim.NullValue, fmt.Errorf("expected 1 argument, got %d", len(args))
			}

			value := args[0]

			switch value.Type {
			case sim.Float:
				return sim.NewBool(math.IsNaN(value.ToFloat())), nil
			case sim.Int:

				return sim.FalseValue, nil
			case sim.String:

				s := value.String()
				if s == "" {
					return sim.FalseValue, nil
				}
				if f, err := strconv.ParseFloat(s, 64); err != nil {

					return sim.TrueValue, nil
				} else {
					return sim.NewBool(math.IsNaN(f)), nil
				}
			case sim.Bool:

				return sim.FalseValue, nil
			case sim.Null:

				return sim.FalseValue, nil
			case sim.Undefined:

				return sim.TrueValue, nil
			default:

				s := value.String()
				if f, err := strconv.ParseFloat(s, 64); err != nil {
					return sim.TrueValue, nil
				} else {
					return sim.NewBool(math.IsNaN(f)), nil
				}
			}
		},
	},
	{
		Name:      "Number.isNaN",
		Arguments: 1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if len(args) != 1 {
				return sim.NullValue, fmt.Errorf("expected 1 argument, got %d", len(args))
			}

			value := args[0]

			if value.Type == sim.Float {
				return sim.NewBool(math.IsNaN(value.ToFloat())), nil
			}

			return sim.FalseValue, nil
		},
	},
}

var OS = []sim.NativeFunction{
	{
		Name:        "->os.sharedCache",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sharedCache, nil
		},
	},
	{
		Name: "->os.ErrNotExist",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewString("no such file or directory"), nil
		},
	},
	{
		Name:        "os.hostName",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			name, err := os.Hostname()
			if err != nil {
				return sim.NullValue, err
			}
			return sim.NewString(name), nil
		},
	},
	{
		Name: "->os.pathSeparator",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewString(string(os.PathSeparator)), nil
		},
	},
	{
		Name:        "->os.userHomeDir",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			d, err := os.UserHomeDir()
			if err != nil {
				return sim.NullValue, ErrUnauthorized
			}
			return sim.NewString(d), nil
		},
	},
	{
		Name:        "->os.stdout",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			f := &file{f: os.Stdout}
			return sim.NewObject(f), nil
		},
	},
	{
		Name:        "->os.stdin",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			f := &file{f: os.Stdin}
			return sim.NewObject(f), nil
		},
	},
	{
		Name:        "->os.stderr",
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			f := &file{f: os.Stderr}
			return sim.NewObject(f), nil
		},
	},
	{
		Name:        "os.mapPath",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}

			p := args[0].String()

			if len(p) > 0 && p[0] == '~' {
				usr, err := user.Current()
				if err != nil {
					return sim.NullValue, err
				}
				p = filepath.Join(usr.HomeDir, p[1:])
			}

			return sim.NewString(p), nil
		},
	},
	{
		Name:        "os.exit",
		Arguments:   -1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateOptionalArgs(args, sim.Int); err != nil {
				return sim.NullValue, err
			}

			var exitCode int
			if len(args) > 0 {
				exitCode = int(args[0].ToInt())
			}

			os.Exit(exitCode)
			return sim.NullValue, nil
		},
	},
	{
		Name:        "os.exec",
		Arguments:   -1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			l := len(args)
			if l == 0 {
				return sim.NullValue, fmt.Errorf("expected at least 1 argument")
			}

			values := make([]string, l)
			for i, v := range args {
				values[i] = v.String()
			}

			cmd := exec.Command(values[0], values[1:]...)
			cmd.Stderr = os.Stderr
			cmd.Stdout = os.Stdout

			if err := cmd.Run(); err != nil {
				return sim.NullValue, err
			}

			return sim.NullValue, nil
		},
	},
	{
		Name:        "os.newCommand",
		Arguments:   -1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			l := len(args)
			if l == 0 {
				return sim.NullValue, fmt.Errorf("expected at least 1 argument")
			}

			values := make([]string, l)
			for i, v := range args {
				values[i] = v.String()
			}

			cmd := newCommand(values[0], values[1:]...)

			return sim.NewObject(cmd), nil
		},
	},

	{
		Name:      "os.getWd",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}

			f := &FileSystemObj{fs}
			return f.getWd(args, vm)
		},
	},
	{
		Name:      "os.open",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.open(args, vm)
		},
	},
	{
		Name:      "os.openIfExists",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.openIfExists(args, vm)
		},
	},
	{
		Name:      "os.openForWrite",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.openForWrite(args, vm)
		},
	},
	{
		Name:      "os.openForAppend",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.openForAppend(args, vm)
		},
	},
	{
		Name:      "os.chdir",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.chdir(args, vm)
		},
	},
	{
		Name:      "os.exists",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.exists(args, vm)
		},
	},
	{
		Name:      "os.rename",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.rename(args, vm)
		},
	},
	{
		Name:      "os.removeAll",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.removeAll(args, vm)
		},
	},
	{
		Name:      "os.readAll",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readAll(args, vm)
		},
	},
	{
		Name:      "os.readAllIfExists",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readAllIfExists(args, vm)
		},
	},
	{
		Name:      "os.readString",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readString(args, vm)
		},
	},
	{
		Name:      "os.readStringIfExists",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readStringIfExists(args, vm)
		},
	},
	{
		Name:      "os.write",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.write(args, vm)
		},
	},
	{
		Name:      "os.append",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.append(args, vm)
		},
	},
	{
		Name:      "os.mkdir",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.mkdir(args, vm)
		},
	},
	{
		Name:      "os.stat",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.stat(args, vm)
		},
	},
	{
		Name:      "os.readDir",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readDir(args, vm)
		},
	},
	{
		Name:      "os.readNames",
		Arguments: -1,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			fs := vm.FileSystem
			if fs == nil {
				return sim.NullValue, ErrNoFileSystem
			}
			f := &FileSystemObj{fs}
			return f.readNames(args, vm)
		},
	},

	{
		Name:        "os.readLine",
		Arguments:   0,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {

			r := bufio.NewReader(os.Stdin)
			s, err := r.ReadString('\n')
			if err != nil {
				return sim.NullValue, err
			}

			s = s[:len(s)-1]

			return sim.NewString(s), nil
		},
	},
	{
		Name: "->os.fileSystem",
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if vm.FileSystem == nil {
				return sim.NullValue, nil
			}
			return sim.NewObject(NewFileSystem(vm.FileSystem)), nil
		},
	},
	{
		Name:        "os.getEnv",
		Arguments:   1,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String); err != nil {
				return sim.NullValue, err
			}
			s := os.Getenv(args[0].String())
			return sim.NewString(s), nil
		},
	},
	{
		Name:        "os.setEnv",
		Arguments:   2,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.String, sim.String); err != nil {
				return sim.NullValue, err
			}

			if err := os.Setenv(args[0].String(), args[1].String()); err != nil {
				return sim.NullValue, err
			}
			return sim.NullValue, nil
		},
	},
	{
		Name:        "os.newFile",
		Arguments:   2,
		Permissions: []string{"trusted"},
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			if err := ValidateArgs(args, sim.Int, sim.String); err != nil {
				return sim.NullValue, err
			}

			f := os.NewFile(uintptr(args[0].ToInt()), args[1].String())
			ff := &file{f: f}
			return sim.NewObject(ff), nil
		},
	},
	{
		Name:      "->os.DevNull",
		Arguments: 0,
		Function: func(this sim.Value, args []sim.Value, vm *sim.VM) (sim.Value, error) {
			return sim.NewString(os.DevNull), nil
		},
	},
}