func (_this *IntrinsicSizes) MaxContentSize() float64 {
	var ret float64
	value := _this.Value_JS.Get("maxContentSize")
	ret = (value).Float()
	return ret
}
MaxContentSize returning attribute 'maxContentSize' with
type float64 (idl: double).
package layout
import js "github.com/gowebapi/webapi/core/js"
import (
	"github.com/gowebapi/webapi/css/typedom"
	"github.com/gowebapi/webapi/javascript"
	"github.com/gowebapi/webapi/webidl"
	"github.com/gowebapi/webapi/worklets"
)
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 BlockFragmentationType int
const (
	NoneBlockFragmentationType BlockFragmentationType = iota
	PageBlockFragmentationType
	ColumnBlockFragmentationType
	RegionBlockFragmentationType
)
var blockFragmentationTypeToWasmTable = []string{
	"none", "page", "column", "region",
}
var blockFragmentationTypeFromWasmTable = map[string]BlockFragmentationType{
	"none": NoneBlockFragmentationType, "page": PageBlockFragmentationType, "column": ColumnBlockFragmentationType, "region": RegionBlockFragmentationType,
}
func (this *BlockFragmentationType) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this BlockFragmentationType) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(blockFragmentationTypeToWasmTable) {
		return blockFragmentationTypeToWasmTable[idx]
	}
	panic("unknown input value")
}
func BlockFragmentationTypeFromJS(value js.Value) BlockFragmentationType {
	key := value.String()
	conv, ok := blockFragmentationTypeFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type BreakType int
const (
	NoneBreakType BreakType = iota
	LineBreakType
	ColumnBreakType
	PageBreakType
	RegionBreakType
)
var breakTypeToWasmTable = []string{
	"none", "line", "column", "page", "region",
}
var breakTypeFromWasmTable = map[string]BreakType{
	"none": NoneBreakType, "line": LineBreakType, "column": ColumnBreakType, "page": PageBreakType, "region": RegionBreakType,
}
func (this *BreakType) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this BreakType) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(breakTypeToWasmTable) {
		return breakTypeToWasmTable[idx]
	}
	panic("unknown input value")
}
func BreakTypeFromJS(value js.Value) BreakType {
	key := value.String()
	conv, ok := breakTypeFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type ChildDisplayType int
const (
	BlockChildDisplayType ChildDisplayType = iota
	NormalChildDisplayType
)
var childDisplayTypeToWasmTable = []string{
	"block", "normal",
}
var childDisplayTypeFromWasmTable = map[string]ChildDisplayType{
	"block": BlockChildDisplayType, "normal": NormalChildDisplayType,
}
func (this *ChildDisplayType) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this ChildDisplayType) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(childDisplayTypeToWasmTable) {
		return childDisplayTypeToWasmTable[idx]
	}
	panic("unknown input value")
}
func ChildDisplayTypeFromJS(value js.Value) ChildDisplayType {
	key := value.String()
	conv, ok := childDisplayTypeFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type LayoutSizingMode int
const (
	BlockLikeLayoutSizingMode LayoutSizingMode = iota
	ManualLayoutSizingMode
)
var layoutSizingModeToWasmTable = []string{
	"block-like", "manual",
}
var layoutSizingModeFromWasmTable = map[string]LayoutSizingMode{
	"block-like": BlockLikeLayoutSizingMode, "manual": ManualLayoutSizingMode,
}
func (this *LayoutSizingMode) JSValue() js.Value {
	return js.ValueOf(this.Value())
}
func (this LayoutSizingMode) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(layoutSizingModeToWasmTable) {
		return layoutSizingModeToWasmTable[idx]
	}
	panic("unknown input value")
}
func LayoutSizingModeFromJS(value js.Value) LayoutSizingMode {
	key := value.String()
	conv, ok := layoutSizingModeFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}
type PromiseIntrinsicSizesOnFulfilledFunc func(value *IntrinsicSizes)
type PromiseIntrinsicSizesOnFulfilled js.Func
func PromiseIntrinsicSizesOnFulfilledToJS(callback PromiseIntrinsicSizesOnFulfilledFunc) *PromiseIntrinsicSizesOnFulfilled {
	if callback == nil {
		return nil
	}
	ret := PromiseIntrinsicSizesOnFulfilled(js.FuncOf(func(this js.Value, args []js.Value) interface{} {
		var (
			_p0 *IntrinsicSizes  
		)
		_p0 = IntrinsicSizesFromJS(args[0])
		callback(_p0)
		return nil
	}))
	return &ret
}
func PromiseIntrinsicSizesOnFulfilledFromJS(_value js.Value) PromiseIntrinsicSizesOnFulfilledFunc {
	return func(value *IntrinsicSizes) {
		var (
			_args [1]interface{}
			_end  int
		)
		_p0 := value.JSValue()
		_args[0] = _p0
		_end++
		_value.Invoke(_args[0:_end]...)
		return
	}
}
type PromiseIntrinsicSizesOnRejectedFunc func(reason js.Value)
type PromiseIntrinsicSizesOnRejected js.Func
func PromiseIntrinsicSizesOnRejectedToJS(callback PromiseIntrinsicSizesOnRejectedFunc) *PromiseIntrinsicSizesOnRejected {
	if callback == nil {
		return nil
	}
	ret := PromiseIntrinsicSizesOnRejected(js.FuncOf(func(this js.Value, args []js.Value) interface{} {
		var (
			_p0 js.Value  
		)
		_p0 = args[0]
		callback(_p0)
		return nil
	}))
	return &ret
}
func PromiseIntrinsicSizesOnRejectedFromJS(_value js.Value) PromiseIntrinsicSizesOnRejectedFunc {
	return func(reason js.Value) {
		var (
			_args [1]interface{}
			_end  int
		)
		_p0 := reason
		_args[0] = _p0
		_end++
		_value.Invoke(_args[0:_end]...)
		return
	}
}
type PromiseLayoutFragmentOnFulfilledFunc func(value *LayoutFragment)
type PromiseLayoutFragmentOnFulfilled js.Func
func PromiseLayoutFragmentOnFulfilledToJS(callback PromiseLayoutFragmentOnFulfilledFunc) *PromiseLayoutFragmentOnFulfilled {
	if callback == nil {
		return nil
	}
	ret := PromiseLayoutFragmentOnFulfilled(js.FuncOf(func(this js.Value, args []js.Value) interface{} {
		var (
			_p0 *LayoutFragment  
		)
		_p0 = LayoutFragmentFromJS(args[0])
		callback(_p0)
		return nil
	}))
	return &ret
}
func PromiseLayoutFragmentOnFulfilledFromJS(_value js.Value) PromiseLayoutFragmentOnFulfilledFunc {
	return func(value *LayoutFragment) {
		var (
			_args [1]interface{}
			_end  int
		)
		_p0 := value.JSValue()
		_args[0] = _p0
		_end++
		_value.Invoke(_args[0:_end]...)
		return
	}
}
type PromiseLayoutFragmentOnRejectedFunc func(reason js.Value)
type PromiseLayoutFragmentOnRejected js.Func
func PromiseLayoutFragmentOnRejectedToJS(callback PromiseLayoutFragmentOnRejectedFunc) *PromiseLayoutFragmentOnRejected {
	if callback == nil {
		return nil
	}
	ret := PromiseLayoutFragmentOnRejected(js.FuncOf(func(this js.Value, args []js.Value) interface{} {
		var (
			_p0 js.Value  
		)
		_p0 = args[0]
		callback(_p0)
		return nil
	}))
	return &ret
}
func PromiseLayoutFragmentOnRejectedFromJS(_value js.Value) PromiseLayoutFragmentOnRejectedFunc {
	return func(reason js.Value) {
		var (
			_args [1]interface{}
			_end  int
		)
		_p0 := reason
		_args[0] = _p0
		_end++
		_value.Invoke(_args[0:_end]...)
		return
	}
}
type BreakTokenOptions struct {
	ChildBreakTokens []*ChildBreakToken
	Data             js.Value
}
func (_this *BreakTokenOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := js.Global().Get("Array").New(len(_this.ChildBreakTokens))
	for __idx0, __seq_in0 := range _this.ChildBreakTokens {
		__seq_out0 := __seq_in0.JSValue()
		value0.SetIndex(__idx0, __seq_out0)
	}
	out.Set("childBreakTokens", value0)
	value1 := _this.Data
	out.Set("data", value1)
	return out
}
func BreakTokenOptionsFromJS(value js.Wrapper) *BreakTokenOptions {
	input := value.JSValue()
	var out BreakTokenOptions
	var (
		value0 []*ChildBreakToken  
		value1 js.Value            
	)
	__length0 := input.Get("childBreakTokens").Length()
	__array0 := make([]*ChildBreakToken, __length0, __length0)
	for __idx0 := 0; __idx0 < __length0; __idx0++ {
		var __seq_out0 *ChildBreakToken
		__seq_in0 := input.Get("childBreakTokens").Index(__idx0)
		__seq_out0 = ChildBreakTokenFromJS(__seq_in0)
		__array0[__idx0] = __seq_out0
	}
	value0 = __array0
	out.ChildBreakTokens = value0
	value1 = input.Get("data")
	out.Data = value1
	return &out
}
type FragmentResultOptions struct {
	InlineSize     float64
	BlockSize      float64
	AutoBlockSize  float64
	ChildFragments []*LayoutFragment
	Data           js.Value
	BreakToken     *BreakTokenOptions
}
func (_this *FragmentResultOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.InlineSize
	out.Set("inlineSize", value0)
	value1 := _this.BlockSize
	out.Set("blockSize", value1)
	value2 := _this.AutoBlockSize
	out.Set("autoBlockSize", value2)
	value3 := js.Global().Get("Array").New(len(_this.ChildFragments))
	for __idx3, __seq_in3 := range _this.ChildFragments {
		__seq_out3 := __seq_in3.JSValue()
		value3.SetIndex(__idx3, __seq_out3)
	}
	out.Set("childFragments", value3)
	value4 := _this.Data
	out.Set("data", value4)
	value5 := _this.BreakToken.JSValue()
	out.Set("breakToken", value5)
	return out
}
func FragmentResultOptionsFromJS(value js.Wrapper) *FragmentResultOptions {
	input := value.JSValue()
	var out FragmentResultOptions
	var (
		value0 float64             
		value1 float64             
		value2 float64             
		value3 []*LayoutFragment   
		value4 js.Value            
		value5 *BreakTokenOptions  
	)
	value0 = (input.Get("inlineSize")).Float()
	out.InlineSize = value0
	value1 = (input.Get("blockSize")).Float()
	out.BlockSize = value1
	value2 = (input.Get("autoBlockSize")).Float()
	out.AutoBlockSize = value2
	__length3 := input.Get("childFragments").Length()
	__array3 := make([]*LayoutFragment, __length3, __length3)
	for __idx3 := 0; __idx3 < __length3; __idx3++ {
		var __seq_out3 *LayoutFragment
		__seq_in3 := input.Get("childFragments").Index(__idx3)
		__seq_out3 = LayoutFragmentFromJS(__seq_in3)
		__array3[__idx3] = __seq_out3
	}
	value3 = __array3
	out.ChildFragments = value3
	value4 = input.Get("data")
	out.Data = value4
	value5 = BreakTokenOptionsFromJS(input.Get("breakToken"))
	out.BreakToken = value5
	return &out
}
type IntrinsicSizesResultOptions struct {
	MaxContentSize float64
	MinContentSize float64
}
func (_this *IntrinsicSizesResultOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.MaxContentSize
	out.Set("maxContentSize", value0)
	value1 := _this.MinContentSize
	out.Set("minContentSize", value1)
	return out
}
func IntrinsicSizesResultOptionsFromJS(value js.Wrapper) *IntrinsicSizesResultOptions {
	input := value.JSValue()
	var out IntrinsicSizesResultOptions
	var (
		value0 float64  
		value1 float64  
	)
	value0 = (input.Get("maxContentSize")).Float()
	out.MaxContentSize = value0
	value1 = (input.Get("minContentSize")).Float()
	out.MinContentSize = value1
	return &out
}
type LayoutConstraintsOptions struct {
	AvailableInlineSize      float64
	AvailableBlockSize       float64
	FixedInlineSize          float64
	FixedBlockSize           float64
	PercentageInlineSize     float64
	PercentageBlockSize      float64
	BlockFragmentationOffset float64
	BlockFragmentationType   BlockFragmentationType
	Data                     js.Value
}
func (_this *LayoutConstraintsOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.AvailableInlineSize
	out.Set("availableInlineSize", value0)
	value1 := _this.AvailableBlockSize
	out.Set("availableBlockSize", value1)
	value2 := _this.FixedInlineSize
	out.Set("fixedInlineSize", value2)
	value3 := _this.FixedBlockSize
	out.Set("fixedBlockSize", value3)
	value4 := _this.PercentageInlineSize
	out.Set("percentageInlineSize", value4)
	value5 := _this.PercentageBlockSize
	out.Set("percentageBlockSize", value5)
	value6 := _this.BlockFragmentationOffset
	out.Set("blockFragmentationOffset", value6)
	value7 := _this.BlockFragmentationType.JSValue()
	out.Set("blockFragmentationType", value7)
	value8 := _this.Data
	out.Set("data", value8)
	return out
}
func LayoutConstraintsOptionsFromJS(value js.Wrapper) *LayoutConstraintsOptions {
	input := value.JSValue()
	var out LayoutConstraintsOptions
	var (
		value0 float64                 
		value1 float64                 
		value2 float64                 
		value3 float64                 
		value4 float64                 
		value5 float64                 
		value6 float64                 
		value7 BlockFragmentationType  
		value8 js.Value                
	)
	value0 = (input.Get("availableInlineSize")).Float()
	out.AvailableInlineSize = value0
	value1 = (input.Get("availableBlockSize")).Float()
	out.AvailableBlockSize = value1
	value2 = (input.Get("fixedInlineSize")).Float()
	out.FixedInlineSize = value2
	value3 = (input.Get("fixedBlockSize")).Float()
	out.FixedBlockSize = value3
	value4 = (input.Get("percentageInlineSize")).Float()
	out.PercentageInlineSize = value4
	value5 = (input.Get("percentageBlockSize")).Float()
	out.PercentageBlockSize = value5
	value6 = (input.Get("blockFragmentationOffset")).Float()
	out.BlockFragmentationOffset = value6
	value7 = BlockFragmentationTypeFromJS(input.Get("blockFragmentationType"))
	out.BlockFragmentationType = value7
	value8 = input.Get("data")
	out.Data = value8
	return &out
}
type LayoutOptions struct {
	ChildDisplay ChildDisplayType
	Sizing       LayoutSizingMode
}
func (_this *LayoutOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.ChildDisplay.JSValue()
	out.Set("childDisplay", value0)
	value1 := _this.Sizing.JSValue()
	out.Set("sizing", value1)
	return out
}
func LayoutOptionsFromJS(value js.Wrapper) *LayoutOptions {
	input := value.JSValue()
	var out LayoutOptions
	var (
		value0 ChildDisplayType  
		value1 LayoutSizingMode  
	)
	value0 = ChildDisplayTypeFromJS(input.Get("childDisplay"))
	out.ChildDisplay = value0
	value1 = LayoutSizingModeFromJS(input.Get("sizing"))
	out.Sizing = value1
	return &out
}
type BreakToken struct {
	Value_JS js.Value
}
func (_this *BreakToken) JSValue() js.Value {
	return _this.Value_JS
}
func BreakTokenFromJS(value js.Wrapper) *BreakToken {
	input := value.JSValue()
	if typ := input.Type(); typ == js.TypeNull || typ == js.TypeUndefined {
		return nil
	}
	ret := &BreakToken{}
	ret.Value_JS = input
	return ret
}
func (_this *BreakToken) ChildBreakTokens() *javascript.FrozenArray {
	var ret *javascript.FrozenArray
	value := _this.Value_JS.Get("childBreakTokens")
	ret = javascript.FrozenArrayFromJS(value)
	return ret
}
func (_this *BreakToken) Data() js.Value {
	var ret js.Value
	value := _this.Value_JS.Get("data")
	ret = value
	return ret
}
type ChildBreakToken struct {
	Value_JS js.Value
}
func (_this *ChildBreakToken) JSValue() js.Value {
	return _this.Value_JS
}
func ChildBreakTokenFromJS(value js.Wrapper) *ChildBreakToken {
	input := value.JSValue()
	if typ := input.Type(); typ == js.TypeNull || typ == js.TypeUndefined {
		return nil
	}
	ret := &ChildBreakToken{}
	ret.Value_JS = input
	return ret
}
func (_this *ChildBreakToken) BreakType() BreakType {
	var ret BreakType
	value := _this.Value_JS.Get("breakType")
	ret = BreakTypeFromJS(value)
	return ret
}
func (_this *ChildBreakToken) Child() *LayoutChild {
	var ret *LayoutChild
	value := _this.Value_JS.Get("child")
	ret = LayoutChildFromJS(value)
	return ret
}
type FragmentResult struct {
	Value_JS js.Value
}
func (_this *FragmentResult) JSValue() js.Value {
	return _this.Value_JS
}
func FragmentResultFromJS(value js.Wrapper) *FragmentResult {
	input := value.JSValue()
	if typ := input.Type(); typ == js.TypeNull || typ == js.TypeUndefined {
		return nil
	}
	ret := &FragmentResult{}
	ret.Value_JS = input
	return ret
}
func NewFragmentResult(options *FragmentResultOptions) (_result *FragmentResult) {
	_klass := js.Global().Get("FragmentResult")
	var (
		_args [1]interface{}
		_end  int
	)
	_p0 := options.JSValue()
	_args[0] = _p0
	_end++
	_returned := _klass.New(_args[0:_end]...)
	var (
		_converted *FragmentResult  
	)
	_converted = FragmentResultFromJS(_returned)
	_result = _converted
	return
}
func (_this *FragmentResult) InlineSize() float64 {
	var ret float64
	value := _this.Value_JS.Get("inlineSize")
	ret = (value).Float()
	return ret
}
func (_this *FragmentResult) BlockSize() float64 {
	var ret float64
	value := _this.Value_JS.Get("blockSize")
	ret = (value).Float()
	return ret
}
type IntrinsicSizes struct {
	Value_JS js.Value
}
func (_this *IntrinsicSizes) JSValue() js.Value {
	return _this.Value_JS
}
func IntrinsicSizesFromJS(value js.Wrapper) *IntrinsicSizes {
	input := value.JSValue()
	if typ := input.Type(); typ == js.TypeNull || typ == js.TypeUndefined {
		return nil
	}
	ret := &IntrinsicSizes{}
	ret.Value_JS = input
	return ret
}
func (_this *IntrinsicSizes) MinContentSize() float64 {
	var ret float64
	value := _this.Value_JS.Get("minContentSize")
	ret = (value).Float()
	return ret
}