core

var (
	Undefined   = Value{}
	True        = Value{Type: value.Bool, Immutable: true, Data: 1}
	False       = Value{Type: value.Bool, Immutable: true, Data: 0}
	EmptyString = Value{Type: value.String, Immutable: true, Ptr: unsafe.Pointer(&emptyString)}
)

var BuiltinFunctions [MaxModules * ModuleSlotSize]*BuiltinFunction

var DefaultValueType = ValueTypeDescr{
	Name:         func(v Value) string { return fmt.Sprintf("<unknown:%d>", v.Type) },
	String:       func(v Value) string { return v.TypeName() },
	Format:       defaultFormat,
	Interface:    func(_ Value) any { return nil },
	EncodeJSON:   func(v Value) ([]byte, error) { return nil, errs.NewJSONEncodingError(v.TypeName()) },
	EncodeBinary: func(v Value) ([]byte, error) { return nil, errs.NewBinaryEncodingError(v.TypeName()) },
	DecodeBinary: func(v *Value, _ []byte) error { return errs.NewBinaryEncodingError(v.TypeName()) },
	IsTrue:       ConstHook(false),
	Clone:        func(v Value) (Value, error) { return v, nil },
	Equal:        func(v Value, r Value) bool { return v == r },

	UnaryOp:    defaultUnaryOp,
	BinaryOp:   defaultBinaryOp,
	MethodCall: defaultMethodCall,

	IsIterable: ConstHook(false),
	Contains:   func(Value, Value) bool { return false },
	Len:        ConstHook(int64(0)),
	Iterator:   ValueHook(Undefined, nil),
	Assign:     func(v Value, _, _ Value) error { return errs.NewNotAssignableError(v.TypeName()) },
	Delete:     defaultDelete,

	Access:    defaultAccess,
	Append:    defaultAppend,
	Slice:     defaultSlice,
	SliceStep: defaultSliceStep,

	IsCallable: ConstHook(false),
	IsVariadic: ConstHook(false),
	Arity:      ConstHook(0),

	Call: defaultCall,

	Next:  ConstHook(false),
	Key:   ValueHook(Undefined, nil),
	Value: ValueHook(Undefined, nil),

	AsBool:    Const2Hook(false, false),
	AsByte:    Const2Hook(byte(0), false),
	AsRune:    Const2Hook(rune(0), false),
	AsInt:     Const2Hook(int64(0), false),
	AsFloat:   Const2Hook(float64(0), false),
	AsDecimal: Const2Hook(dec128.Decimal0, false),
	AsTime:    Const2Hook(time.Time{}, false),
	AsString:  Const2Hook("", false),
	AsBytes:   Const2Hook[[]byte](nil, false),
	AsArray:   func(Value) ([]Value, bool) { return nil, false },
	AsDict:    func(Value) (map[string]Value, bool) { return nil, false },
	AsRunes:   defaultAsRunes,

	IsMethodPure: func(string) bool { return false },
}

var TypeArray = ValueTypeDescr{
	Name:         SeqNameHook(arrayTypeName, immutableArrayTypeName),
	String:       arrayTypeString,
	Format:       arrayTypeFormat,
	Interface:    arrayTypeInterface,
	EncodeJSON:   arrayTypeEncodeJSON,
	EncodeBinary: arrayTypeEncodeBinary,
	DecodeBinary: arrayTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return len((*Array)(v.Ptr).Elements) > 0 },
	IsIterable:   ConstHook(true),
	Iterator:     arrayTypeIterator,
	Equal:        arrayTypeEqual,
	Clone:        arrayTypeClone,
	Len:          func(v Value) int64 { return int64(len((*Array)(v.Ptr).Elements)) },
	BinaryOp:     arrayTypeBinaryOp,
	MethodCall:   arrayTypeMethodCall,
	Access:       SeqAccessHook(RefValue, arrayTypeResolve),
	Assign:       SeqAssignHook(arrayTypeResolve, Value.AsValue, anyTypeName),
	Contains:     arrayTypeContains,
	Append:       arrayTypeAppend,
	Slice:        SeqSliceHook(NewArrayValue, arrayTypeResolve),
	SliceStep:    SeqSliceStepHook(NewArrayValue, arrayTypeResolve),
	AsBool:       func(v Value) (bool, bool) { return len((*Array)(v.Ptr).Elements) > 0, true },
	AsString:     arrayTypeAsString,
	AsRunes:      arrayTypeAsRunes,
	AsBytes:      arrayTypeAsBytes,
	AsArray:      func(v Value) ([]Value, bool) { return (*Array)(v.Ptr).Elements, true },

	IsMethodPure: func(string) bool { return true },
}

var TypeArrayIterator = ValueTypeDescr{
	Name:   ConstHook(arrayIteratorTypeName),
	String: SeqIterStringHook[Value](arrayIteratorTypeName, arrayIteratorResolve),
	Next:   SeqIterNextHook[Value](arrayIteratorResolve),
	Key:    SeqIterKeyHook[Value](arrayIteratorResolve),
	Value:  SeqIterValueHook(RefValue, arrayIteratorResolve),
}

var TypeBool = ValueTypeDescr{
	Name:         ConstHook(boolTypeName),
	String:       boolTypeString,
	Format:       boolTypeFormat,
	Interface:    func(v Value) any { return v.Data != 0 },
	EncodeJSON:   boolTypeEncodeJSON,
	EncodeBinary: boolTypeEncodeBinary,
	DecodeBinary: boolTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return v.Data != 0 },
	Equal:        boolTypeEqual,
	MethodCall:   boolTypeMethodCall,
	Len:          ConstHook(int64(1)),
	AsString:     boolTypeAsString,
	AsInt:        boolTypeAsInt,
	AsBool:       func(v Value) (bool, bool) { return v.Data != 0, true },
	AsByte:       boolTypeAsByte,
	IsMethodPure: func(string) bool { return true },
}

var TypeBuiltinClosure = ValueTypeDescr{
	Name:         builtinClosureTypeName,
	String:       func(v Value) string { return builtinClosureTypeName(v) },
	IsTrue:       ConstHook(true),
	IsCallable:   ConstHook(true),
	IsVariadic:   builtinClosureTypeIsVariadic,
	Arity:        builtinClosureTypeArity,
	Call:         builtinClosureTypeCall,
	MethodCall:   builtinClosureTypeMethodCall,
	IsMethodPure: func(string) bool { return true },
}

var TypeBuiltinFunction = ValueTypeDescr{
	Name:         builtinFunctionTypeName,
	String:       func(v Value) string { return builtinFunctionTypeName(v) },
	EncodeBinary: builtinFunctionTypeEncodeBinary,
	DecodeBinary: builtinFunctionTypeDecodeBinary,
	IsTrue:       ConstHook(true),
	IsCallable:   ConstHook(true),
	IsVariadic:   builtinFunctionTypeIsVariadic,
	Arity:        builtinFunctionTypeArity,
	Call:         builtinFunctionTypeCall,
	MethodCall:   builtinFunctionTypeMethodCall,
	IsMethodPure: func(string) bool { return true },
}

var TypeByte = ValueTypeDescr{
	Name:         ConstHook(byteTypeName),
	String:       func(v Value) string { return fmt.Sprintf("byte(%d)", v.Data) },
	Format:       byteTypeFormat,
	Interface:    func(v Value) any { return byte(v.Data) },
	EncodeJSON:   byteTypeEncodeJSON,
	EncodeBinary: byteTypeEncodeBinary,
	DecodeBinary: byteTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return v.Data != 0 },
	Equal:        byteTypeEqual,
	Len:          ConstHook(int64(1)),
	UnaryOp:      byteTypeUnaryOp,
	BinaryOp:     byteTypeBinaryOp,
	MethodCall:   byteTypeMethodCall,
	AsString:     func(v Value) (string, bool) { return strconv.FormatInt(int64(v.Data), 10), true },
	AsInt:        func(v Value) (int64, bool) { return int64(v.Data), true },
	AsBool:       func(v Value) (bool, bool) { return v.Data != 0, true },
	AsRune:       func(v Value) (rune, bool) { return rune(v.Data), true },
	AsByte:       func(v Value) (byte, bool) { return byte(v.Data), true },
	AsFloat:      func(v Value) (float64, bool) { return float64(int64(v.Data)), true },
	AsDecimal:    func(v Value) (dec128.Dec128, bool) { return dec128.FromInt64(int64(v.Data)), true },
	IsMethodPure: func(string) bool { return true },
}

var TypeBytes = ValueTypeDescr{
	Name:         SeqNameHook(bytesTypeName, immutableBytesTypeName),
	String:       bytesTypeString,
	Format:       bytesTypeFormat,
	Interface:    func(v Value) any { return (*Bytes)(v.Ptr).Elements },
	EncodeJSON:   bytesTypeEncodeJSON,
	EncodeBinary: bytesTypeEncodeBinary,
	DecodeBinary: bytesTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return len((*Bytes)(v.Ptr).Elements) > 0 },
	IsIterable:   ConstHook(true),
	Iterator:     bytesTypeIterator,
	Equal:        bytesTypeEqual,
	Clone:        bytesTypeClone,
	Len:          func(v Value) int64 { return int64(len((*Bytes)(v.Ptr).Elements)) },
	BinaryOp:     bytesTypeBinaryOp,
	MethodCall:   bytesTypeMethodCall,
	Access:       SeqAccessHook(ByteValue, bytesTypeResolve),
	Assign:       SeqAssignHook(bytesTypeResolve, Value.AsByte, byteTypeName),
	Append:       bytesTypeAppend,
	Contains:     bytesTypeContains,
	Slice:        SeqSliceHook(NewBytesValue, bytesTypeResolve),
	SliceStep:    SeqSliceStepHook(NewBytesValue, bytesTypeResolve),
	AsBool:       func(v Value) (bool, bool) { return conv.ParseBool(string((*Bytes)(v.Ptr).Elements)) },
	AsString:     func(v Value) (string, bool) { return string((*Bytes)(v.Ptr).Elements), true },
	AsBytes:      func(v Value) ([]byte, bool) { return (*Bytes)(v.Ptr).Elements, true },
	AsArray:      bytesTypeAsArray,

	IsMethodPure: func(string) bool { return true },
}

var TypeBytesIterator = ValueTypeDescr{
	Name:   ConstHook(bytesIteratorTypeName),
	String: SeqIterStringHook[byte](bytesIteratorTypeName, bytesIteratorResolve),
	Next:   SeqIterNextHook[byte](bytesIteratorResolve),
	Key:    SeqIterKeyHook[byte](bytesIteratorResolve),
	Value:  SeqIterValueHook(ByteValue, bytesIteratorResolve),
}

var TypeCompiledFunction = ValueTypeDescr{
	Name:         compiledFunctionTypeName,
	String:       func(v Value) string { return compiledFunctionTypeName(v) },
	EncodeBinary: compiledFunctionTypeEncodeBinary,
	DecodeBinary: compiledFunctionTypeDecodeBinary,
	IsTrue:       ConstHook(true),
	IsCallable:   ConstHook(true),
	IsVariadic:   compiledFunctionTypeIsVariadic,
	Equal:        compiledFunctionTypeEqual,
	Arity:        compiledFunctionTypeArity,
	Call:         compiledFunctionTypeCall,
	MethodCall:   compiledFunctionTypeMethodCall,
	IsMethodPure: func(string) bool { return true },
}

var TypeDecimal = ValueTypeDescr{
	Name:         ConstHook(decimalTypeName),
	String:       decimalTypeString,
	Format:       decimalTypeFormat,
	Interface:    func(v Value) any { return *(*dec128.Dec128)(v.Ptr) },
	EncodeJSON:   func(v Value) ([]byte, error) { return (*dec128.Dec128)(v.Ptr).MarshalJSON() },
	EncodeBinary: decimalTypeEncodeBinary,
	DecodeBinary: decimalTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return !(*dec128.Dec128)(v.Ptr).IsZero() },
	Equal:        decimalTypeEqual,
	Len:          ConstHook(int64(1)),
	UnaryOp:      decimalTypeUnaryOp,
	BinaryOp:     decimalTypeBinaryOp,
	MethodCall:   decimalTypeMethodCall,
	AsString:     func(v Value) (string, bool) { return (*dec128.Dec128)(v.Ptr).String(), true },
	AsInt:        decimalTypeAsInt,
	AsFloat:      decimalTypeAsFloat,
	AsDecimal:    func(v Value) (dec128.Dec128, bool) { return *(*dec128.Dec128)(v.Ptr), true },
	AsBool:       func(v Value) (bool, bool) { return !(*dec128.Dec128)(v.Ptr).IsZero(), true },
	IsMethodPure: func(string) bool { return true },
}

var TypeDict = ValueTypeDescr{
	Name:         SeqNameHook(dictTypeName, immutableDictTypeName),
	String:       dictTypeString,
	Format:       dictTypeFormat,
	Interface:    dictTypeInterface,
	EncodeJSON:   dictTypeEncodeJSON,
	EncodeBinary: dictTypeEncodeBinary,
	DecodeBinary: dictTypeDecodeBinary,
	IsTrue:       dictTypeIsTrue,
	IsIterable:   ConstHook(true),
	Iterator:     dictTypeIterator,
	Equal:        dictTypeEqual,
	Clone:        dictTypeClone,
	Len:          dictTypeLen,
	MethodCall:   dictTypeMethodCall,
	Access:       dictTypeAccess,
	Assign:       dictTypeAssign,
	Contains:     dictTypeContains,
	Delete:       dictTypeDelete,
	AsBool:       dictTypeAsBool,
	AsString:     dictTypeAsString,
	AsDict:       dictTypeAsDict,

	IsMethodPure: func(string) bool { return true },
}

var TypeDictIterator = ValueTypeDescr{
	Name:   ConstHook(dictIteratorTypeName),
	String: dictIteratorTypeString,
	Equal:  dictIteratorTypeEqual,
	Next:   dictIteratorTypeNext,
	Key:    dictIteratorTypeKey,
	Value:  dictIteratorTypeValue,
}

var TypeError = ValueTypeDescr{
	Name:         ConstHook(errorTypeName),
	String:       errorTypeString,
	Format:       errorTypeFormat,
	Interface:    func(v Value) any { return errors.New(v.String()) },
	EncodeJSON:   errorTypeEncodeJSON,
	EncodeBinary: errorTypeEncodeBinary,
	DecodeBinary: errorTypeDecodeBinary,
	IsTrue:       ConstHook(false),
	Equal:        errorTypeEqual,
	Clone:        errorTypeClone,
	MethodCall:   errorTypeMethodCall,
	AsString:     errorTypeAsString,
	AsBool:       Const2Hook(false, true),
	IsMethodPure: func(string) bool { return true },
}

var TypeFloat = ValueTypeDescr{
	Name:         ConstHook(floatTypeName),
	String:       floatTypeString,
	Format:       floatTypeFormat,
	Interface:    func(v Value) any { return math.Float64frombits(v.Data) },
	EncodeJSON:   floatTypeEncodeJSON,
	EncodeBinary: floatTypeEncodeBinary,
	DecodeBinary: floatTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return !math.IsNaN(math.Float64frombits(v.Data)) },
	Equal:        floatTypeEqual,
	Len:          ConstHook(int64(1)),
	UnaryOp:      floatTypeUnaryOp,
	BinaryOp:     floatTypeBinaryOp,
	MethodCall:   floatTypeMethodCall,
	AsInt:        floatTypeAsInt,
	AsFloat:      floatTypeAsFloat,
	AsDecimal:    floatTypeAsDecimal,
	AsBool:       floatTypeAsBool,
	AsString:     floatTypeAsString,
	IsMethodPure: func(string) bool { return true },
}

var TypeFormatSpec = ValueTypeDescr{
	Name:   ConstHook(formatSpecTypeName),
	String: formatSpecTypeString,
	Equal:  formatSpecTypeEqual,
}

var TypeInt = ValueTypeDescr{
	Name:         ConstHook(intTypeName),
	String:       func(v Value) string { return strconv.FormatInt(int64(v.Data), 10) },
	Format:       intTypeFormat,
	Interface:    func(v Value) any { return int64(v.Data) },
	EncodeJSON:   intTypeEncodeJSON,
	EncodeBinary: intTypeEncodeBinary,
	DecodeBinary: intTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return v.Data != 0 },
	Equal:        intTypeEqual,
	Len:          ConstHook(int64(1)),
	UnaryOp:      intTypeUnaryOp,
	BinaryOp:     intTypeBinaryOp,
	MethodCall:   intTypeMethodCall,
	AsString:     func(v Value) (string, bool) { return strconv.FormatInt(int64(v.Data), 10), true },
	AsInt:        func(v Value) (int64, bool) { return int64(v.Data), true },
	AsFloat:      func(v Value) (float64, bool) { return float64(int64(v.Data)), true },
	AsDecimal:    func(v Value) (dec128.Dec128, bool) { return dec128.FromInt64(int64(v.Data)), true },
	AsBool:       func(v Value) (bool, bool) { return v.Data != 0, true },
	AsRune:       intTypeAsRune,
	AsTime:       func(v Value) (time.Time, bool) { return time.Unix(int64(v.Data), 0).UTC(), true },
	AsByte:       intTypeAsByte,
	IsMethodPure: func(string) bool { return true },
}

var TypeIntRange = ValueTypeDescr{
	Name:         ConstHook(intRangeTypeName),
	EncodeBinary: intRangeTypeEncodeBinary,
	DecodeBinary: intRangeTypeDecodeBinary,
	String:       intRangeTypeString,
	Format:       intRangeTypeFormat,
	IsTrue:       intRangeTypeIsTrue,
	IsIterable:   ConstHook(true),
	Iterator:     intRangeTypeIterator,
	Equal:        intRangeTypeEqual,
	Len:          intRangeTypeLen,
	MethodCall:   intRangeTypeMethodCall,
	Access:       intRangeTypeAccess,
	Contains:     intRangeTypeContains,
	AsBool:       intRangeTypeAsBool,
	AsArray:      intRangeTypeAsArray,

	IsMethodPure: func(string) bool { return true },
}

var TypeIntRangeIterator = ValueTypeDescr{
	Name:   ConstHook(intRangeIteratorTypeName),
	String: intRangeIteratorTypeString,
	Equal:  intRangeIteratorTypeEqual,
	Next:   intRangeIteratorTypeNext,
	Key:    intRangeIteratorTypeKey,
	Value:  intRangeIteratorTypeValue,
}

var TypeRecord = ValueTypeDescr{
	Name:         SeqNameHook(recordTypeName, immutableRecordTypeName),
	String:       recordTypeString,
	Format:       recordTypeFormat,
	Interface:    recordTypeInterface,
	EncodeJSON:   recordTypeEncodeJSON,
	EncodeBinary: recordTypeEncodeBinary,
	DecodeBinary: recordTypeDecodeBinary,
	IsTrue:       recordTypeIsTrue,
	IsIterable:   ConstHook(true),
	Iterator:     recordTypeIterator,
	Equal:        recordTypeEqual,
	Clone:        recordTypeClone,
	Len:          recordTypeLen,
	MethodCall:   recordTypeMethodCall,
	Access:       recordTypeAccess,
	Assign:       recordTypeAssign,
	Contains:     recordTypeContains,
	Delete:       recordTypeDelete,
	AsBool:       recordTypeAsBool,
	AsString:     recordTypeAsString,
	AsDict:       recordTypeAsDict,
	IsMethodPure: func(string) bool { return false },
}

var TypeRune = ValueTypeDescr{
	Name:         ConstHook(runeTypeName),
	String:       func(v Value) string { return fmt.Sprintf("%q", rune(v.Data)) },
	Format:       runeTypeFormat,
	Interface:    func(v Value) any { return rune(v.Data) },
	EncodeJSON:   runeTypeEncodeJSON,
	EncodeBinary: runeTypeEncodeBinary,
	DecodeBinary: runeTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return v.Data != 0 },
	Equal:        runeTypeEqual,
	Len:          ConstHook(int64(1)),
	BinaryOp:     runeTypeBinaryOp,
	MethodCall:   runeTypeMethodCall,
	AsString:     func(v Value) (string, bool) { return string(rune(v.Data)), true },
	AsInt:        func(v Value) (int64, bool) { return int64(v.Data), true },
	AsBool:       func(v Value) (bool, bool) { return v.Data != 0, true },
	AsRune:       func(v Value) (rune, bool) { return rune(v.Data), true },
	AsByte:       runeTypeAsByte,
	IsMethodPure: func(string) bool { return true },
}

var TypeRunes = ValueTypeDescr{
	Name:         SeqNameHook(runesTypeName, immutableRunesTypeName),
	String:       func(v Value) string { return "u" + strconv.Quote(string((*Runes)(v.Ptr).Elements)) },
	Format:       runesTypeFormat,
	Interface:    func(v Value) any { return (*Runes)(v.Ptr).Elements },
	EncodeJSON:   runesTypeEncodeJSON,
	EncodeBinary: runesTypeEncodeBinary,
	DecodeBinary: runesTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return len((*Runes)(v.Ptr).Elements) > 0 },
	IsIterable:   ConstHook(true),
	Iterator:     runesTypeIterator,
	Equal:        runesTypeEqual,
	Clone:        runesTypeClone,
	Len:          func(v Value) int64 { return int64(len((*Runes)(v.Ptr).Elements)) },
	BinaryOp:     runesTypeBinaryOp,
	MethodCall:   runesTypeMethodCall,
	Access:       SeqAccessHook(RuneValue, runesTypeResolve),
	Assign:       SeqAssignHook(runesTypeResolve, Value.AsRune, runeTypeName),
	Append:       runesTypeAppend,
	Contains:     runesTypeContains,
	Slice:        SeqSliceHook(NewRunesValue, runesTypeResolve),
	SliceStep:    SeqSliceStepHook(NewRunesValue, runesTypeResolve),
	AsBool:       runesTypeAsBool,
	AsInt:        runesTypeAsInt,
	AsByte:       runesTypeAsByte,
	AsFloat:      runesTypeAsFloat,
	AsDecimal:    runesTypeAsDecimal,
	AsTime:       runesTypeAsTime,
	AsString:     func(v Value) (string, bool) { return string((*Runes)(v.Ptr).Elements), true },
	AsRunes:      func(v Value) ([]rune, bool) { return (*Runes)(v.Ptr).Elements, true },
	AsBytes:      runesTypeAsBytes,
	AsArray:      runesTypeAsArray,

	IsMethodPure: func(string) bool { return true },
}

var TypeRunesIterator = ValueTypeDescr{
	Name:   ConstHook(runesIteratorTypeName),
	String: SeqIterStringHook[rune](runesIteratorTypeName, runesIteratorResolve),
	Next:   SeqIterNextHook[rune](runesIteratorResolve),
	Key:    SeqIterKeyHook[rune](runesIteratorResolve),
	Value:  SeqIterValueHook(RuneValue, runesIteratorResolve),
}

var TypeString = ValueTypeDescr{
	Name:         ConstHook(stringTypeName),
	String:       func(v Value) string { return strconv.Quote(*(*string)(v.Ptr)) },
	Format:       stringTypeFormat,
	Interface:    func(v Value) any { return *(*string)(v.Ptr) },
	EncodeJSON:   stringTypeEncodeJSON,
	EncodeBinary: stringTypeEncodeBinary,
	DecodeBinary: stringTypeDecodeBinary,
	IsTrue:       func(v Value) bool { return len(*(*string)(v.Ptr)) > 0 },
	IsIterable:   ConstHook(true),
	Iterator:     stringTypeIterator,
	Equal:        stringTypeEqual,
	Len:          func(v Value) int64 { return int64(len(*(*string)(v.Ptr))) },
	BinaryOp:     stringTypeBinaryOp,
	MethodCall:   stringTypeMethodCall,
	Access:       stringTypeAccess,
	Contains:     stringTypeContains,
	Slice:        stringTypeSlice,
	SliceStep:    stringTypeSliceStep,
	AsBool:       func(v Value) (bool, bool) { return conv.ParseBool(*(*string)(v.Ptr)) },
	AsInt:        stringTypeAsInt,
	AsByte:       stringTypeAsByte,
	AsFloat:      stringTypeAsFloat,
	AsDecimal:    stringTypeAsDecimal,
	AsTime:       stringTypeAsTime,
	AsString:     func(v Value) (string, bool) { return *(*string)(v.Ptr), true },
	AsRunes:      func(v Value) ([]rune, bool) { return []rune(*(*string)(v.Ptr)), true },
	AsBytes:      func(v Value) ([]byte, bool) { return []byte(*(*string)(v.Ptr)), true },
	AsArray:      stringTypeAsArray,
	IsMethodPure: func(string) bool { return true },
}

var TypeTime = ValueTypeDescr{
	Name:         ConstHook(timeTypeName),
	String:       timeTypeString,
	Format:       timeTypeFormat,
	Interface:    timeTypeInterface,
	EncodeJSON:   timeTypeEncodeJSON,
	EncodeBinary: timeTypeEncodeBinary,
	DecodeBinary: timeTypeDecodeBinary,
	IsTrue:       timeTypeIsTrue,
	Equal:        timeTypeEqual,
	Len:          ConstHook(int64(1)),
	BinaryOp:     timeTypeBinaryOp,
	MethodCall:   timeTypeMethodCall,
	AsString:     timeTypeAsString,
	AsInt:        timeTypeAsInt,
	AsBool:       timeTypeAsBool,
	AsTime:       timeTypeAsTime,
	IsMethodPure: timeTypeIsMethodPure,
}

var TypeUndefined = ValueTypeDescr{
	Name:         ConstHook(undefinedTypeName),
	Interface:    func(Value) any { return nil },
	String:       func(Value) string { return undefinedTypeName },
	Format:       undefinedTypeFormat,
	EncodeJSON:   func(Value) ([]byte, error) { return []byte("null"), nil },
	EncodeBinary: func(Value) ([]byte, error) { return []byte{}, nil },
	DecodeBinary: func(v *Value, _ []byte) error { *v = Undefined; return nil },
	IsTrue:       ConstHook(false),
	IsIterable:   ConstHook(true),
	Equal:        func(v Value, r Value) bool { return v.Type == r.Type },
	MethodCall:   undefinedTypeMethodCall,
	Access:       func(Value, Value, bc.Opcode) (Value, error) { return Undefined, nil },
	AsBool:       func(Value) (bool, bool) { return false, true },
	IsMethodPure: func(string) bool { return true },
}

var TypeValuePtr = ValueTypeDescr{
	Name: func(v Value) string { return fmt.Sprintf("<%s:%s>", valuePtrTypeName, v.TypeName()) },
}

var ValueTypes [256]ValueTypeDescr