func (_this *BaseComputedKeyframe) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	var value0 interface{}
	if _this.Offset != nil {
		value0 = *(_this.Offset)
	} else {
		value0 = nil
	}
	out.Set("offset", value0)
	value1 := _this.ComputedOffset
	out.Set("computedOffset", value1)
	value2 := _this.Easing
	out.Set("easing", value2)
	value3 := _this.Composite.JSValue()
	out.Set("composite", value3)
	return out
}
JSValue is allocating a new javasript object and copy
all values
package webani
import "syscall/js"
import (
	"github.com/gowebapi/webapi/dom/domcore"
	"github.com/gowebapi/webapi/javascript"
)
func unused(value interface{}) {
}
type Union struct {
	Value js.Value
}
func (u *Union) JSValue() js.Value {
	return u.Value
}
func UnionFromJS(value js.Value) *Union {
	return &Union{Value: value}
}
type AnimationPlayState int
const (
	IdleAnimationPlayState AnimationPlayState = iota
	RunningAnimationPlayState
	PausedAnimationPlayState
	FinishedAnimationPlayState
)
var animationPlayStateToWasmTable = []string{
	"idle", "running", "paused", "finished",
}
var animationPlayStateFromWasmTable = map[string]AnimationPlayState{
	"idle": IdleAnimationPlayState, "running": RunningAnimationPlayState, "paused": PausedAnimationPlayState, "finished": FinishedAnimationPlayState,
}
func (this *AnimationPlayState) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this AnimationPlayState) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(animationPlayStateToWasmTable) {
		return animationPlayStateToWasmTable[idx]
	}
	panic("unknown input value")
}
func AnimationPlayStateFromJS(value js.Value) AnimationPlayState {
	key := value.String()
	conv, ok := animationPlayStateFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type CompositeOperation int
const (
	ReplaceCompositeOperation CompositeOperation = iota
	AddCompositeOperation
	AccumulateCompositeOperation
)
var compositeOperationToWasmTable = []string{
	"replace", "add", "accumulate",
}
var compositeOperationFromWasmTable = map[string]CompositeOperation{
	"replace": ReplaceCompositeOperation, "add": AddCompositeOperation, "accumulate": AccumulateCompositeOperation,
}
func (this *CompositeOperation) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this CompositeOperation) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(compositeOperationToWasmTable) {
		return compositeOperationToWasmTable[idx]
	}
	panic("unknown input value")
}
func CompositeOperationFromJS(value js.Value) CompositeOperation {
	key := value.String()
	conv, ok := compositeOperationFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type CompositeOperationOrAuto int
const (
	ReplaceCompositeOperationOrAuto CompositeOperationOrAuto = iota
	AddCompositeOperationOrAuto
	AccumulateCompositeOperationOrAuto
	AutoCompositeOperationOrAuto
)
var compositeOperationOrAutoToWasmTable = []string{
	"replace", "add", "accumulate", "auto",
}
var compositeOperationOrAutoFromWasmTable = map[string]CompositeOperationOrAuto{
	"replace": ReplaceCompositeOperationOrAuto, "add": AddCompositeOperationOrAuto, "accumulate": AccumulateCompositeOperationOrAuto, "auto": AutoCompositeOperationOrAuto,
}
func (this *CompositeOperationOrAuto) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this CompositeOperationOrAuto) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(compositeOperationOrAutoToWasmTable) {
		return compositeOperationOrAutoToWasmTable[idx]
	}
	panic("unknown input value")
}
func CompositeOperationOrAutoFromJS(value js.Value) CompositeOperationOrAuto {
	key := value.String()
	conv, ok := compositeOperationOrAutoFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type FillMode int
const (
	NoneFillMode FillMode = iota
	ForwardsFillMode
	BackwardsFillMode
	BothFillMode
	AutoFillMode
)
var fillModeToWasmTable = []string{
	"none", "forwards", "backwards", "both", "auto",
}
var fillModeFromWasmTable = map[string]FillMode{
	"none": NoneFillMode, "forwards": ForwardsFillMode, "backwards": BackwardsFillMode, "both": BothFillMode, "auto": AutoFillMode,
}
func (this *FillMode) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this FillMode) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(fillModeToWasmTable) {
		return fillModeToWasmTable[idx]
	}
	panic("unknown input value")
}
func FillModeFromJS(value js.Value) FillMode {
	key := value.String()
	conv, ok := fillModeFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type IterationCompositeOperation int
const (
	ReplaceIterationCompositeOperation IterationCompositeOperation = iota
	AccumulateIterationCompositeOperation
)
var iterationCompositeOperationToWasmTable = []string{
	"replace", "accumulate",
}
var iterationCompositeOperationFromWasmTable = map[string]IterationCompositeOperation{
	"replace": ReplaceIterationCompositeOperation, "accumulate": AccumulateIterationCompositeOperation,
}
func (this *IterationCompositeOperation) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this IterationCompositeOperation) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(iterationCompositeOperationToWasmTable) {
		return iterationCompositeOperationToWasmTable[idx]
	}
	panic("unknown input value")
}
func IterationCompositeOperationFromJS(value js.Value) IterationCompositeOperation {
	key := value.String()
	conv, ok := iterationCompositeOperationFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type PlaybackDirection int
const (
	NormalPlaybackDirection PlaybackDirection = iota
	ReversePlaybackDirection
	AlternatePlaybackDirection
	AlternateReversePlaybackDirection
)
var playbackDirectionToWasmTable = []string{
	"normal", "reverse", "alternate", "alternate-reverse",
}
var playbackDirectionFromWasmTable = map[string]PlaybackDirection{
	"normal": NormalPlaybackDirection, "reverse": ReversePlaybackDirection, "alternate": AlternatePlaybackDirection, "alternate-reverse": AlternateReversePlaybackDirection,
}
func (this *PlaybackDirection) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this PlaybackDirection) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(playbackDirectionToWasmTable) {
		return playbackDirectionToWasmTable[idx]
	}
	panic("unknown input value")
}
func PlaybackDirectionFromJS(value js.Value) PlaybackDirection {
	key := value.String()
	conv, ok := playbackDirectionFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type AnimationPlaybackEventInit struct {
	Bubbles      bool
	Cancelable   bool
	Composed     bool
	CurrentTime  *float64
	TimelineTime *float64
}
func (_this *AnimationPlaybackEventInit) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.Bubbles
	out.Set("bubbles", value0)
	value1 := _this.Cancelable
	out.Set("cancelable", value1)
	value2 := _this.Composed
	out.Set("composed", value2)
	var value3 interface{}
	if _this.CurrentTime != nil {
		value3 = *(_this.CurrentTime)
	} else {
		value3 = nil
	}
	out.Set("currentTime", value3)
	var value4 interface{}
	if _this.TimelineTime != nil {
		value4 = *(_this.TimelineTime)
	} else {
		value4 = nil
	}
	out.Set("timelineTime", value4)
	return out
}
func AnimationPlaybackEventInitFromJS(value js.Wrapper) *AnimationPlaybackEventInit {
	input := value.JSValue()
	var out AnimationPlaybackEventInit
	var (
		value0 bool      
		value1 bool      
		value2 bool      
		value3 *float64  
		value4 *float64  
	)
	value0 = (input.Get("bubbles")).Bool()
	out.Bubbles = value0
	value1 = (input.Get("cancelable")).Bool()
	out.Cancelable = value1
	value2 = (input.Get("composed")).Bool()
	out.Composed = value2
	if input.Get("currentTime").Type() != js.TypeNull && input.Get("currentTime").Type() != js.TypeUndefined {
		__tmp := (input.Get("currentTime")).Float()
		value3 = &__tmp
	}
	out.CurrentTime = value3
	if input.Get("timelineTime").Type() != js.TypeNull && input.Get("timelineTime").Type() != js.TypeUndefined {
		__tmp := (input.Get("timelineTime")).Float()
		value4 = &__tmp
	}
	out.TimelineTime = value4
	return &out
}
type BaseComputedKeyframe struct {
	Offset         *float64
	ComputedOffset float64
	Easing         string
	Composite      CompositeOperationOrAuto
}