D3vugu-components/page-colors_vgen.go

package main

// Code generated by vugu via vugugen. Please regenerate instead of editing or add additional code in a separate file. DO NOT EDIT.

import "fmt"
import "reflect"
import "github.com/vugu/vjson"
import "github.com/vugu/vugu"
import js "github.com/vugu/vugu/js"

import (
	"git.d3nexus.de/Dadido3/D3vugu-components/components/input"
	"git.d3nexus.de/Dadido3/D3vugu-components/components/layout"
	"git.d3nexus.de/Dadido3/D3vugu-components/components/view"
	"git.d3nexus.de/Dadido3/D3vugu-components/icons"
)

type PageColors struct{}

func (c *PageColors) Build(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {

	vgout = &vugu.BuildOut{}

	var vgiterkey interface{}
	_ = vgiterkey
	var vgn *vugu.VGNode
	vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute(nil)}
	vgout.Out = append(vgout.Out, vgn)	// root for output
	{
		vgparent := vgn
		_ = vgparent
		vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t"}
		vgparent.AppendChild(vgn)
		{
			vgcompKey := vugu.MakeCompKey(0x971FB99BFC49A0A9^vgin.CurrentPositionHash(), vgiterkey)
			// ask BuildEnv for prior instance of this specific component
			vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*layout.Container)
			if vgcomp == nil {
				// create new one if needed
				vgcomp = new(layout.Container)
				vgin.BuildEnv.WireComponent(vgcomp)
			}
			vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
			vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
				vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
				vgout = &vugu.BuildOut{}
				vgout.Out = append(vgout.Out, vgn)
				vgparent := vgn
				_ = vgparent

				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "h2", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Signal colors"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "p", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Colors can be set via special color classes:"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "ul", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x58C38B75AA03AA2E^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-layer-0"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: " This is the default color scheme."}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x80935F5D48DA9F6F^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-layer-1"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x3D2E77D1AA05141^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-layer-2"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x7590A8285D972FC0^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-accent"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x9FA0389941803E7E^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-success"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x5DE60228BFA6DC05^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-success-faded"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x81E6C783DCB222D^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-attention"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0xEBA4FA16CD695FAC^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-attention-faded"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0xD1F22BE520A4D2F1^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-caution"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0xF4C97B100AC05156^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-caution-faded"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x2D43E866AD32186A^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-critical"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "li", Attr: []vugu.VGAttribute(nil)}
					vgparent.AppendChild(vgn)
					{
						vgparent := vgn
						_ = vgparent
						{
							vgcompKey := vugu.MakeCompKey(0x3685F67B1DFF3548^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(view.CodeInline)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-critical-faded"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "h2", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Buttons"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				{
					vgcompKey := vugu.MakeCompKey(0x3E3BBC1D6D9BB70B^vgin.CurrentPositionHash(), vgiterkey)
					// ask BuildEnv for prior instance of this specific component
					vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Code)
					if vgcomp == nil {
						// create new one if needed
						vgcomp = new(view.Code)
						vgin.BuildEnv.WireComponent(vgcomp)
					}
					vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
					vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
						vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
						vgout = &vugu.BuildOut{}
						vgout.Out = append(vgout.Out, vgn)
						vgparent := vgn
						_ = vgparent

						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "pre", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "style", Val: "margin: 0;"}}}
						vgparent.AppendChild(vgn)
						vgn.SetInnerHTML("<input:Button class=\"d3c-color-success\">\n" +
							"	<vg-slot name=\"SymbolSlot\"><icons:LPlus></icons:LPlus></vg-slot>\n" +
							"	<vg-slot name=\"DefaultSlot\">Successful action</vg-slot>\n" +
							"</input:Button>")
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
						vgparent.AppendChild(vgn)
						return
					})
					vgout.Components = append(vgout.Components, vgcomp)
					vgn = &vugu.VGNode{Component: vgcomp}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "class", Val: "flex-container"}}}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x91799A6A8DB835DC^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-success"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0x97759048726CA018^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LPlus)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LPlus)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Successful action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x4D56D72CFA7DA1E8^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-attention"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0x6A57C808E44AFC32^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LGlobe)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LGlobe)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Highlighted action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xD9371741E9BC60EA^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-caution"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0xAFCD2F9B58831CA8^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LInfoCircle)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LInfoCircle)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Press with caution"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xDC6B84DB1A33BBC1^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-critical"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0xFDACB4A397260016^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LWarning)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LWarning)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Dangerous action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "class", Val: "flex-container"}}}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x82BB143FBA0084FD^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-success-faded"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0x2723A1A51826F7EC^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LPlus)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LPlus)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Successful action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xB2E2141C5B44A686^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-attention-faded"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0x8C2F2BF99DA97266^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LGlobe)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LGlobe)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Highlighted action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xBEF82AEE9691EC62^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-caution-faded"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0xB22C5A6E93C7AC9^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LInfoCircle)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LInfoCircle)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Press with caution"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x7777775ABAD873ED^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(input.Button)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-critical-faded"
						vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							{
								vgcompKey := vugu.MakeCompKey(0x7B260ACC53894132^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LWarning)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(icons.LWarning)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							return
						})
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Dangerous action"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "h2", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Tags"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				{
					vgcompKey := vugu.MakeCompKey(0x4DC92E263044DAE8^vgin.CurrentPositionHash(), vgiterkey)
					// ask BuildEnv for prior instance of this specific component
					vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Code)
					if vgcomp == nil {
						// create new one if needed
						vgcomp = new(view.Code)
						vgin.BuildEnv.WireComponent(vgcomp)
					}
					vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
					vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
						vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
						vgout = &vugu.BuildOut{}
						vgout.Out = append(vgout.Out, vgn)
						vgparent := vgn
						_ = vgparent

						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "pre", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "style", Val: "margin: 0;"}}}
						vgparent.AppendChild(vgn)
						vgn.SetInnerHTML("<view:Tag class=\"d3c-color-success\">This was a success</view:Tag>")
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
						vgparent.AppendChild(vgn)
						return
					})
					vgout.Components = append(vgout.Components, vgcomp)
					vgn = &vugu.VGNode{Component: vgcomp}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "class", Val: "flex-container"}}}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x7ABED0BEBB4F3507^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-success"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "This was a success"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x7FB38A1B68264079^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-attention"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Attention needed"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x3E84183B936EC50^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-caution"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Warning"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x9BAAC9A57DA23367^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-critical"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Something went wrong"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "class", Val: "flex-container"}}}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xC5C7948756B12907^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-success-faded"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "This was a success"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xE34866DB9327CD67^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-attention-faded"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Attention needed"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xE1691A8454F38F13^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-caution-faded"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Warning"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xABD3B5B69EB87EB6^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Tag)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.Tag)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-critical-faded"
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Something went wrong"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "h2", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Icons"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "p", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Icons will use the text color by default, if you need to change their stroke/fill coloring, use the "}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x9C302FDE8EE7681^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(view.CodeInline)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
							vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
							vgout = &vugu.BuildOut{}
							vgout.Out = append(vgout.Out, vgn)
							vgparent := vgn
							_ = vgparent

							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-icon-use-color"}
							vgparent.AppendChild(vgn)
							return
						})
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: " class."}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				{
					vgcompKey := vugu.MakeCompKey(0x2D6DA5E326EE8AC9^vgin.CurrentPositionHash(), vgiterkey)
					// ask BuildEnv for prior instance of this specific component
					vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.Code)
					if vgcomp == nil {
						// create new one if needed
						vgcomp = new(view.Code)
						vgin.BuildEnv.WireComponent(vgcomp)
					}
					vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
					vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
						vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
						vgout = &vugu.BuildOut{}
						vgout.Out = append(vgout.Out, vgn)
						vgparent := vgn
						_ = vgparent

						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "pre", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "style", Val: "margin: 0;"}}}
						vgparent.AppendChild(vgn)
						vgn.SetInnerHTML("<icons:LInfoCircle class=\"d3c-color-attention d3c-icon-use-color\"></icons:LInfoCircle>")
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
						vgparent.AppendChild(vgn)
						return
					})
					vgout.Components = append(vgout.Components, vgcomp)
					vgn = &vugu.VGNode{Component: vgcomp}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "div", Attr: []vugu.VGAttribute{vugu.VGAttribute{Namespace: "", Key: "class", Val: "flex-container"}, vugu.VGAttribute{Namespace: "", Key: "style", Val: "font-size: 2em;"}}}
				vgparent.AppendChild(vgn)
				{
					vgparent := vgn
					_ = vgparent
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0xA6E519A5CDC25E68^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LInfoCircle)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(icons.LInfoCircle)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-attention d3c-icon-use-color"
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
					vgparent.AppendChild(vgn)
					{
						vgcompKey := vugu.MakeCompKey(0x32DB6F58BFDFE6FD^vgin.CurrentPositionHash(), vgiterkey)
						// ask BuildEnv for prior instance of this specific component
						vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LWarning)
						if vgcomp == nil {
							// create new one if needed
							vgcomp = new(icons.LWarning)
							vgin.BuildEnv.WireComponent(vgcomp)
						}
						vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
						vgcomp.AttrMap = make(map[string]interface{}, 8)
						vgcomp.AttrMap["class"] = "d3c-color-critical d3c-icon-use-color"
						vgout.Components = append(vgout.Components, vgcomp)
						vgn = &vugu.VGNode{Component: vgcomp}
						vgparent.AppendChild(vgn)
					}
					vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\n\t\t"}
				vgparent.AppendChild(vgn)
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "h2", Attr: []vugu.VGAttribute(nil)}
				vgparent.AppendChild(vgn)
				vgn.SetInnerHTML(vugu.HTML("Containers"))
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				{
					vgcompKey := vugu.MakeCompKey(0x80A6F9D5787BE518^vgin.CurrentPositionHash(), vgiterkey)
					// ask BuildEnv for prior instance of this specific component
					vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*layout.LayerContainer)
					if vgcomp == nil {
						// create new one if needed
						vgcomp = new(layout.LayerContainer)
						vgin.BuildEnv.WireComponent(vgcomp)
					}
					vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
					vgcomp.AttrMap = make(map[string]interface{}, 8)
					vgcomp.AttrMap["class"] = "d3c-color-layer-1"
					vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
						vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
						vgout = &vugu.BuildOut{}
						vgout.Out = append(vgout.Out, vgn)
						vgparent := vgn
						_ = vgparent

						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "span", Attr: []vugu.VGAttribute(nil)}
						vgparent.AppendChild(vgn)
						{
							vgparent := vgn
							_ = vgparent
							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "This container uses the "}
							vgparent.AppendChild(vgn)
							{
								vgcompKey := vugu.MakeCompKey(0x7793B4B81AE55595^vgin.CurrentPositionHash(), vgiterkey)
								// ask BuildEnv for prior instance of this specific component
								vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*view.CodeInline)
								if vgcomp == nil {
									// create new one if needed
									vgcomp = new(view.CodeInline)
									vgin.BuildEnv.WireComponent(vgcomp)
								}
								vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
								vgcomp.AttrMap = make(map[string]interface{}, 8)
								vgcomp.AttrMap["class"] = "d3c-color-layer-2"
								vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
									vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
									vgout = &vugu.BuildOut{}
									vgout.Out = append(vgout.Out, vgn)
									vgparent := vgn
									_ = vgparent

									vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "d3c-color-layer-1"}
									vgparent.AppendChild(vgn)
									return
								})
								vgout.Components = append(vgout.Components, vgcomp)
								vgn = &vugu.VGNode{Component: vgcomp}
								vgparent.AppendChild(vgn)
							}
							vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: " class. All child elements inherit the color scheme."}
							vgparent.AppendChild(vgn)
						}
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						{
							vgcompKey := vugu.MakeCompKey(0x35407C776AEDFA2^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(input.Button)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								{
									vgcompKey := vugu.MakeCompKey(0x170C1E72F015DBBE^vgin.CurrentPositionHash(), vgiterkey)
									// ask BuildEnv for prior instance of this specific component
									vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LPlus)
									if vgcomp == nil {
										// create new one if needed
										vgcomp = new(icons.LPlus)
										vgin.BuildEnv.WireComponent(vgcomp)
									}
									vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
									vgout.Components = append(vgout.Components, vgcomp)
									vgn = &vugu.VGNode{Component: vgcomp}
									vgparent.AppendChild(vgn)
								}
								return
							})
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Does inherit color"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						{
							vgcompKey := vugu.MakeCompKey(0xAF0BB57570FA91AF^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*input.Button)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(input.Button)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgcomp.AttrMap = make(map[string]interface{}, 8)
							vgcomp.AttrMap["class"] = "d3c-color-layer-0"
							vgcomp.SymbolSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								{
									vgcompKey := vugu.MakeCompKey(0x66385E7ADD163FB1^vgin.CurrentPositionHash(), vgiterkey)
									// ask BuildEnv for prior instance of this specific component
									vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LPlus)
									if vgcomp == nil {
										// create new one if needed
										vgcomp = new(icons.LPlus)
										vgin.BuildEnv.WireComponent(vgcomp)
									}
									vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
									vgout.Components = append(vgout.Components, vgcomp)
									vgn = &vugu.VGNode{Component: vgcomp}
									vgparent.AppendChild(vgn)
								}
								return
							})
							vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
								vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
								vgout = &vugu.BuildOut{}
								vgout.Out = append(vgout.Out, vgn)
								vgparent := vgn
								_ = vgparent

								vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "Doesn't inherit color"}
								vgparent.AppendChild(vgn)
								return
							})
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
						vgparent.AppendChild(vgn)
						return
					})
					vgout.Components = append(vgout.Components, vgcomp)
					vgn = &vugu.VGNode{Component: vgcomp}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
				vgparent.AppendChild(vgn)
				{
					vgcompKey := vugu.MakeCompKey(0x92E6E708166BE47E^vgin.CurrentPositionHash(), vgiterkey)
					// ask BuildEnv for prior instance of this specific component
					vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*layout.LayerContainer)
					if vgcomp == nil {
						// create new one if needed
						vgcomp = new(layout.LayerContainer)
						vgin.BuildEnv.WireComponent(vgcomp)
					}
					vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
					vgcomp.AttrMap = make(map[string]interface{}, 8)
					vgcomp.AttrMap["class"] = "d3c-color-critical-faded"
					vgcomp.DefaultSlot = vugu.NewBuilderFunc(func(vgin *vugu.BuildIn) (vgout *vugu.BuildOut) {
						vgn := &vugu.VGNode{Type: vugu.VGNodeType(3)}
						vgout = &vugu.BuildOut{}
						vgout.Out = append(vgout.Out, vgn)
						vgparent := vgn
						_ = vgparent

						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t\t"}
						vgparent.AppendChild(vgn)
						{
							vgcompKey := vugu.MakeCompKey(0xFB49BCCB77EF69A0^vgin.CurrentPositionHash(), vgiterkey)
							// ask BuildEnv for prior instance of this specific component
							vgcomp, _ := vgin.BuildEnv.CachedComponent(vgcompKey).(*icons.LWarning)
							if vgcomp == nil {
								// create new one if needed
								vgcomp = new(icons.LWarning)
								vgin.BuildEnv.WireComponent(vgcomp)
							}
							vgin.BuildEnv.UseComponent(vgcompKey, vgcomp)	// ensure we can use this in the cache next time around
							vgout.Components = append(vgout.Components, vgcomp)
							vgn = &vugu.VGNode{Component: vgcomp}
							vgparent.AppendChild(vgn)
						}
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: " "}
						vgparent.AppendChild(vgn)
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Namespace: "", Data: "span", Attr: []vugu.VGAttribute(nil)}
						vgparent.AppendChild(vgn)
						vgn.SetInnerHTML(vugu.HTML("Something bad happened!"))
						vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t\t"}
						vgparent.AppendChild(vgn)
						return
					})
					vgout.Components = append(vgout.Components, vgcomp)
					vgn = &vugu.VGNode{Component: vgcomp}
					vgparent.AppendChild(vgn)
				}
				vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t"}
				vgparent.AppendChild(vgn)
				return
			})
			vgout.Components = append(vgout.Components, vgcomp)
			vgn = &vugu.VGNode{Component: vgcomp}
			vgparent.AppendChild(vgn)
		}
		vgn = &vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n"}
		vgparent.AppendChild(vgn)
	}
	vgn = &vugu.VGNode{Type: vugu.VGNodeType(3), Data: "style", Attr: []vugu.VGAttribute(nil)}
	{
		vgn.AppendChild(&vugu.VGNode{Type: vugu.VGNodeType(1), Data: "\n\t.flex-container {\n\t\tmargin: 0.5em 0;\n\t\tdisplay: flex;\n\t\tflex-wrap: wrap;\n\t\tgap: 0.5em;\n\t}\n\n\t.flex-container > * {\n\t\tmargin: 0;\n\t}\n", Attr: []vugu.VGAttribute(nil)})
	}
	vgout.AppendCSS(vgn)
	return vgout
}

// 'fix' unused imports
var _ fmt.Stringer
var _ reflect.Type
var _ vjson.RawMessage
var _ js.Value