get global namespace packages together

Makefile

@@ -4,5 +4,5 @@ all:
 
 clean:
 	rm *.go
-	rm -rf console/ css/ document/
+	rm -rf console/ css/ document/ window/
 .PHONY: clean

abortcontroller.go

@@ -12,7 +12,7 @@ type AbortController struct {
 	Value
 }
 
-func jsValueToAbortController(val js.Value) AbortController {
+func JSValueToAbortController(val js.Value) AbortController {
 	return AbortController{Value: Value{Value: val}}
 }
 func (v Value) AsAbortController() AbortController { return AbortController{Value: v} }
@@ -21,5 +21,5 @@ func (a AbortController) Abort(args ...interface{}) {
 }
 func (a AbortController) GetSignal() AbortSignal {
 	val := a.Get("signal")
-	return jsValueToAbortSignal(val.JSValue())
+	return JSValueToAbortSignal(val.JSValue())
 }

abortsignal.go

@@ -17,7 +17,7 @@ type AbortSignal struct {
 	EventTarget
 }
 
-func jsValueToAbortSignal(val js.Value) AbortSignal { return AbortSignal{Value: Value{Value: val}} }
+func JSValueToAbortSignal(val js.Value) AbortSignal { return AbortSignal{Value: Value{Value: val}} }
 func (v Value) AsAbortSignal() AbortSignal          { return AbortSignal{Value: v} }
 func (a AbortSignal) GetAborted() bool {
 	val := a.Get("aborted")
@@ -25,7 +25,7 @@ func (a AbortSignal) GetAborted() bool {
 }
 func (a AbortSignal) GetOnabort() EventHandler {
 	val := a.Get("onabort")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a AbortSignal) SetOnabort(val EventHandler) {
 	a.Set("onabort", val)

abstractrange.go

@@ -15,7 +15,7 @@ type AbstractRange struct {
 	Value
 }
 
-func jsValueToAbstractRange(val js.Value) AbstractRange {
+func JSValueToAbstractRange(val js.Value) AbstractRange {
 	return AbstractRange{Value: Value{Value: val}}
 }
 func (v Value) AsAbstractRange() AbstractRange { return AbstractRange{Value: v} }
@@ -25,7 +25,7 @@ func (a AbstractRange) GetCollapsed() bool {
 }
 func (a AbstractRange) GetEndContainer() Node {
 	val := a.Get("endContainer")
-	return jsValueToNode(val.JSValue())
+	return JSValueToNode(val.JSValue())
 }
 func (a AbstractRange) GetEndOffset() float64 {
 	val := a.Get("endOffset")
@@ -33,7 +33,7 @@ func (a AbstractRange) GetEndOffset() float64 {
 }
 func (a AbstractRange) GetStartContainer() Node {
 	val := a.Get("startContainer")
-	return jsValueToNode(val.JSValue())
+	return JSValueToNode(val.JSValue())
 }
 func (a AbstractRange) GetStartOffset() float64 {
 	val := a.Get("startOffset")

applicationcache.go

@@ -34,7 +34,7 @@ type ApplicationCache struct {
 	EventTarget
 }
 
-func jsValueToApplicationCache(val js.Value) ApplicationCache {
+func JSValueToApplicationCache(val js.Value) ApplicationCache {
 	return ApplicationCache{Value: Value{Value: val}}
 }
 func (v Value) AsApplicationCache() ApplicationCache { return ApplicationCache{Value: v} }
@@ -43,56 +43,56 @@ func (a ApplicationCache) Abort(args ...interface{}) {
 }
 func (a ApplicationCache) GetOncached() EventHandler {
 	val := a.Get("oncached")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOncached(val EventHandler) {
 	a.Set("oncached", val)
 }
 func (a ApplicationCache) GetOnchecking() EventHandler {
 	val := a.Get("onchecking")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnchecking(val EventHandler) {
 	a.Set("onchecking", val)
 }
 func (a ApplicationCache) GetOndownloading() EventHandler {
 	val := a.Get("ondownloading")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOndownloading(val EventHandler) {
 	a.Set("ondownloading", val)
 }
 func (a ApplicationCache) GetOnerror() EventHandler {
 	val := a.Get("onerror")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnerror(val EventHandler) {
 	a.Set("onerror", val)
 }
 func (a ApplicationCache) GetOnnoupdate() EventHandler {
 	val := a.Get("onnoupdate")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnnoupdate(val EventHandler) {
 	a.Set("onnoupdate", val)
 }
 func (a ApplicationCache) GetOnobsolete() EventHandler {
 	val := a.Get("onobsolete")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnobsolete(val EventHandler) {
 	a.Set("onobsolete", val)
 }
 func (a ApplicationCache) GetOnprogress() EventHandler {
 	val := a.Get("onprogress")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnprogress(val EventHandler) {
 	a.Set("onprogress", val)
 }
 func (a ApplicationCache) GetOnupdateready() EventHandler {
 	val := a.Get("onupdateready")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a ApplicationCache) SetOnupdateready(val EventHandler) {
 	a.Set("onupdateready", val)

arraybuffer.go

@@ -6,7 +6,7 @@ type ArrayBuffer struct {
 	js.TypedArray
 }
 
-func jsValueToArrayBuffer(val js.Value) ArrayBuffer {
+func JSValueToArrayBuffer(val js.Value) ArrayBuffer {
 	return ArrayBuffer{TypedArray: js.TypedArray{Value: val}}
 }
 func (u ArrayBuffer) JSValue() js.Value { return u.TypedArray.Value }

arraybufferview.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type ArrayBufferView Value
 
-func jsValueToArrayBufferView(val js.Value) ArrayBufferView {
-	return ArrayBufferView(jsValueToValue(val))
+func JSValueToArrayBufferView(val js.Value) ArrayBufferView {
+	return ArrayBufferView(JSValueToValue(val))
 }

attr.go

@@ -54,7 +54,7 @@ type Attr struct {
 	EventTarget
 }
 
-func jsValueToAttr(val js.Value) Attr { return Attr{Value: Value{Value: val}} }
+func JSValueToAttr(val js.Value) Attr { return Attr{Value: Value{Value: val}} }
 func (v Value) AsAttr() Attr          { return Attr{Value: v} }
 func (a Attr) GetLocalName() string {
 	val := a.Get("localName")
@@ -70,7 +70,7 @@ func (a Attr) GetNamespaceURI() string {
 }
 func (a Attr) GetOwnerElement() Element {
 	val := a.Get("ownerElement")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (a Attr) GetPrefix() string {
 	val := a.Get("prefix")

audiotrack.go

@@ -16,7 +16,7 @@ type AudioTrack struct {
 	Value
 }
 
-func jsValueToAudioTrack(val js.Value) AudioTrack { return AudioTrack{Value: Value{Value: val}} }
+func JSValueToAudioTrack(val js.Value) AudioTrack { return AudioTrack{Value: Value{Value: val}} }
 func (v Value) AsAudioTrack() AudioTrack          { return AudioTrack{Value: v} }
 func (a AudioTrack) GetEnabled() bool {
 	val := a.Get("enabled")

audiotracklist.go

@@ -22,13 +22,13 @@ type AudioTrackList struct {
 	EventTarget
 }
 
-func jsValueToAudioTrackList(val js.Value) AudioTrackList {
+func JSValueToAudioTrackList(val js.Value) AudioTrackList {
 	return AudioTrackList{Value: Value{Value: val}}
 }
 func (v Value) AsAudioTrackList() AudioTrackList { return AudioTrackList{Value: v} }
 func (a AudioTrackList) GetTrackById(args ...interface{}) AudioTrack {
 	val := a.Call("getTrackById", args...)
-	return jsValueToAudioTrack(val.JSValue())
+	return JSValueToAudioTrack(val.JSValue())
 }
 func (a AudioTrackList) GetLength() float64 {
 	val := a.Get("length")
@@ -36,21 +36,21 @@ func (a AudioTrackList) GetLength() float64 {
 }
 func (a AudioTrackList) GetOnaddtrack() EventHandler {
 	val := a.Get("onaddtrack")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a AudioTrackList) SetOnaddtrack(val EventHandler) {
 	a.Set("onaddtrack", val)
 }
 func (a AudioTrackList) GetOnchange() EventHandler {
 	val := a.Get("onchange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a AudioTrackList) SetOnchange(val EventHandler) {
 	a.Set("onchange", val)
 }
 func (a AudioTrackList) GetOnremovetrack() EventHandler {
 	val := a.Get("onremovetrack")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (a AudioTrackList) SetOnremovetrack(val EventHandler) {
 	a.Set("onremovetrack", val)

barprop.go

@@ -11,7 +11,7 @@ type BarProp struct {
 	Value
 }
 
-func jsValueToBarProp(val js.Value) BarProp { return BarProp{Value: Value{Value: val}} }
+func JSValueToBarProp(val js.Value) BarProp { return BarProp{Value: Value{Value: val}} }
 func (v Value) AsBarProp() BarProp          { return BarProp{Value: v} }
 func (b BarProp) GetVisible() bool {
 	val := b.Get("visible")

beforeunloadevent.go

@@ -31,7 +31,7 @@ type BeforeUnloadEvent struct {
 	Event
 }
 
-func jsValueToBeforeUnloadEvent(val js.Value) BeforeUnloadEvent {
+func JSValueToBeforeUnloadEvent(val js.Value) BeforeUnloadEvent {
 	return BeforeUnloadEvent{Value: Value{Value: val}}
 }
 func (v Value) AsBeforeUnloadEvent() BeforeUnloadEvent { return BeforeUnloadEvent{Value: v} }

binarytype.go

@@ -11,6 +11,6 @@ const (
 	BinaryTypeArraybuffer BinaryType = "arraybuffer"
 )
 
-func jsValueToBinaryType(val js.Value) BinaryType {
+func JSValueToBinaryType(val js.Value) BinaryType {
 	return BinaryType(val.String())
 }

blob.go

@@ -13,7 +13,7 @@ type Blob struct {
 	Value
 }
 
-func jsValueToBlob(val js.Value) Blob { return Blob{Value: Value{Value: val}} }
+func JSValueToBlob(val js.Value) Blob { return Blob{Value: Value{Value: val}} }
 func (v Value) AsBlob() Blob          { return Blob{Value: v} }
 func (b Blob) GetSize() float64 {
 	val := b.Get("size")
@@ -21,7 +21,7 @@ func (b Blob) GetSize() float64 {
 }
 func (b Blob) Slice(args ...interface{}) Blob {
 	val := b.Call("slice", args...)
-	return jsValueToBlob(val.JSValue())
+	return JSValueToBlob(val.JSValue())
 }
 func (b Blob) GetType() string {
 	val := b.Get("type")

blobcallback.go

@@ -9,12 +9,12 @@ type BlobCallback struct {
 	Callback
 }
 
-func jsValueToBlobCallback(val js.Value) BlobCallback {
-	return BlobCallback{Callback: jsValueToCallback(val)}
+func JSValueToBlobCallback(val js.Value) BlobCallback {
+	return BlobCallback{Callback: JSValueToCallback(val)}
 }
 func NewBlobCallback(c BlobCallbackCallback) BlobCallback {
 	callback := js.NewCallback(func(args []js.Value) {
-		blob := jsValueToBlob(args[0])
+		blob := JSValueToBlob(args[0])
 		c(blob)
 	})
 	return BlobCallback{Callback: Callback{Callback: callback}}

blobpart.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type BlobPart Value
 
-func jsValueToBlobPart(val js.Value) BlobPart {
-	return BlobPart(jsValueToValue(val))
+func JSValueToBlobPart(val js.Value) BlobPart {
+	return BlobPart(JSValueToValue(val))
 }

bodyinit.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type BodyInit Value
 
-func jsValueToBodyInit(val js.Value) BodyInit {
-	return BodyInit(jsValueToValue(val))
+func JSValueToBodyInit(val js.Value) BodyInit {
+	return BodyInit(JSValueToValue(val))
 }

broadcastchannel.go

@@ -21,7 +21,7 @@ type BroadcastChannel struct {
 	EventTarget
 }
 
-func jsValueToBroadcastChannel(val js.Value) BroadcastChannel {
+func JSValueToBroadcastChannel(val js.Value) BroadcastChannel {
 	return BroadcastChannel{Value: Value{Value: val}}
 }
 func (v Value) AsBroadcastChannel() BroadcastChannel { return BroadcastChannel{Value: v} }
@@ -34,14 +34,14 @@ func (b BroadcastChannel) GetName() string {
 }
 func (b BroadcastChannel) GetOnmessage() EventHandler {
 	val := b.Get("onmessage")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (b BroadcastChannel) SetOnmessage(val EventHandler) {
 	b.Set("onmessage", val)
 }
 func (b BroadcastChannel) GetOnmessageerror() EventHandler {
 	val := b.Get("onmessageerror")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (b BroadcastChannel) SetOnmessageerror(val EventHandler) {
 	b.Set("onmessageerror", val)

buffersource.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type BufferSource Value
 
-func jsValueToBufferSource(val js.Value) BufferSource {
-	return BufferSource(jsValueToValue(val))
+func JSValueToBufferSource(val js.Value) BufferSource {
+	return BufferSource(JSValueToValue(val))
 }

callback.go

@@ -6,5 +6,5 @@ type Callback struct {
 	js.Callback
 }
 
-func jsValueToCallback(val js.Value) Callback { return Callback{Callback: js.Callback{Value: val}} }
+func JSValueToCallback(val js.Value) Callback { return Callback{Callback: js.Callback{Value: val}} }
 func (c Callback) JSValue() js.Value          { return c.Callback.Value }

canplaytyperesult.go

@@ -12,6 +12,6 @@ const (
 	CanPlayTypeResultProbably CanPlayTypeResult = "probably"
 )
 
-func jsValueToCanPlayTypeResult(val js.Value) CanPlayTypeResult {
+func JSValueToCanPlayTypeResult(val js.Value) CanPlayTypeResult {
 	return CanPlayTypeResult(val.String())
 }

canvasdirection.go

@@ -12,6 +12,6 @@ const (
 	CanvasDirectionInherit CanvasDirection = "inherit"
 )
 
-func jsValueToCanvasDirection(val js.Value) CanvasDirection {
+func JSValueToCanvasDirection(val js.Value) CanvasDirection {
 	return CanvasDirection(val.String())
 }

canvasfillrule.go

@@ -11,6 +11,6 @@ const (
 	CanvasFillRuleEvenodd CanvasFillRule = "evenodd"
 )
 
-func jsValueToCanvasFillRule(val js.Value) CanvasFillRule {
+func JSValueToCanvasFillRule(val js.Value) CanvasFillRule {
 	return CanvasFillRule(val.String())
 }

canvasgradient.go

@@ -11,7 +11,7 @@ type CanvasGradient struct {
 	Value
 }
 
-func jsValueToCanvasGradient(val js.Value) CanvasGradient {
+func JSValueToCanvasGradient(val js.Value) CanvasGradient {
 	return CanvasGradient{Value: Value{Value: val}}
 }
 func (v Value) AsCanvasGradient() CanvasGradient { return CanvasGradient{Value: v} }

canvasimagesource.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type CanvasImageSource Value
 
-func jsValueToCanvasImageSource(val js.Value) CanvasImageSource {
-	return CanvasImageSource(jsValueToValue(val))
+func JSValueToCanvasImageSource(val js.Value) CanvasImageSource {
+	return CanvasImageSource(JSValueToValue(val))
 }

canvaslinecap.go

@@ -12,6 +12,6 @@ const (
 	CanvasLineCapSquare CanvasLineCap = "square"
 )
 
-func jsValueToCanvasLineCap(val js.Value) CanvasLineCap {
+func JSValueToCanvasLineCap(val js.Value) CanvasLineCap {
 	return CanvasLineCap(val.String())
 }

canvaslinejoin.go

@@ -12,6 +12,6 @@ const (
 	CanvasLineJoinMiter CanvasLineJoin = "miter"
 )
 
-func jsValueToCanvasLineJoin(val js.Value) CanvasLineJoin {
+func JSValueToCanvasLineJoin(val js.Value) CanvasLineJoin {
 	return CanvasLineJoin(val.String())
 }

canvaspattern.go

@@ -11,7 +11,7 @@ type CanvasPattern struct {
 	Value
 }
 
-func jsValueToCanvasPattern(val js.Value) CanvasPattern {
+func JSValueToCanvasPattern(val js.Value) CanvasPattern {
 	return CanvasPattern{Value: Value{Value: val}}
 }
 func (v Value) AsCanvasPattern() CanvasPattern { return CanvasPattern{Value: v} }

canvasrenderingcontext2d.go

@@ -102,7 +102,7 @@ type CanvasRenderingContext2D struct {
 	Value
 }
 
-func jsValueToCanvasRenderingContext2D(val js.Value) CanvasRenderingContext2D {
+func JSValueToCanvasRenderingContext2D(val js.Value) CanvasRenderingContext2D {
 	return CanvasRenderingContext2D{Value: Value{Value: val}}
 }
 func (v Value) AsCanvasRenderingContext2D() CanvasRenderingContext2D {
@@ -122,7 +122,7 @@ func (c CanvasRenderingContext2D) BezierCurveTo(args ...interface{}) {
 }
 func (c CanvasRenderingContext2D) GetCanvas() HTMLCanvasElement {
 	val := c.Get("canvas")
-	return jsValueToHTMLCanvasElement(val.JSValue())
+	return JSValueToHTMLCanvasElement(val.JSValue())
 }
 func (c CanvasRenderingContext2D) ClearRect(args ...interface{}) {
 	c.Call("clearRect", args...)
@@ -138,27 +138,27 @@ func (c CanvasRenderingContext2D) ClosePath(args ...interface{}) {
 }
 func (c CanvasRenderingContext2D) CreateImageData(args ...interface{}) ImageData {
 	val := c.Call("createImageData", args...)
-	return jsValueToImageData(val.JSValue())
+	return JSValueToImageData(val.JSValue())
 }
 func (c CanvasRenderingContext2D) CreateImageDataWithArgs(args ...interface{}) ImageData {
 	val := c.Call("createImageDataWithArgs", args...)
-	return jsValueToImageData(val.JSValue())
+	return JSValueToImageData(val.JSValue())
 }
 func (c CanvasRenderingContext2D) CreateLinearGradient(args ...interface{}) CanvasGradient {
 	val := c.Call("createLinearGradient", args...)
-	return jsValueToCanvasGradient(val.JSValue())
+	return JSValueToCanvasGradient(val.JSValue())
 }
 func (c CanvasRenderingContext2D) CreatePattern(args ...interface{}) CanvasPattern {
 	val := c.Call("createPattern", args...)
-	return jsValueToCanvasPattern(val.JSValue())
+	return JSValueToCanvasPattern(val.JSValue())
 }
 func (c CanvasRenderingContext2D) CreateRadialGradient(args ...interface{}) CanvasGradient {
 	val := c.Call("createRadialGradient", args...)
-	return jsValueToCanvasGradient(val.JSValue())
+	return JSValueToCanvasGradient(val.JSValue())
 }
 func (c CanvasRenderingContext2D) GetDirection() CanvasDirection {
 	val := c.Get("direction")
-	return jsValueToCanvasDirection(val.JSValue())
+	return JSValueToCanvasDirection(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetDirection(val CanvasDirection) {
 	c.Set("direction", val)
@@ -210,14 +210,14 @@ func (c CanvasRenderingContext2D) SetFont(val string) {
 }
 func (c CanvasRenderingContext2D) GetImageData(args ...interface{}) ImageData {
 	val := c.Call("getImageData", args...)
-	return jsValueToImageData(val.JSValue())
+	return JSValueToImageData(val.JSValue())
 }
 func (c CanvasRenderingContext2D) GetLineDash(args ...interface{}) {
 	c.Call("getLineDash", args...)
 }
 func (c CanvasRenderingContext2D) GetTransform(args ...interface{}) DOMMatrix {
 	val := c.Call("getTransform", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (c CanvasRenderingContext2D) GetGlobalAlpha() float64 {
 	val := c.Get("globalAlpha")
@@ -242,7 +242,7 @@ func (c CanvasRenderingContext2D) SetImageSmoothingEnabled(val bool) {
 }
 func (c CanvasRenderingContext2D) GetImageSmoothingQuality() ImageSmoothingQuality {
 	val := c.Get("imageSmoothingQuality")
-	return jsValueToImageSmoothingQuality(val.JSValue())
+	return JSValueToImageSmoothingQuality(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetImageSmoothingQuality(val ImageSmoothingQuality) {
 	c.Set("imageSmoothingQuality", val)
@@ -265,7 +265,7 @@ func (c CanvasRenderingContext2D) IsPointInStrokeWithArgs(args ...interface{}) b
 }
 func (c CanvasRenderingContext2D) GetLineCap() CanvasLineCap {
 	val := c.Get("lineCap")
-	return jsValueToCanvasLineCap(val.JSValue())
+	return JSValueToCanvasLineCap(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetLineCap(val CanvasLineCap) {
 	c.Set("lineCap", val)
@@ -279,7 +279,7 @@ func (c CanvasRenderingContext2D) SetLineDashOffset(val float64) {
 }
 func (c CanvasRenderingContext2D) GetLineJoin() CanvasLineJoin {
 	val := c.Get("lineJoin")
-	return jsValueToCanvasLineJoin(val.JSValue())
+	return JSValueToCanvasLineJoin(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetLineJoin(val CanvasLineJoin) {
 	c.Set("lineJoin", val)
@@ -296,7 +296,7 @@ func (c CanvasRenderingContext2D) SetLineWidth(val float64) {
 }
 func (c CanvasRenderingContext2D) MeasureText(args ...interface{}) TextMetrics {
 	val := c.Call("measureText", args...)
-	return jsValueToTextMetrics(val.JSValue())
+	return JSValueToTextMetrics(val.JSValue())
 }
 func (c CanvasRenderingContext2D) GetMiterLimit() float64 {
 	val := c.Get("miterLimit")
@@ -399,14 +399,14 @@ func (c CanvasRenderingContext2D) StrokeWithArgs(args ...interface{}) {
 }
 func (c CanvasRenderingContext2D) GetTextAlign() CanvasTextAlign {
 	val := c.Get("textAlign")
-	return jsValueToCanvasTextAlign(val.JSValue())
+	return JSValueToCanvasTextAlign(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetTextAlign(val CanvasTextAlign) {
 	c.Set("textAlign", val)
 }
 func (c CanvasRenderingContext2D) GetTextBaseline() CanvasTextBaseline {
 	val := c.Get("textBaseline")
-	return jsValueToCanvasTextBaseline(val.JSValue())
+	return JSValueToCanvasTextBaseline(val.JSValue())
 }
 func (c CanvasRenderingContext2D) SetTextBaseline(val CanvasTextBaseline) {
 	c.Set("textBaseline", val)

canvastextalign.go

@@ -14,6 +14,6 @@ const (
 	CanvasTextAlignCenter CanvasTextAlign = "center"
 )
 
-func jsValueToCanvasTextAlign(val js.Value) CanvasTextAlign {
+func JSValueToCanvasTextAlign(val js.Value) CanvasTextAlign {
 	return CanvasTextAlign(val.String())
 }

canvastextbaseline.go

@@ -15,6 +15,6 @@ const (
 	CanvasTextBaselineBottom      CanvasTextBaseline = "bottom"
 )
 
-func jsValueToCanvasTextBaseline(val js.Value) CanvasTextBaseline {
+func JSValueToCanvasTextBaseline(val js.Value) CanvasTextBaseline {
 	return CanvasTextBaseline(val.String())
 }

cdatasection.go

@@ -58,5 +58,5 @@ type CDATASection struct {
 	EventTarget
 }
 
-func jsValueToCDATASection(val js.Value) CDATASection { return CDATASection{Value: Value{Value: val}} }
+func JSValueToCDATASection(val js.Value) CDATASection { return CDATASection{Value: Value{Value: val}} }
 func (v Value) AsCDATASection() CDATASection          { return CDATASection{Value: v} }

characterdata.go

@@ -60,7 +60,7 @@ type CharacterData struct {
 	EventTarget
 }
 
-func jsValueToCharacterData(val js.Value) CharacterData {
+func JSValueToCharacterData(val js.Value) CharacterData {
 	return CharacterData{Value: Value{Value: val}}
 }
 func (v Value) AsCharacterData() CharacterData { return CharacterData{Value: v} }
@@ -92,11 +92,11 @@ func (c CharacterData) GetLength() float64 {
 }
 func (c CharacterData) GetNextElementSibling() Element {
 	val := c.Get("nextElementSibling")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (c CharacterData) GetPreviousElementSibling() Element {
 	val := c.Get("previousElementSibling")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (c CharacterData) Remove(args ...interface{}) {
 	c.Call("remove", args...)

closeevent.go

@@ -34,7 +34,7 @@ type CloseEvent struct {
 	Event
 }
 
-func jsValueToCloseEvent(val js.Value) CloseEvent { return CloseEvent{Value: Value{Value: val}} }
+func JSValueToCloseEvent(val js.Value) CloseEvent { return CloseEvent{Value: Value{Value: val}} }
 func (v Value) AsCloseEvent() CloseEvent          { return CloseEvent{Value: v} }
 func (c CloseEvent) GetCode() int {
 	val := c.Get("code")

cmd/dom/main.go

@@ -1,16 +1,18 @@
 package main
 
 import (
-	"syscall/js"
-
+	"github.com/brettlangdon/go-dom/v1/console"
 	"github.com/brettlangdon/go-dom/v1/document"
+	"github.com/brettlangdon/go-dom/v1/window"
 )
 
 func main() {
-	console := js.Global().Get("console")
-	nodes := document.Document.QuerySelectorAll("div")
+	loc := window.GetLocation()
+	console.Dir(loc.JSValue())
+
+	nodes := document.QuerySelectorAll("div")
 	var i float64 = 0
 	for ; i < nodes.GetLength(); i++ {
-		console.Call("dir", nodes.Item(i).JSValue())
+		console.Dir(nodes.Item(i).JSValue())
 	}
 }

colorspaceconversion.go

@@ -11,6 +11,6 @@ const (
 	ColorSpaceConversionDefault ColorSpaceConversion = "default"
 )
 
-func jsValueToColorSpaceConversion(val js.Value) ColorSpaceConversion {
+func JSValueToColorSpaceConversion(val js.Value) ColorSpaceConversion {
 	return ColorSpaceConversion(val.String())
 }

comment.go

@@ -55,5 +55,5 @@ type Comment struct {
 	EventTarget
 }
 
-func jsValueToComment(val js.Value) Comment { return Comment{Value: Value{Value: val}} }
+func JSValueToComment(val js.Value) Comment { return Comment{Value: Value{Value: val}} }
 func (v Value) AsComment() Comment          { return Comment{Value: v} }

console/console.go

@@ -2,27 +2,66 @@
 // console/console.go
 package console
 
+import dom "github.com/brettlangdon/go-dom/v1"
 import "syscall/js"
 
-var value Value
+var value dom.Value
 
-func init()                              { value = Value{Value: js.Global().Get("console")} }
-func Clear(args ...interface{})          { return value.Call("clear", args...) }
-func Table(args ...interface{})          { return value.Call("table", args...) }
-func Warn(args ...interface{})           { return value.Call("warn", args...) }
-func Dirxml(args ...interface{})         { return value.Call("dirxml", args...) }
-func Group(args ...interface{})          { return value.Call("group", args...) }
-func Time(args ...interface{})           { return value.Call("time", args...) }
-func Trace(args ...interface{})          { return value.Call("trace", args...) }
-func CountReset(args ...interface{})     { return value.Call("countReset", args...) }
-func GroupEnd(args ...interface{})       { return value.Call("groupEnd", args...) }
-func Assert(args ...interface{})         { return value.Call("assert", args...) }
-func Debug(args ...interface{})          { return value.Call("debug", args...) }
-func Log(args ...interface{})            { return value.Call("log", args...) }
-func Dir(args ...interface{})            { return value.Call("dir", args...) }
-func TimeLog(args ...interface{})        { return value.Call("timeLog", args...) }
-func Error(args ...interface{})          { return value.Call("error", args...) }
-func Info(args ...interface{})           { return value.Call("info", args...) }
-func Count(args ...interface{})          { return value.Call("count", args...) }
-func GroupCollapsed(args ...interface{}) { return value.Call("groupCollapsed", args...) }
-func TimeEnd(args ...interface{})        { return value.Call("timeEnd", args...) }
+func init() { value = dom.JSValueToValue(js.Global().Get("console")) }
+func Assert(args ...interface{}) {
+	value.Call("assert", args...)
+}
+func Clear(args ...interface{}) {
+	value.Call("clear", args...)
+}
+func Count(args ...interface{}) {
+	value.Call("count", args...)
+}
+func CountReset(args ...interface{}) {
+	value.Call("countReset", args...)
+}
+func Debug(args ...interface{}) {
+	value.Call("debug", args...)
+}
+func Dir(args ...interface{}) {
+	value.Call("dir", args...)
+}
+func Dirxml(args ...interface{}) {
+	value.Call("dirxml", args...)
+}
+func Error(args ...interface{}) {
+	value.Call("error", args...)
+}
+func Group(args ...interface{}) {
+	value.Call("group", args...)
+}
+func GroupCollapsed(args ...interface{}) {
+	value.Call("groupCollapsed", args...)
+}
+func GroupEnd(args ...interface{}) {
+	value.Call("groupEnd", args...)
+}
+func Info(args ...interface{}) {
+	value.Call("info", args...)
+}
+func Log(args ...interface{}) {
+	value.Call("log", args...)
+}
+func Table(args ...interface{}) {
+	value.Call("table", args...)
+}
+func Time(args ...interface{}) {
+	value.Call("time", args...)
+}
+func TimeEnd(args ...interface{}) {
+	value.Call("timeEnd", args...)
+}
+func TimeLog(args ...interface{}) {
+	value.Call("timeLog", args...)
+}
+func Trace(args ...interface{}) {
+	value.Call("trace", args...)
+}
+func Warn(args ...interface{}) {
+	value.Call("warn", args...)
+}

css/css.go

@@ -2,9 +2,13 @@
 // css/css.go
 package css
 
+import dom "github.com/brettlangdon/go-dom/v1"
 import "syscall/js"
 
-var value Value
+var value dom.Value
 
-func init()                      { value = Value{Value: js.Global().Get("CSS")} }
-func Escape(args ...interface{}) { return value.Call("escape", args...) }
+func init() { value = dom.JSValueToValue(js.Global().Get("css")) }
+func Escape(args ...interface{}) string {
+	val := value.Call("escape", args...)
+	return val.String()
+}

cssgroupingrule.go

@@ -19,13 +19,13 @@ type CSSGroupingRule struct {
 	CSSRule
 }
 
-func jsValueToCSSGroupingRule(val js.Value) CSSGroupingRule {
+func JSValueToCSSGroupingRule(val js.Value) CSSGroupingRule {
 	return CSSGroupingRule{Value: Value{Value: val}}
 }
 func (v Value) AsCSSGroupingRule() CSSGroupingRule { return CSSGroupingRule{Value: v} }
 func (c CSSGroupingRule) GetCssRules() CSSRuleList {
 	val := c.Get("cssRules")
-	return jsValueToCSSRuleList(val.JSValue())
+	return JSValueToCSSRuleList(val.JSValue())
 }
 func (c CSSGroupingRule) DeleteRule(args ...interface{}) {
 	c.Call("deleteRule", args...)

cssimportrule.go

@@ -19,7 +19,7 @@ type CSSImportRule struct {
 	CSSRule
 }
 
-func jsValueToCSSImportRule(val js.Value) CSSImportRule {
+func JSValueToCSSImportRule(val js.Value) CSSImportRule {
 	return CSSImportRule{Value: Value{Value: val}}
 }
 func (v Value) AsCSSImportRule() CSSImportRule { return CSSImportRule{Value: v} }
@@ -29,9 +29,9 @@ func (c CSSImportRule) GetHref() string {
 }
 func (c CSSImportRule) GetMedia() MediaList {
 	val := c.Get("media")
-	return jsValueToMediaList(val.JSValue())
+	return JSValueToMediaList(val.JSValue())
 }
 func (c CSSImportRule) GetStyleSheet() CSSStyleSheet {
 	val := c.Get("styleSheet")
-	return jsValueToCSSStyleSheet(val.JSValue())
+	return JSValueToCSSStyleSheet(val.JSValue())
 }

cssmarginrule.go

@@ -18,7 +18,7 @@ type CSSMarginRule struct {
 	CSSRule
 }
 
-func jsValueToCSSMarginRule(val js.Value) CSSMarginRule {
+func JSValueToCSSMarginRule(val js.Value) CSSMarginRule {
 	return CSSMarginRule{Value: Value{Value: val}}
 }
 func (v Value) AsCSSMarginRule() CSSMarginRule { return CSSMarginRule{Value: v} }
@@ -28,5 +28,5 @@ func (c CSSMarginRule) GetName() string {
 }
 func (c CSSMarginRule) GetStyle() CSSStyleDeclaration {
 	val := c.Get("style")
-	return jsValueToCSSStyleDeclaration(val.JSValue())
+	return JSValueToCSSStyleDeclaration(val.JSValue())
 }

cssnamespacerule.go

@@ -18,7 +18,7 @@ type CSSNamespaceRule struct {
 	CSSRule
 }
 
-func jsValueToCSSNamespaceRule(val js.Value) CSSNamespaceRule {
+func JSValueToCSSNamespaceRule(val js.Value) CSSNamespaceRule {
 	return CSSNamespaceRule{Value: Value{Value: val}}
 }
 func (v Value) AsCSSNamespaceRule() CSSNamespaceRule { return CSSNamespaceRule{Value: v} }

csspagerule.go

@@ -23,7 +23,7 @@ type CSSPageRule struct {
 	CSSRule
 }
 
-func jsValueToCSSPageRule(val js.Value) CSSPageRule { return CSSPageRule{Value: Value{Value: val}} }
+func JSValueToCSSPageRule(val js.Value) CSSPageRule { return CSSPageRule{Value: Value{Value: val}} }
 func (v Value) AsCSSPageRule() CSSPageRule          { return CSSPageRule{Value: v} }
 func (c CSSPageRule) GetSelectorText() string {
 	val := c.Get("selectorText")
@@ -34,5 +34,5 @@ func (c CSSPageRule) SetSelectorText(val string) {
 }
 func (c CSSPageRule) GetStyle() CSSStyleDeclaration {
 	val := c.Get("style")
-	return jsValueToCSSStyleDeclaration(val.JSValue())
+	return JSValueToCSSStyleDeclaration(val.JSValue())
 }

cssrule.go

@@ -15,7 +15,7 @@ type CSSRule struct {
 	Value
 }
 
-func jsValueToCSSRule(val js.Value) CSSRule { return CSSRule{Value: Value{Value: val}} }
+func JSValueToCSSRule(val js.Value) CSSRule { return CSSRule{Value: Value{Value: val}} }
 func (v Value) AsCSSRule() CSSRule          { return CSSRule{Value: v} }
 func (c CSSRule) GetCssText() string {
 	val := c.Get("cssText")
@@ -26,11 +26,11 @@ func (c CSSRule) SetCssText(val string) {
 }
 func (c CSSRule) GetParentRule() CSSRule {
 	val := c.Get("parentRule")
-	return jsValueToCSSRule(val.JSValue())
+	return JSValueToCSSRule(val.JSValue())
 }
 func (c CSSRule) GetParentStyleSheet() CSSStyleSheet {
 	val := c.Get("parentStyleSheet")
-	return jsValueToCSSStyleSheet(val.JSValue())
+	return JSValueToCSSStyleSheet(val.JSValue())
 }
 func (c CSSRule) GetType() int {
 	val := c.Get("type")

cssrulelist.go

@@ -12,11 +12,11 @@ type CSSRuleList struct {
 	Value
 }
 
-func jsValueToCSSRuleList(val js.Value) CSSRuleList { return CSSRuleList{Value: Value{Value: val}} }
+func JSValueToCSSRuleList(val js.Value) CSSRuleList { return CSSRuleList{Value: Value{Value: val}} }
 func (v Value) AsCSSRuleList() CSSRuleList          { return CSSRuleList{Value: v} }
 func (c CSSRuleList) Item(args ...interface{}) CSSRule {
 	val := c.Call("item", args...)
-	return jsValueToCSSRule(val.JSValue())
+	return JSValueToCSSRule(val.JSValue())
 }
 func (c CSSRuleList) GetLength() float64 {
 	val := c.Get("length")

cssstyledeclaration.go

@@ -21,7 +21,7 @@ type CSSStyleDeclaration struct {
 	Value
 }
 
-func jsValueToCSSStyleDeclaration(val js.Value) CSSStyleDeclaration {
+func JSValueToCSSStyleDeclaration(val js.Value) CSSStyleDeclaration {
 	return CSSStyleDeclaration{Value: Value{Value: val}}
 }
 func (v Value) AsCSSStyleDeclaration() CSSStyleDeclaration { return CSSStyleDeclaration{Value: v} }
@@ -57,7 +57,7 @@ func (c CSSStyleDeclaration) GetLength() float64 {
 }
 func (c CSSStyleDeclaration) GetParentRule() CSSRule {
 	val := c.Get("parentRule")
-	return jsValueToCSSRule(val.JSValue())
+	return JSValueToCSSRule(val.JSValue())
 }
 func (c CSSStyleDeclaration) RemoveProperty(args ...interface{}) string {
 	val := c.Call("removeProperty", args...)

cssstylerule.go

@@ -19,7 +19,7 @@ type CSSStyleRule struct {
 	CSSRule
 }
 
-func jsValueToCSSStyleRule(val js.Value) CSSStyleRule { return CSSStyleRule{Value: Value{Value: val}} }
+func JSValueToCSSStyleRule(val js.Value) CSSStyleRule { return CSSStyleRule{Value: Value{Value: val}} }
 func (v Value) AsCSSStyleRule() CSSStyleRule          { return CSSStyleRule{Value: v} }
 func (c CSSStyleRule) GetSelectorText() string {
 	val := c.Get("selectorText")
@@ -30,5 +30,5 @@ func (c CSSStyleRule) SetSelectorText(val string) {
 }
 func (c CSSStyleRule) GetStyle() CSSStyleDeclaration {
 	val := c.Get("style")
-	return jsValueToCSSStyleDeclaration(val.JSValue())
+	return JSValueToCSSStyleDeclaration(val.JSValue())
 }

cssstylesheet.go

@@ -23,13 +23,13 @@ type CSSStyleSheet struct {
 	StyleSheet
 }
 
-func jsValueToCSSStyleSheet(val js.Value) CSSStyleSheet {
+func JSValueToCSSStyleSheet(val js.Value) CSSStyleSheet {
 	return CSSStyleSheet{Value: Value{Value: val}}
 }
 func (v Value) AsCSSStyleSheet() CSSStyleSheet { return CSSStyleSheet{Value: v} }
 func (c CSSStyleSheet) GetCssRules() CSSRuleList {
 	val := c.Get("cssRules")
-	return jsValueToCSSRuleList(val.JSValue())
+	return JSValueToCSSRuleList(val.JSValue())
 }
 func (c CSSStyleSheet) DeleteRule(args ...interface{}) {
 	c.Call("deleteRule", args...)
@@ -40,5 +40,5 @@ func (c CSSStyleSheet) InsertRule(args ...interface{}) float64 {
 }
 func (c CSSStyleSheet) GetOwnerRule() CSSRule {
 	val := c.Get("ownerRule")
-	return jsValueToCSSRule(val.JSValue())
+	return JSValueToCSSRule(val.JSValue())
 }

customelementconstructor.go

@@ -9,8 +9,8 @@ type CustomElementConstructor struct {
 	Callback
 }
 
-func jsValueToCustomElementConstructor(val js.Value) CustomElementConstructor {
-	return CustomElementConstructor{Callback: jsValueToCallback(val)}
+func JSValueToCustomElementConstructor(val js.Value) CustomElementConstructor {
+	return CustomElementConstructor{Callback: JSValueToCallback(val)}
 }
 func NewCustomElementConstructor(c CustomElementConstructorCallback) CustomElementConstructor {
 	callback := js.NewCallback(func(args []js.Value) {

customelementregistry.go

@@ -14,7 +14,7 @@ type CustomElementRegistry struct {
 	Value
 }
 
-func jsValueToCustomElementRegistry(val js.Value) CustomElementRegistry {
+func JSValueToCustomElementRegistry(val js.Value) CustomElementRegistry {
 	return CustomElementRegistry{Value: Value{Value: val}}
 }
 func (v Value) AsCustomElementRegistry() CustomElementRegistry { return CustomElementRegistry{Value: v} }

customevent.go

@@ -33,7 +33,7 @@ type CustomEvent struct {
 	Event
 }
 
-func jsValueToCustomEvent(val js.Value) CustomEvent { return CustomEvent{Value: Value{Value: val}} }
+func JSValueToCustomEvent(val js.Value) CustomEvent { return CustomEvent{Value: Value{Value: val}} }
 func (v Value) AsCustomEvent() CustomEvent          { return CustomEvent{Value: v} }
 func (c CustomEvent) GetDetail() Value {
 	val := c.Get("detail")

datatransfer.go

@@ -21,7 +21,7 @@ type DataTransfer struct {
 	Value
 }
 
-func jsValueToDataTransfer(val js.Value) DataTransfer { return DataTransfer{Value: Value{Value: val}} }
+func JSValueToDataTransfer(val js.Value) DataTransfer { return DataTransfer{Value: Value{Value: val}} }
 func (v Value) AsDataTransfer() DataTransfer          { return DataTransfer{Value: v} }
 func (d DataTransfer) ClearData(args ...interface{}) {
 	d.Call("clearData", args...)
@@ -42,7 +42,7 @@ func (d DataTransfer) SetEffectAllowed(val string) {
 }
 func (d DataTransfer) GetFiles() FileList {
 	val := d.Get("files")
-	return jsValueToFileList(val.JSValue())
+	return JSValueToFileList(val.JSValue())
 }
 func (d DataTransfer) GetData(args ...interface{}) string {
 	val := d.Call("getData", args...)
@@ -50,7 +50,7 @@ func (d DataTransfer) GetData(args ...interface{}) string {
 }
 func (d DataTransfer) GetItems() DataTransferItemList {
 	val := d.Get("items")
-	return jsValueToDataTransferItemList(val.JSValue())
+	return JSValueToDataTransferItemList(val.JSValue())
 }
 func (d DataTransfer) SetData(args ...interface{}) {
 	d.Call("setData", args...)

datatransferitem.go

@@ -14,13 +14,13 @@ type DataTransferItem struct {
 	Value
 }
 
-func jsValueToDataTransferItem(val js.Value) DataTransferItem {
+func JSValueToDataTransferItem(val js.Value) DataTransferItem {
 	return DataTransferItem{Value: Value{Value: val}}
 }
 func (v Value) AsDataTransferItem() DataTransferItem { return DataTransferItem{Value: v} }
 func (d DataTransferItem) GetAsFile(args ...interface{}) File {
 	val := d.Call("getAsFile", args...)
-	return jsValueToFile(val.JSValue())
+	return JSValueToFile(val.JSValue())
 }
 func (d DataTransferItem) GetAsString(args ...interface{}) {
 	d.Call("getAsString", args...)

datatransferitemlist.go

@@ -15,17 +15,17 @@ type DataTransferItemList struct {
 	Value
 }
 
-func jsValueToDataTransferItemList(val js.Value) DataTransferItemList {
+func JSValueToDataTransferItemList(val js.Value) DataTransferItemList {
 	return DataTransferItemList{Value: Value{Value: val}}
 }
 func (v Value) AsDataTransferItemList() DataTransferItemList { return DataTransferItemList{Value: v} }
 func (d DataTransferItemList) Add(args ...interface{}) DataTransferItem {
 	val := d.Call("add", args...)
-	return jsValueToDataTransferItem(val.JSValue())
+	return JSValueToDataTransferItem(val.JSValue())
 }
 func (d DataTransferItemList) AddWithArgs(args ...interface{}) DataTransferItem {
 	val := d.Call("addWithArgs", args...)
-	return jsValueToDataTransferItem(val.JSValue())
+	return JSValueToDataTransferItem(val.JSValue())
 }
 func (d DataTransferItemList) Clear(args ...interface{}) {
 	d.Call("clear", args...)

dedicatedworkerglobalscope.go

@@ -40,7 +40,7 @@ type DedicatedWorkerGlobalScope struct {
 	EventTarget
 }
 
-func jsValueToDedicatedWorkerGlobalScope(val js.Value) DedicatedWorkerGlobalScope {
+func JSValueToDedicatedWorkerGlobalScope(val js.Value) DedicatedWorkerGlobalScope {
 	return DedicatedWorkerGlobalScope{Value: Value{Value: val}}
 }
 func (v Value) AsDedicatedWorkerGlobalScope() DedicatedWorkerGlobalScope {
@@ -58,14 +58,14 @@ func (d DedicatedWorkerGlobalScope) GetName() string {
 }
 func (d DedicatedWorkerGlobalScope) GetOnmessage() EventHandler {
 	val := d.Get("onmessage")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d DedicatedWorkerGlobalScope) SetOnmessage(val EventHandler) {
 	d.Set("onmessage", val)
 }
 func (d DedicatedWorkerGlobalScope) GetOnmessageerror() EventHandler {
 	val := d.Get("onmessageerror")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d DedicatedWorkerGlobalScope) SetOnmessageerror(val EventHandler) {
 	d.Set("onmessageerror", val)

document.go

@@ -214,11 +214,11 @@ type Document struct {
 	EventTarget
 }
 
-func jsValueToDocument(val js.Value) Document { return Document{Value: Value{Value: val}} }
+func JSValueToDocument(val js.Value) Document { return Document{Value: Value{Value: val}} }
 func (v Value) AsDocument() Document          { return Document{Value: v} }
 func (d Document) AdoptNode(args ...interface{}) Node {
 	val := d.Call("adoptNode", args...)
-	return jsValueToNode(val.JSValue())
+	return JSValueToNode(val.JSValue())
 }
 func (d Document) Append(args ...interface{}) {
 	d.Call("append", args...)
@@ -237,7 +237,7 @@ func (d Document) GetChildElementCount() float64 {
 }
 func (d Document) GetChildren() HTMLCollection {
 	val := d.Get("children")
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (d Document) GetCompatMode() string {
 	val := d.Get("compatMode")
@@ -249,63 +249,63 @@ func (d Document) GetContentType() string {
 }
 func (d Document) CreateAttribute(args ...interface{}) Attr {
 	val := d.Call("createAttribute", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (d Document) CreateAttributeNS(args ...interface{}) Attr {
 	val := d.Call("createAttributeNS", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (d Document) CreateCDATASection(args ...interface{}) CDATASection {
 	val := d.Call("createCDATASection", args...)
-	return jsValueToCDATASection(val.JSValue())
+	return JSValueToCDATASection(val.JSValue())
 }
 func (d Document) CreateComment(args ...interface{}) Comment {
 	val := d.Call("createComment", args...)
-	return jsValueToComment(val.JSValue())
+	return JSValueToComment(val.JSValue())
 }
 func (d Document) CreateDocumentFragment(args ...interface{}) DocumentFragment {
 	val := d.Call("createDocumentFragment", args...)
-	return jsValueToDocumentFragment(val.JSValue())
+	return JSValueToDocumentFragment(val.JSValue())
 }
 func (d Document) CreateElement(args ...interface{}) Element {
 	val := d.Call("createElement", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) CreateElementNS(args ...interface{}) Element {
 	val := d.Call("createElementNS", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) CreateEvent(args ...interface{}) Event {
 	val := d.Call("createEvent", args...)
-	return jsValueToEvent(val.JSValue())
+	return JSValueToEvent(val.JSValue())
 }
 func (d Document) CreateNodeIterator(args ...interface{}) NodeIterator {
 	val := d.Call("createNodeIterator", args...)
-	return jsValueToNodeIterator(val.JSValue())
+	return JSValueToNodeIterator(val.JSValue())
 }
 func (d Document) CreateProcessingInstruction(args ...interface{}) ProcessingInstruction {
 	val := d.Call("createProcessingInstruction", args...)
-	return jsValueToProcessingInstruction(val.JSValue())
+	return JSValueToProcessingInstruction(val.JSValue())
 }
 func (d Document) CreateRange(args ...interface{}) Range {
 	val := d.Call("createRange", args...)
-	return jsValueToRange(val.JSValue())
+	return JSValueToRange(val.JSValue())
 }
 func (d Document) CreateTextNode(args ...interface{}) Text {
 	val := d.Call("createTextNode", args...)
-	return jsValueToText(val.JSValue())
+	return JSValueToText(val.JSValue())
 }
 func (d Document) CreateTreeWalker(args ...interface{}) TreeWalker {
 	val := d.Call("createTreeWalker", args...)
-	return jsValueToTreeWalker(val.JSValue())
+	return JSValueToTreeWalker(val.JSValue())
 }
 func (d Document) GetDoctype() DocumentType {
 	val := d.Get("doctype")
-	return jsValueToDocumentType(val.JSValue())
+	return JSValueToDocumentType(val.JSValue())
 }
 func (d Document) GetDocumentElement() Element {
 	val := d.Get("documentElement")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) GetDocumentURI() string {
 	val := d.Get("documentURI")
@@ -313,31 +313,31 @@ func (d Document) GetDocumentURI() string {
 }
 func (d Document) GetFirstElementChild() Element {
 	val := d.Get("firstElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) GetElementById(args ...interface{}) Element {
 	val := d.Call("getElementById", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) GetElementsByClassName(args ...interface{}) HTMLCollection {
 	val := d.Call("getElementsByClassName", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (d Document) GetElementsByTagName(args ...interface{}) HTMLCollection {
 	val := d.Call("getElementsByTagName", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (d Document) GetElementsByTagNameNS(args ...interface{}) HTMLCollection {
 	val := d.Call("getElementsByTagNameNS", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (d Document) GetImplementation() DOMImplementation {
 	val := d.Get("implementation")
-	return jsValueToDOMImplementation(val.JSValue())
+	return JSValueToDOMImplementation(val.JSValue())
 }
 func (d Document) ImportNode(args ...interface{}) Node {
 	val := d.Call("importNode", args...)
-	return jsValueToNode(val.JSValue())
+	return JSValueToNode(val.JSValue())
 }
 func (d Document) GetInputEncoding() string {
 	val := d.Get("inputEncoding")
@@ -345,459 +345,459 @@ func (d Document) GetInputEncoding() string {
 }
 func (d Document) GetLastElementChild() Element {
 	val := d.Get("lastElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) GetOnabort() EventHandler {
 	val := d.Get("onabort")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnabort(val EventHandler) {
 	d.Set("onabort", val)
 }
 func (d Document) GetOnauxclick() EventHandler {
 	val := d.Get("onauxclick")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnauxclick(val EventHandler) {
 	d.Set("onauxclick", val)
 }
 func (d Document) GetOnblur() EventHandler {
 	val := d.Get("onblur")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnblur(val EventHandler) {
 	d.Set("onblur", val)
 }
 func (d Document) GetOncancel() EventHandler {
 	val := d.Get("oncancel")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncancel(val EventHandler) {
 	d.Set("oncancel", val)
 }
 func (d Document) GetOncanplay() EventHandler {
 	val := d.Get("oncanplay")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncanplay(val EventHandler) {
 	d.Set("oncanplay", val)
 }
 func (d Document) GetOncanplaythrough() EventHandler {
 	val := d.Get("oncanplaythrough")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncanplaythrough(val EventHandler) {
 	d.Set("oncanplaythrough", val)
 }
 func (d Document) GetOnchange() EventHandler {
 	val := d.Get("onchange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnchange(val EventHandler) {
 	d.Set("onchange", val)
 }
 func (d Document) GetOnclick() EventHandler {
 	val := d.Get("onclick")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnclick(val EventHandler) {
 	d.Set("onclick", val)
 }
 func (d Document) GetOnclose() EventHandler {
 	val := d.Get("onclose")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnclose(val EventHandler) {
 	d.Set("onclose", val)
 }
 func (d Document) GetOncontextmenu() EventHandler {
 	val := d.Get("oncontextmenu")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncontextmenu(val EventHandler) {
 	d.Set("oncontextmenu", val)
 }
 func (d Document) GetOncopy() EventHandler {
 	val := d.Get("oncopy")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncopy(val EventHandler) {
 	d.Set("oncopy", val)
 }
 func (d Document) GetOncuechange() EventHandler {
 	val := d.Get("oncuechange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncuechange(val EventHandler) {
 	d.Set("oncuechange", val)
 }
 func (d Document) GetOncut() EventHandler {
 	val := d.Get("oncut")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOncut(val EventHandler) {
 	d.Set("oncut", val)
 }
 func (d Document) GetOndblclick() EventHandler {
 	val := d.Get("ondblclick")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndblclick(val EventHandler) {
 	d.Set("ondblclick", val)
 }
 func (d Document) GetOndrag() EventHandler {
 	val := d.Get("ondrag")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndrag(val EventHandler) {
 	d.Set("ondrag", val)
 }
 func (d Document) GetOndragend() EventHandler {
 	val := d.Get("ondragend")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragend(val EventHandler) {
 	d.Set("ondragend", val)
 }
 func (d Document) GetOndragenter() EventHandler {
 	val := d.Get("ondragenter")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragenter(val EventHandler) {
 	d.Set("ondragenter", val)
 }
 func (d Document) GetOndragexit() EventHandler {
 	val := d.Get("ondragexit")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragexit(val EventHandler) {
 	d.Set("ondragexit", val)
 }
 func (d Document) GetOndragleave() EventHandler {
 	val := d.Get("ondragleave")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragleave(val EventHandler) {
 	d.Set("ondragleave", val)
 }
 func (d Document) GetOndragover() EventHandler {
 	val := d.Get("ondragover")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragover(val EventHandler) {
 	d.Set("ondragover", val)
 }
 func (d Document) GetOndragstart() EventHandler {
 	val := d.Get("ondragstart")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndragstart(val EventHandler) {
 	d.Set("ondragstart", val)
 }
 func (d Document) GetOndrop() EventHandler {
 	val := d.Get("ondrop")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndrop(val EventHandler) {
 	d.Set("ondrop", val)
 }
 func (d Document) GetOndurationchange() EventHandler {
 	val := d.Get("ondurationchange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOndurationchange(val EventHandler) {
 	d.Set("ondurationchange", val)
 }
 func (d Document) GetOnemptied() EventHandler {
 	val := d.Get("onemptied")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnemptied(val EventHandler) {
 	d.Set("onemptied", val)
 }
 func (d Document) GetOnended() EventHandler {
 	val := d.Get("onended")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnended(val EventHandler) {
 	d.Set("onended", val)
 }
 func (d Document) GetOnerror() OnErrorEventHandler {
 	val := d.Get("onerror")
-	return jsValueToOnErrorEventHandler(val.JSValue())
+	return JSValueToOnErrorEventHandler(val.JSValue())
 }
 func (d Document) SetOnerror(val OnErrorEventHandler) {
 	d.Set("onerror", val)
 }
 func (d Document) GetOnfocus() EventHandler {
 	val := d.Get("onfocus")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnfocus(val EventHandler) {
 	d.Set("onfocus", val)
 }
 func (d Document) GetOninput() EventHandler {
 	val := d.Get("oninput")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOninput(val EventHandler) {
 	d.Set("oninput", val)
 }
 func (d Document) GetOninvalid() EventHandler {
 	val := d.Get("oninvalid")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOninvalid(val EventHandler) {
 	d.Set("oninvalid", val)
 }
 func (d Document) GetOnkeydown() EventHandler {
 	val := d.Get("onkeydown")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnkeydown(val EventHandler) {
 	d.Set("onkeydown", val)
 }
 func (d Document) GetOnkeypress() EventHandler {
 	val := d.Get("onkeypress")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnkeypress(val EventHandler) {
 	d.Set("onkeypress", val)
 }
 func (d Document) GetOnkeyup() EventHandler {
 	val := d.Get("onkeyup")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnkeyup(val EventHandler) {
 	d.Set("onkeyup", val)
 }
 func (d Document) GetOnload() EventHandler {
 	val := d.Get("onload")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnload(val EventHandler) {
 	d.Set("onload", val)
 }
 func (d Document) GetOnloadeddata() EventHandler {
 	val := d.Get("onloadeddata")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnloadeddata(val EventHandler) {
 	d.Set("onloadeddata", val)
 }
 func (d Document) GetOnloadedmetadata() EventHandler {
 	val := d.Get("onloadedmetadata")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnloadedmetadata(val EventHandler) {
 	d.Set("onloadedmetadata", val)
 }
 func (d Document) GetOnloadend() EventHandler {
 	val := d.Get("onloadend")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnloadend(val EventHandler) {
 	d.Set("onloadend", val)
 }
 func (d Document) GetOnloadstart() EventHandler {
 	val := d.Get("onloadstart")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnloadstart(val EventHandler) {
 	d.Set("onloadstart", val)
 }
 func (d Document) GetOnmousedown() EventHandler {
 	val := d.Get("onmousedown")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmousedown(val EventHandler) {
 	d.Set("onmousedown", val)
 }
 func (d Document) GetOnmouseenter() EventHandler {
 	val := d.Get("onmouseenter")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmouseenter(val EventHandler) {
 	d.Set("onmouseenter", val)
 }
 func (d Document) GetOnmouseleave() EventHandler {
 	val := d.Get("onmouseleave")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmouseleave(val EventHandler) {
 	d.Set("onmouseleave", val)
 }
 func (d Document) GetOnmousemove() EventHandler {
 	val := d.Get("onmousemove")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmousemove(val EventHandler) {
 	d.Set("onmousemove", val)
 }
 func (d Document) GetOnmouseout() EventHandler {
 	val := d.Get("onmouseout")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmouseout(val EventHandler) {
 	d.Set("onmouseout", val)
 }
 func (d Document) GetOnmouseover() EventHandler {
 	val := d.Get("onmouseover")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmouseover(val EventHandler) {
 	d.Set("onmouseover", val)
 }
 func (d Document) GetOnmouseup() EventHandler {
 	val := d.Get("onmouseup")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnmouseup(val EventHandler) {
 	d.Set("onmouseup", val)
 }
 func (d Document) GetOnpaste() EventHandler {
 	val := d.Get("onpaste")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnpaste(val EventHandler) {
 	d.Set("onpaste", val)
 }
 func (d Document) GetOnpause() EventHandler {
 	val := d.Get("onpause")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnpause(val EventHandler) {
 	d.Set("onpause", val)
 }
 func (d Document) GetOnplay() EventHandler {
 	val := d.Get("onplay")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnplay(val EventHandler) {
 	d.Set("onplay", val)
 }
 func (d Document) GetOnplaying() EventHandler {
 	val := d.Get("onplaying")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnplaying(val EventHandler) {
 	d.Set("onplaying", val)
 }
 func (d Document) GetOnprogress() EventHandler {
 	val := d.Get("onprogress")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnprogress(val EventHandler) {
 	d.Set("onprogress", val)
 }
 func (d Document) GetOnratechange() EventHandler {
 	val := d.Get("onratechange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnratechange(val EventHandler) {
 	d.Set("onratechange", val)
 }
 func (d Document) GetOnreset() EventHandler {
 	val := d.Get("onreset")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnreset(val EventHandler) {
 	d.Set("onreset", val)
 }
 func (d Document) GetOnresize() EventHandler {
 	val := d.Get("onresize")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnresize(val EventHandler) {
 	d.Set("onresize", val)
 }
 func (d Document) GetOnscroll() EventHandler {
 	val := d.Get("onscroll")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnscroll(val EventHandler) {
 	d.Set("onscroll", val)
 }
 func (d Document) GetOnsecuritypolicyviolation() EventHandler {
 	val := d.Get("onsecuritypolicyviolation")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnsecuritypolicyviolation(val EventHandler) {
 	d.Set("onsecuritypolicyviolation", val)
 }
 func (d Document) GetOnseeked() EventHandler {
 	val := d.Get("onseeked")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnseeked(val EventHandler) {
 	d.Set("onseeked", val)
 }
 func (d Document) GetOnseeking() EventHandler {
 	val := d.Get("onseeking")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnseeking(val EventHandler) {
 	d.Set("onseeking", val)
 }
 func (d Document) GetOnselect() EventHandler {
 	val := d.Get("onselect")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnselect(val EventHandler) {
 	d.Set("onselect", val)
 }
 func (d Document) GetOnstalled() EventHandler {
 	val := d.Get("onstalled")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnstalled(val EventHandler) {
 	d.Set("onstalled", val)
 }
 func (d Document) GetOnsubmit() EventHandler {
 	val := d.Get("onsubmit")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnsubmit(val EventHandler) {
 	d.Set("onsubmit", val)
 }
 func (d Document) GetOnsuspend() EventHandler {
 	val := d.Get("onsuspend")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnsuspend(val EventHandler) {
 	d.Set("onsuspend", val)
 }
 func (d Document) GetOntimeupdate() EventHandler {
 	val := d.Get("ontimeupdate")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOntimeupdate(val EventHandler) {
 	d.Set("ontimeupdate", val)
 }
 func (d Document) GetOntoggle() EventHandler {
 	val := d.Get("ontoggle")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOntoggle(val EventHandler) {
 	d.Set("ontoggle", val)
 }
 func (d Document) GetOnvolumechange() EventHandler {
 	val := d.Get("onvolumechange")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnvolumechange(val EventHandler) {
 	d.Set("onvolumechange", val)
 }
 func (d Document) GetOnwaiting() EventHandler {
 	val := d.Get("onwaiting")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnwaiting(val EventHandler) {
 	d.Set("onwaiting", val)
 }
 func (d Document) GetOnwheel() EventHandler {
 	val := d.Get("onwheel")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (d Document) SetOnwheel(val EventHandler) {
 	d.Set("onwheel", val)
@@ -811,11 +811,11 @@ func (d Document) Prepend(args ...interface{}) {
 }
 func (d Document) QuerySelector(args ...interface{}) Element {
 	val := d.Call("querySelector", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d Document) QuerySelectorAll(args ...interface{}) NodeList {
 	val := d.Call("querySelectorAll", args...)
-	return jsValueToNodeList(val.JSValue())
+	return JSValueToNodeList(val.JSValue())
 }
 func (d Document) GetURL() string {
 	val := d.Get("URL")

document/document.go

@@ -1,13 +1,518 @@
+// Code generated DO NOT EDIT
+// document/document.go
 package document
 
-import (
-	"syscall/js"
-
-	dom "github.com/brettlangdon/go-dom/v1"
-)
+import dom "github.com/brettlangdon/go-dom/v1"
+import "syscall/js"
 
 var value dom.Document
 
-func init() {
-	value = dom.Value{Value: js.Global().Get("document")}.AsDocument()
+func init() { value = dom.JSValueToDocument(js.Global().Get("document")) }
+func AddEventListener(args ...interface{}) {
+	value.Call("addEventListener", args...)
+}
+func AdoptNode(args ...interface{}) dom.Node {
+	val := value.Call("adoptNode", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func Append(args ...interface{}) {
+	value.Call("append", args...)
+}
+func AppendChild(args ...interface{}) dom.Node {
+	val := value.Call("appendChild", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func GetBaseURI() string {
+	return value.GetBaseURI()
+}
+func GetCharacterSet() string {
+	return value.GetCharacterSet()
+}
+func GetCharset() string {
+	return value.GetCharset()
+}
+func GetChildElementCount() float64 {
+	return value.GetChildElementCount()
+}
+func GetChildNodes() dom.NodeList {
+	return value.GetChildNodes()
+}
+func GetChildren() dom.HTMLCollection {
+	return value.GetChildren()
+}
+func CloneNode(args ...interface{}) dom.Node {
+	val := value.Call("cloneNode", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func CompareDocumentPosition(args ...interface{}) int {
+	val := value.Call("compareDocumentPosition", args...)
+	return val.Int()
+}
+func GetCompatMode() string {
+	return value.GetCompatMode()
+}
+func Contains(args ...interface{}) bool {
+	val := value.Call("contains", args...)
+	return val.Bool()
+}
+func GetContentType() string {
+	return value.GetContentType()
+}
+func CreateAttribute(args ...interface{}) dom.Attr {
+	val := value.Call("createAttribute", args...)
+	return dom.JSValueToAttr(val.JSValue())
+}
+func CreateAttributeNS(args ...interface{}) dom.Attr {
+	val := value.Call("createAttributeNS", args...)
+	return dom.JSValueToAttr(val.JSValue())
+}
+func CreateCDATASection(args ...interface{}) dom.CDATASection {
+	val := value.Call("createCDATASection", args...)
+	return dom.JSValueToCDATASection(val.JSValue())
+}
+func CreateComment(args ...interface{}) dom.Comment {
+	val := value.Call("createComment", args...)
+	return dom.JSValueToComment(val.JSValue())
+}
+func CreateDocumentFragment(args ...interface{}) dom.DocumentFragment {
+	val := value.Call("createDocumentFragment", args...)
+	return dom.JSValueToDocumentFragment(val.JSValue())
+}
+func CreateElement(args ...interface{}) dom.Element {
+	val := value.Call("createElement", args...)
+	return dom.JSValueToElement(val.JSValue())
+}
+func CreateElementNS(args ...interface{}) dom.Element {
+	val := value.Call("createElementNS", args...)
+	return dom.JSValueToElement(val.JSValue())
+}
+func CreateEvent(args ...interface{}) dom.Event {
+	val := value.Call("createEvent", args...)
+	return dom.JSValueToEvent(val.JSValue())
+}
+func CreateNodeIterator(args ...interface{}) dom.NodeIterator {
+	val := value.Call("createNodeIterator", args...)
+	return dom.JSValueToNodeIterator(val.JSValue())
+}
+func CreateProcessingInstruction(args ...interface{}) dom.ProcessingInstruction {
+	val := value.Call("createProcessingInstruction", args...)
+	return dom.JSValueToProcessingInstruction(val.JSValue())
+}
+func CreateRange(args ...interface{}) dom.Range {
+	val := value.Call("createRange", args...)
+	return dom.JSValueToRange(val.JSValue())
+}
+func CreateTextNode(args ...interface{}) dom.Text {
+	val := value.Call("createTextNode", args...)
+	return dom.JSValueToText(val.JSValue())
+}
+func CreateTreeWalker(args ...interface{}) dom.TreeWalker {
+	val := value.Call("createTreeWalker", args...)
+	return dom.JSValueToTreeWalker(val.JSValue())
+}
+func DispatchEvent(args ...interface{}) bool {
+	val := value.Call("dispatchEvent", args...)
+	return val.Bool()
+}
+func GetDoctype() dom.DocumentType {
+	return value.GetDoctype()
+}
+func GetDocumentElement() dom.Element {
+	return value.GetDocumentElement()
+}
+func GetDocumentURI() string {
+	return value.GetDocumentURI()
+}
+func GetFirstChild() dom.Node {
+	return value.GetFirstChild()
+}
+func GetFirstElementChild() dom.Element {
+	return value.GetFirstElementChild()
+}
+func GetElementById(args ...interface{}) dom.Element {
+	val := value.Call("getElementById", args...)
+	return dom.JSValueToElement(val.JSValue())
+}
+func GetElementsByClassName(args ...interface{}) dom.HTMLCollection {
+	val := value.Call("getElementsByClassName", args...)
+	return dom.JSValueToHTMLCollection(val.JSValue())
+}
+func GetElementsByTagName(args ...interface{}) dom.HTMLCollection {
+	val := value.Call("getElementsByTagName", args...)
+	return dom.JSValueToHTMLCollection(val.JSValue())
+}
+func GetElementsByTagNameNS(args ...interface{}) dom.HTMLCollection {
+	val := value.Call("getElementsByTagNameNS", args...)
+	return dom.JSValueToHTMLCollection(val.JSValue())
+}
+func GetRootNode(args ...interface{}) dom.Node {
+	val := value.Call("getRootNode", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func HasChildNodes(args ...interface{}) bool {
+	val := value.Call("hasChildNodes", args...)
+	return val.Bool()
+}
+func GetImplementation() dom.DOMImplementation {
+	return value.GetImplementation()
+}
+func ImportNode(args ...interface{}) dom.Node {
+	val := value.Call("importNode", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func GetInputEncoding() string {
+	return value.GetInputEncoding()
+}
+func InsertBefore(args ...interface{}) dom.Node {
+	val := value.Call("insertBefore", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func GetIsConnected() bool {
+	return value.GetIsConnected()
+}
+func IsDefaultNamespace(args ...interface{}) bool {
+	val := value.Call("isDefaultNamespace", args...)
+	return val.Bool()
+}
+func IsEqualNode(args ...interface{}) bool {
+	val := value.Call("isEqualNode", args...)
+	return val.Bool()
+}
+func IsSameNode(args ...interface{}) bool {
+	val := value.Call("isSameNode", args...)
+	return val.Bool()
+}
+func GetLastChild() dom.Node {
+	return value.GetLastChild()
+}
+func GetLastElementChild() dom.Element {
+	return value.GetLastElementChild()
+}
+func LookupNamespaceURI(args ...interface{}) string {
+	val := value.Call("lookupNamespaceURI", args...)
+	return val.String()
+}
+func LookupPrefix(args ...interface{}) string {
+	val := value.Call("lookupPrefix", args...)
+	return val.String()
+}
+func GetNextSibling() dom.Node {
+	return value.GetNextSibling()
+}
+func GetNodeName() string {
+	return value.GetNodeName()
+}
+func GetNodeType() int {
+	return value.GetNodeType()
+}
+func GetNodeValue() string {
+	return value.GetNodeValue()
+}
+func SetNodeValue(val string) { value.SetNodeValue(val) }
+func Normalize(args ...interface{}) {
+	value.Call("normalize", args...)
+}
+func GetOnabort() dom.EventHandler {
+	return value.GetOnabort()
+}
+func SetOnabort(val dom.EventHandler) { value.SetOnabort(val) }
+func GetOnauxclick() dom.EventHandler {
+	return value.GetOnauxclick()
+}
+func SetOnauxclick(val dom.EventHandler) { value.SetOnauxclick(val) }
+func GetOnblur() dom.EventHandler {
+	return value.GetOnblur()
+}
+func SetOnblur(val dom.EventHandler) { value.SetOnblur(val) }
+func GetOncancel() dom.EventHandler {
+	return value.GetOncancel()
+}
+func SetOncancel(val dom.EventHandler) { value.SetOncancel(val) }
+func GetOncanplay() dom.EventHandler {
+	return value.GetOncanplay()
+}
+func SetOncanplay(val dom.EventHandler) { value.SetOncanplay(val) }
+func GetOncanplaythrough() dom.EventHandler {
+	return value.GetOncanplaythrough()
+}
+func SetOncanplaythrough(val dom.EventHandler) { value.SetOncanplaythrough(val) }
+func GetOnchange() dom.EventHandler {
+	return value.GetOnchange()
+}
+func SetOnchange(val dom.EventHandler) { value.SetOnchange(val) }
+func GetOnclick() dom.EventHandler {
+	return value.GetOnclick()
+}
+func SetOnclick(val dom.EventHandler) { value.SetOnclick(val) }
+func GetOnclose() dom.EventHandler {
+	return value.GetOnclose()
+}
+func SetOnclose(val dom.EventHandler) { value.SetOnclose(val) }
+func GetOncontextmenu() dom.EventHandler {
+	return value.GetOncontextmenu()
+}
+func SetOncontextmenu(val dom.EventHandler) { value.SetOncontextmenu(val) }
+func GetOncopy() dom.EventHandler {
+	return value.GetOncopy()
+}
+func SetOncopy(val dom.EventHandler) { value.SetOncopy(val) }
+func GetOncuechange() dom.EventHandler {
+	return value.GetOncuechange()
+}
+func SetOncuechange(val dom.EventHandler) { value.SetOncuechange(val) }
+func GetOncut() dom.EventHandler {
+	return value.GetOncut()
+}
+func SetOncut(val dom.EventHandler) { value.SetOncut(val) }
+func GetOndblclick() dom.EventHandler {
+	return value.GetOndblclick()
+}
+func SetOndblclick(val dom.EventHandler) { value.SetOndblclick(val) }
+func GetOndrag() dom.EventHandler {
+	return value.GetOndrag()
+}
+func SetOndrag(val dom.EventHandler) { value.SetOndrag(val) }
+func GetOndragend() dom.EventHandler {
+	return value.GetOndragend()
+}
+func SetOndragend(val dom.EventHandler) { value.SetOndragend(val) }
+func GetOndragenter() dom.EventHandler {
+	return value.GetOndragenter()
+}
+func SetOndragenter(val dom.EventHandler) { value.SetOndragenter(val) }
+func GetOndragexit() dom.EventHandler {
+	return value.GetOndragexit()
+}
+func SetOndragexit(val dom.EventHandler) { value.SetOndragexit(val) }
+func GetOndragleave() dom.EventHandler {
+	return value.GetOndragleave()
+}
+func SetOndragleave(val dom.EventHandler) { value.SetOndragleave(val) }
+func GetOndragover() dom.EventHandler {
+	return value.GetOndragover()
+}
+func SetOndragover(val dom.EventHandler) { value.SetOndragover(val) }
+func GetOndragstart() dom.EventHandler {
+	return value.GetOndragstart()
+}
+func SetOndragstart(val dom.EventHandler) { value.SetOndragstart(val) }
+func GetOndrop() dom.EventHandler {
+	return value.GetOndrop()
+}
+func SetOndrop(val dom.EventHandler) { value.SetOndrop(val) }
+func GetOndurationchange() dom.EventHandler {
+	return value.GetOndurationchange()
+}
+func SetOndurationchange(val dom.EventHandler) { value.SetOndurationchange(val) }
+func GetOnemptied() dom.EventHandler {
+	return value.GetOnemptied()
+}
+func SetOnemptied(val dom.EventHandler) { value.SetOnemptied(val) }
+func GetOnended() dom.EventHandler {
+	return value.GetOnended()
+}
+func SetOnended(val dom.EventHandler) { value.SetOnended(val) }
+func GetOnerror() dom.OnErrorEventHandler {
+	return value.GetOnerror()
+}
+func SetOnerror(val dom.OnErrorEventHandler) { value.SetOnerror(val) }
+func GetOnfocus() dom.EventHandler {
+	return value.GetOnfocus()
+}
+func SetOnfocus(val dom.EventHandler) { value.SetOnfocus(val) }
+func GetOninput() dom.EventHandler {
+	return value.GetOninput()
+}
+func SetOninput(val dom.EventHandler) { value.SetOninput(val) }
+func GetOninvalid() dom.EventHandler {
+	return value.GetOninvalid()
+}
+func SetOninvalid(val dom.EventHandler) { value.SetOninvalid(val) }
+func GetOnkeydown() dom.EventHandler {
+	return value.GetOnkeydown()
+}
+func SetOnkeydown(val dom.EventHandler) { value.SetOnkeydown(val) }
+func GetOnkeypress() dom.EventHandler {
+	return value.GetOnkeypress()
+}
+func SetOnkeypress(val dom.EventHandler) { value.SetOnkeypress(val) }
+func GetOnkeyup() dom.EventHandler {
+	return value.GetOnkeyup()
+}
+func SetOnkeyup(val dom.EventHandler) { value.SetOnkeyup(val) }
+func GetOnload() dom.EventHandler {
+	return value.GetOnload()
+}
+func SetOnload(val dom.EventHandler) { value.SetOnload(val) }
+func GetOnloadeddata() dom.EventHandler {
+	return value.GetOnloadeddata()
+}
+func SetOnloadeddata(val dom.EventHandler) { value.SetOnloadeddata(val) }
+func GetOnloadedmetadata() dom.EventHandler {
+	return value.GetOnloadedmetadata()
+}
+func SetOnloadedmetadata(val dom.EventHandler) { value.SetOnloadedmetadata(val) }
+func GetOnloadend() dom.EventHandler {
+	return value.GetOnloadend()
+}
+func SetOnloadend(val dom.EventHandler) { value.SetOnloadend(val) }
+func GetOnloadstart() dom.EventHandler {
+	return value.GetOnloadstart()
+}
+func SetOnloadstart(val dom.EventHandler) { value.SetOnloadstart(val) }
+func GetOnmousedown() dom.EventHandler {
+	return value.GetOnmousedown()
+}
+func SetOnmousedown(val dom.EventHandler) { value.SetOnmousedown(val) }
+func GetOnmouseenter() dom.EventHandler {
+	return value.GetOnmouseenter()
+}
+func SetOnmouseenter(val dom.EventHandler) { value.SetOnmouseenter(val) }
+func GetOnmouseleave() dom.EventHandler {
+	return value.GetOnmouseleave()
+}
+func SetOnmouseleave(val dom.EventHandler) { value.SetOnmouseleave(val) }
+func GetOnmousemove() dom.EventHandler {
+	return value.GetOnmousemove()
+}
+func SetOnmousemove(val dom.EventHandler) { value.SetOnmousemove(val) }
+func GetOnmouseout() dom.EventHandler {
+	return value.GetOnmouseout()
+}
+func SetOnmouseout(val dom.EventHandler) { value.SetOnmouseout(val) }
+func GetOnmouseover() dom.EventHandler {
+	return value.GetOnmouseover()
+}
+func SetOnmouseover(val dom.EventHandler) { value.SetOnmouseover(val) }
+func GetOnmouseup() dom.EventHandler {
+	return value.GetOnmouseup()
+}
+func SetOnmouseup(val dom.EventHandler) { value.SetOnmouseup(val) }
+func GetOnpaste() dom.EventHandler {
+	return value.GetOnpaste()
+}
+func SetOnpaste(val dom.EventHandler) { value.SetOnpaste(val) }
+func GetOnpause() dom.EventHandler {
+	return value.GetOnpause()
+}
+func SetOnpause(val dom.EventHandler) { value.SetOnpause(val) }
+func GetOnplay() dom.EventHandler {
+	return value.GetOnplay()
+}
+func SetOnplay(val dom.EventHandler) { value.SetOnplay(val) }
+func GetOnplaying() dom.EventHandler {
+	return value.GetOnplaying()
+}
+func SetOnplaying(val dom.EventHandler) { value.SetOnplaying(val) }
+func GetOnprogress() dom.EventHandler {
+	return value.GetOnprogress()
+}
+func SetOnprogress(val dom.EventHandler) { value.SetOnprogress(val) }
+func GetOnratechange() dom.EventHandler {
+	return value.GetOnratechange()
+}
+func SetOnratechange(val dom.EventHandler) { value.SetOnratechange(val) }
+func GetOnreset() dom.EventHandler {
+	return value.GetOnreset()
+}
+func SetOnreset(val dom.EventHandler) { value.SetOnreset(val) }
+func GetOnresize() dom.EventHandler {
+	return value.GetOnresize()
+}
+func SetOnresize(val dom.EventHandler) { value.SetOnresize(val) }
+func GetOnscroll() dom.EventHandler {
+	return value.GetOnscroll()
+}
+func SetOnscroll(val dom.EventHandler) { value.SetOnscroll(val) }
+func GetOnsecuritypolicyviolation() dom.EventHandler {
+	return value.GetOnsecuritypolicyviolation()
+}
+func SetOnsecuritypolicyviolation(val dom.EventHandler) { value.SetOnsecuritypolicyviolation(val) }
+func GetOnseeked() dom.EventHandler {
+	return value.GetOnseeked()
+}
+func SetOnseeked(val dom.EventHandler) { value.SetOnseeked(val) }
+func GetOnseeking() dom.EventHandler {
+	return value.GetOnseeking()
+}
+func SetOnseeking(val dom.EventHandler) { value.SetOnseeking(val) }
+func GetOnselect() dom.EventHandler {
+	return value.GetOnselect()
+}
+func SetOnselect(val dom.EventHandler) { value.SetOnselect(val) }
+func GetOnstalled() dom.EventHandler {
+	return value.GetOnstalled()
+}
+func SetOnstalled(val dom.EventHandler) { value.SetOnstalled(val) }
+func GetOnsubmit() dom.EventHandler {
+	return value.GetOnsubmit()
+}
+func SetOnsubmit(val dom.EventHandler) { value.SetOnsubmit(val) }
+func GetOnsuspend() dom.EventHandler {
+	return value.GetOnsuspend()
+}
+func SetOnsuspend(val dom.EventHandler) { value.SetOnsuspend(val) }
+func GetOntimeupdate() dom.EventHandler {
+	return value.GetOntimeupdate()
+}
+func SetOntimeupdate(val dom.EventHandler) { value.SetOntimeupdate(val) }
+func GetOntoggle() dom.EventHandler {
+	return value.GetOntoggle()
+}
+func SetOntoggle(val dom.EventHandler) { value.SetOntoggle(val) }
+func GetOnvolumechange() dom.EventHandler {
+	return value.GetOnvolumechange()
+}
+func SetOnvolumechange(val dom.EventHandler) { value.SetOnvolumechange(val) }
+func GetOnwaiting() dom.EventHandler {
+	return value.GetOnwaiting()
+}
+func SetOnwaiting(val dom.EventHandler) { value.SetOnwaiting(val) }
+func GetOnwheel() dom.EventHandler {
+	return value.GetOnwheel()
+}
+func SetOnwheel(val dom.EventHandler) { value.SetOnwheel(val) }
+func GetOrigin() string {
+	return value.GetOrigin()
+}
+func GetOwnerDocument() dom.Document {
+	return value.GetOwnerDocument()
+}
+func GetParentElement() dom.Element {
+	return value.GetParentElement()
+}
+func GetParentNode() dom.Node {
+	return value.GetParentNode()
+}
+func Prepend(args ...interface{}) {
+	value.Call("prepend", args...)
+}
+func GetPreviousSibling() dom.Node {
+	return value.GetPreviousSibling()
+}
+func QuerySelector(args ...interface{}) dom.Element {
+	val := value.Call("querySelector", args...)
+	return dom.JSValueToElement(val.JSValue())
+}
+func QuerySelectorAll(args ...interface{}) dom.NodeList {
+	val := value.Call("querySelectorAll", args...)
+	return dom.JSValueToNodeList(val.JSValue())
+}
+func RemoveChild(args ...interface{}) dom.Node {
+	val := value.Call("removeChild", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func RemoveEventListener(args ...interface{}) {
+	value.Call("removeEventListener", args...)
+}
+func ReplaceChild(args ...interface{}) dom.Node {
+	val := value.Call("replaceChild", args...)
+	return dom.JSValueToNode(val.JSValue())
+}
+func GetTextContent() string {
+	return value.GetTextContent()
+}
+func SetTextContent(val string) { value.SetTextContent(val) }
+func GetURL() string {
+	return value.GetURL()
 }

documentfragment.go

@@ -55,7 +55,7 @@ type DocumentFragment struct {
 	EventTarget
 }
 
-func jsValueToDocumentFragment(val js.Value) DocumentFragment {
+func JSValueToDocumentFragment(val js.Value) DocumentFragment {
 	return DocumentFragment{Value: Value{Value: val}}
 }
 func (v Value) AsDocumentFragment() DocumentFragment { return DocumentFragment{Value: v} }
@@ -68,28 +68,28 @@ func (d DocumentFragment) GetChildElementCount() float64 {
 }
 func (d DocumentFragment) GetChildren() HTMLCollection {
 	val := d.Get("children")
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (d DocumentFragment) GetFirstElementChild() Element {
 	val := d.Get("firstElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d DocumentFragment) GetElementById(args ...interface{}) Element {
 	val := d.Call("getElementById", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d DocumentFragment) GetLastElementChild() Element {
 	val := d.Get("lastElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d DocumentFragment) Prepend(args ...interface{}) {
 	d.Call("prepend", args...)
 }
 func (d DocumentFragment) QuerySelector(args ...interface{}) Element {
 	val := d.Call("querySelector", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (d DocumentFragment) QuerySelectorAll(args ...interface{}) NodeList {
 	val := d.Call("querySelectorAll", args...)
-	return jsValueToNodeList(val.JSValue())
+	return JSValueToNodeList(val.JSValue())
 }

documentreadystate.go

@@ -12,6 +12,6 @@ const (
 	DocumentReadyStateComplete    DocumentReadyState = "complete"
 )
 
-func jsValueToDocumentReadyState(val js.Value) DocumentReadyState {
+func JSValueToDocumentReadyState(val js.Value) DocumentReadyState {
 	return DocumentReadyState(val.String())
 }

documenttype.go

@@ -53,7 +53,7 @@ type DocumentType struct {
 	EventTarget
 }
 
-func jsValueToDocumentType(val js.Value) DocumentType { return DocumentType{Value: Value{Value: val}} }
+func JSValueToDocumentType(val js.Value) DocumentType { return DocumentType{Value: Value{Value: val}} }
 func (v Value) AsDocumentType() DocumentType          { return DocumentType{Value: v} }
 func (d DocumentType) After(args ...interface{}) {
 	d.Call("after", args...)

domexception.go

@@ -13,7 +13,7 @@ type DOMException struct {
 	Value
 }
 
-func jsValueToDOMException(val js.Value) DOMException { return DOMException{Value: Value{Value: val}} }
+func JSValueToDOMException(val js.Value) DOMException { return DOMException{Value: Value{Value: val}} }
 func (v Value) AsDOMException() DOMException          { return DOMException{Value: v} }
 func (d DOMException) GetCode() int {
 	val := d.Get("code")

domhighrestimestamp.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type DOMHighResTimeStamp float64
 
-func jsValueToDOMHighResTimeStamp(val js.Value) DOMHighResTimeStamp {
+func JSValueToDOMHighResTimeStamp(val js.Value) DOMHighResTimeStamp {
 	return DOMHighResTimeStamp(val.Float())
 }

domimplementation.go

@@ -14,21 +14,21 @@ type DOMImplementation struct {
 	Value
 }
 
-func jsValueToDOMImplementation(val js.Value) DOMImplementation {
+func JSValueToDOMImplementation(val js.Value) DOMImplementation {
 	return DOMImplementation{Value: Value{Value: val}}
 }
 func (v Value) AsDOMImplementation() DOMImplementation { return DOMImplementation{Value: v} }
 func (d DOMImplementation) CreateDocument(args ...interface{}) XMLDocument {
 	val := d.Call("createDocument", args...)
-	return jsValueToXMLDocument(val.JSValue())
+	return JSValueToXMLDocument(val.JSValue())
 }
 func (d DOMImplementation) CreateDocumentType(args ...interface{}) DocumentType {
 	val := d.Call("createDocumentType", args...)
-	return jsValueToDocumentType(val.JSValue())
+	return JSValueToDocumentType(val.JSValue())
 }
 func (d DOMImplementation) CreateHTMLDocument(args ...interface{}) Document {
 	val := d.Call("createHTMLDocument", args...)
-	return jsValueToDocument(val.JSValue())
+	return JSValueToDocument(val.JSValue())
 }
 func (d DOMImplementation) HasFeature(args ...interface{}) bool {
 	val := d.Call("hasFeature", args...)

dommatrix.go

@@ -88,7 +88,7 @@ type DOMMatrix struct {
 	DOMMatrixReadOnly
 }
 
-func jsValueToDOMMatrix(val js.Value) DOMMatrix { return DOMMatrix{Value: Value{Value: val}} }
+func JSValueToDOMMatrix(val js.Value) DOMMatrix { return DOMMatrix{Value: Value{Value: val}} }
 func (v Value) AsDOMMatrix() DOMMatrix          { return DOMMatrix{Value: v} }
 func (d DOMMatrix) GetA() float64 {
 	val := d.Get("a")
@@ -134,19 +134,19 @@ func (d DOMMatrix) SetF(val float64) {
 }
 func (d DOMMatrix) FromFloat32Array(args ...interface{}) DOMMatrix {
 	val := d.Call("fromFloat32Array", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) FromFloat64Array(args ...interface{}) DOMMatrix {
 	val := d.Call("fromFloat64Array", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) FromMatrix(args ...interface{}) DOMMatrix {
 	val := d.Call("fromMatrix", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) InvertSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("invertSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) GetM11() float64 {
 	val := d.Get("m11")
@@ -262,45 +262,45 @@ func (d DOMMatrix) SetM44(val float64) {
 }
 func (d DOMMatrix) MultiplySelf(args ...interface{}) DOMMatrix {
 	val := d.Call("multiplySelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) PreMultiplySelf(args ...interface{}) DOMMatrix {
 	val := d.Call("preMultiplySelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) RotateAxisAngleSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("rotateAxisAngleSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) RotateFromVectorSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("rotateFromVectorSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) RotateSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("rotateSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) Scale3dSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("scale3dSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) ScaleSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("scaleSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) SetMatrixValue(args ...interface{}) DOMMatrix {
 	val := d.Call("setMatrixValue", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) SkewXSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("skewXSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) SkewYSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("skewYSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrix) TranslateSelf(args ...interface{}) DOMMatrix {
 	val := d.Call("translateSelf", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }

dommatrixreadonly.go

@@ -53,7 +53,7 @@ type DOMMatrixReadOnly struct {
 	Value
 }
 
-func jsValueToDOMMatrixReadOnly(val js.Value) DOMMatrixReadOnly {
+func JSValueToDOMMatrixReadOnly(val js.Value) DOMMatrixReadOnly {
 	return DOMMatrixReadOnly{Value: Value{Value: val}}
 }
 func (v Value) AsDOMMatrixReadOnly() DOMMatrixReadOnly { return DOMMatrixReadOnly{Value: v} }
@@ -83,27 +83,27 @@ func (d DOMMatrixReadOnly) GetF() float64 {
 }
 func (d DOMMatrixReadOnly) FlipX(args ...interface{}) DOMMatrix {
 	val := d.Call("flipX", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) FlipY(args ...interface{}) DOMMatrix {
 	val := d.Call("flipY", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) FromFloat32Array(args ...interface{}) DOMMatrixReadOnly {
 	val := d.Call("fromFloat32Array", args...)
-	return jsValueToDOMMatrixReadOnly(val.JSValue())
+	return JSValueToDOMMatrixReadOnly(val.JSValue())
 }
 func (d DOMMatrixReadOnly) FromFloat64Array(args ...interface{}) DOMMatrixReadOnly {
 	val := d.Call("fromFloat64Array", args...)
-	return jsValueToDOMMatrixReadOnly(val.JSValue())
+	return JSValueToDOMMatrixReadOnly(val.JSValue())
 }
 func (d DOMMatrixReadOnly) FromMatrix(args ...interface{}) DOMMatrixReadOnly {
 	val := d.Call("fromMatrix", args...)
-	return jsValueToDOMMatrixReadOnly(val.JSValue())
+	return JSValueToDOMMatrixReadOnly(val.JSValue())
 }
 func (d DOMMatrixReadOnly) Inverse(args ...interface{}) DOMMatrix {
 	val := d.Call("inverse", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) GetIs2D() bool {
 	val := d.Get("is2D")
@@ -179,43 +179,43 @@ func (d DOMMatrixReadOnly) GetM44() float64 {
 }
 func (d DOMMatrixReadOnly) Multiply(args ...interface{}) DOMMatrix {
 	val := d.Call("multiply", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) Rotate(args ...interface{}) DOMMatrix {
 	val := d.Call("rotate", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) RotateAxisAngle(args ...interface{}) DOMMatrix {
 	val := d.Call("rotateAxisAngle", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) RotateFromVector(args ...interface{}) DOMMatrix {
 	val := d.Call("rotateFromVector", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) Scale(args ...interface{}) DOMMatrix {
 	val := d.Call("scale", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) Scale3d(args ...interface{}) DOMMatrix {
 	val := d.Call("scale3d", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) SkewX(args ...interface{}) DOMMatrix {
 	val := d.Call("skewX", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) SkewY(args ...interface{}) DOMMatrix {
 	val := d.Call("skewY", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }
 func (d DOMMatrixReadOnly) ToFloat32Array(args ...interface{}) Float32Array {
 	val := d.Call("toFloat32Array", args...)
-	return jsValueToFloat32Array(val.JSValue())
+	return JSValueToFloat32Array(val.JSValue())
 }
 func (d DOMMatrixReadOnly) ToFloat64Array(args ...interface{}) Float64Array {
 	val := d.Call("toFloat64Array", args...)
-	return jsValueToFloat64Array(val.JSValue())
+	return JSValueToFloat64Array(val.JSValue())
 }
 func (d DOMMatrixReadOnly) ToJSON(args ...interface{}) Value {
 	val := d.Call("toJSON", args...)
@@ -223,9 +223,9 @@ func (d DOMMatrixReadOnly) ToJSON(args ...interface{}) Value {
 }
 func (d DOMMatrixReadOnly) TransformPoint(args ...interface{}) DOMPoint {
 	val := d.Call("transformPoint", args...)
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMMatrixReadOnly) Translate(args ...interface{}) DOMMatrix {
 	val := d.Call("translate", args...)
-	return jsValueToDOMMatrix(val.JSValue())
+	return JSValueToDOMMatrix(val.JSValue())
 }

dompoint.go

@@ -22,11 +22,11 @@ type DOMPoint struct {
 	DOMPointReadOnly
 }
 
-func jsValueToDOMPoint(val js.Value) DOMPoint { return DOMPoint{Value: Value{Value: val}} }
+func JSValueToDOMPoint(val js.Value) DOMPoint { return DOMPoint{Value: Value{Value: val}} }
 func (v Value) AsDOMPoint() DOMPoint          { return DOMPoint{Value: v} }
 func (d DOMPoint) FromPoint(args ...interface{}) DOMPoint {
 	val := d.Call("fromPoint", args...)
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMPoint) GetW() float64 {
 	val := d.Get("w")

dompointreadonly.go

@@ -17,17 +17,17 @@ type DOMPointReadOnly struct {
 	Value
 }
 
-func jsValueToDOMPointReadOnly(val js.Value) DOMPointReadOnly {
+func JSValueToDOMPointReadOnly(val js.Value) DOMPointReadOnly {
 	return DOMPointReadOnly{Value: Value{Value: val}}
 }
 func (v Value) AsDOMPointReadOnly() DOMPointReadOnly { return DOMPointReadOnly{Value: v} }
 func (d DOMPointReadOnly) FromPoint(args ...interface{}) DOMPointReadOnly {
 	val := d.Call("fromPoint", args...)
-	return jsValueToDOMPointReadOnly(val.JSValue())
+	return JSValueToDOMPointReadOnly(val.JSValue())
 }
 func (d DOMPointReadOnly) MatrixTransform(args ...interface{}) DOMPoint {
 	val := d.Call("matrixTransform", args...)
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMPointReadOnly) ToJSON(args ...interface{}) Value {
 	val := d.Call("toJSON", args...)

domquad.go

@@ -18,35 +18,35 @@ type DOMQuad struct {
 	Value
 }
 
-func jsValueToDOMQuad(val js.Value) DOMQuad { return DOMQuad{Value: Value{Value: val}} }
+func JSValueToDOMQuad(val js.Value) DOMQuad { return DOMQuad{Value: Value{Value: val}} }
 func (v Value) AsDOMQuad() DOMQuad          { return DOMQuad{Value: v} }
 func (d DOMQuad) FromQuad(args ...interface{}) DOMQuad {
 	val := d.Call("fromQuad", args...)
-	return jsValueToDOMQuad(val.JSValue())
+	return JSValueToDOMQuad(val.JSValue())
 }
 func (d DOMQuad) FromRect(args ...interface{}) DOMQuad {
 	val := d.Call("fromRect", args...)
-	return jsValueToDOMQuad(val.JSValue())
+	return JSValueToDOMQuad(val.JSValue())
 }
 func (d DOMQuad) GetBounds(args ...interface{}) DOMRect {
 	val := d.Call("getBounds", args...)
-	return jsValueToDOMRect(val.JSValue())
+	return JSValueToDOMRect(val.JSValue())
 }
 func (d DOMQuad) GetP1() DOMPoint {
 	val := d.Get("p1")
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMQuad) GetP2() DOMPoint {
 	val := d.Get("p2")
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMQuad) GetP3() DOMPoint {
 	val := d.Get("p3")
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMQuad) GetP4() DOMPoint {
 	val := d.Get("p4")
-	return jsValueToDOMPoint(val.JSValue())
+	return JSValueToDOMPoint(val.JSValue())
 }
 func (d DOMQuad) ToJSON(args ...interface{}) Value {
 	val := d.Call("toJSON", args...)

domrect.go

@@ -25,11 +25,11 @@ type DOMRect struct {
 	DOMRectReadOnly
 }
 
-func jsValueToDOMRect(val js.Value) DOMRect { return DOMRect{Value: Value{Value: val}} }
+func JSValueToDOMRect(val js.Value) DOMRect { return DOMRect{Value: Value{Value: val}} }
 func (v Value) AsDOMRect() DOMRect          { return DOMRect{Value: v} }
 func (d DOMRect) FromRect(args ...interface{}) DOMRect {
 	val := d.Call("fromRect", args...)
-	return jsValueToDOMRect(val.JSValue())
+	return JSValueToDOMRect(val.JSValue())
 }
 func (d DOMRect) GetHeight() float64 {
 	val := d.Get("height")

domrectlist.go

@@ -12,11 +12,11 @@ type DOMRectList struct {
 	Value
 }
 
-func jsValueToDOMRectList(val js.Value) DOMRectList { return DOMRectList{Value: Value{Value: val}} }
+func JSValueToDOMRectList(val js.Value) DOMRectList { return DOMRectList{Value: Value{Value: val}} }
 func (v Value) AsDOMRectList() DOMRectList          { return DOMRectList{Value: v} }
 func (d DOMRectList) Item(args ...interface{}) DOMRect {
 	val := d.Call("item", args...)
-	return jsValueToDOMRect(val.JSValue())
+	return JSValueToDOMRect(val.JSValue())
 }
 func (d DOMRectList) GetLength() float64 {
 	val := d.Get("length")

domrectreadonly.go

@@ -20,7 +20,7 @@ type DOMRectReadOnly struct {
 	Value
 }
 
-func jsValueToDOMRectReadOnly(val js.Value) DOMRectReadOnly {
+func JSValueToDOMRectReadOnly(val js.Value) DOMRectReadOnly {
 	return DOMRectReadOnly{Value: Value{Value: val}}
 }
 func (v Value) AsDOMRectReadOnly() DOMRectReadOnly { return DOMRectReadOnly{Value: v} }
@@ -30,7 +30,7 @@ func (d DOMRectReadOnly) GetBottom() float64 {
 }
 func (d DOMRectReadOnly) FromRect(args ...interface{}) DOMRectReadOnly {
 	val := d.Call("fromRect", args...)
-	return jsValueToDOMRectReadOnly(val.JSValue())
+	return JSValueToDOMRectReadOnly(val.JSValue())
 }
 func (d DOMRectReadOnly) GetHeight() float64 {
 	val := d.Get("height")

domstringlist.go

@@ -13,7 +13,7 @@ type DOMStringList struct {
 	Value
 }
 
-func jsValueToDOMStringList(val js.Value) DOMStringList {
+func JSValueToDOMStringList(val js.Value) DOMStringList {
 	return DOMStringList{Value: Value{Value: val}}
 }
 func (v Value) AsDOMStringList() DOMStringList { return DOMStringList{Value: v} }

domstringmap.go

@@ -10,5 +10,5 @@ type DOMStringMap struct {
 	Value
 }
 
-func jsValueToDOMStringMap(val js.Value) DOMStringMap { return DOMStringMap{Value: Value{Value: val}} }
+func JSValueToDOMStringMap(val js.Value) DOMStringMap { return DOMStringMap{Value: Value{Value: val}} }
 func (v Value) AsDOMStringMap() DOMStringMap          { return DOMStringMap{Value: v} }

domtimestamp.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type DOMTimeStamp float64
 
-func jsValueToDOMTimeStamp(val js.Value) DOMTimeStamp {
+func JSValueToDOMTimeStamp(val js.Value) DOMTimeStamp {
 	return DOMTimeStamp(val.Float())
 }

domtokenlist.go

@@ -20,7 +20,7 @@ type DOMTokenList struct {
 	Value
 }
 
-func jsValueToDOMTokenList(val js.Value) DOMTokenList { return DOMTokenList{Value: Value{Value: val}} }
+func JSValueToDOMTokenList(val js.Value) DOMTokenList { return DOMTokenList{Value: Value{Value: val}} }
 func (v Value) AsDOMTokenList() DOMTokenList          { return DOMTokenList{Value: v} }
 func (d DOMTokenList) Add(args ...interface{}) {
 	d.Call("add", args...)

dragevent.go

@@ -11,9 +11,9 @@ type DragEvent struct {
 	Value
 }
 
-func jsValueToDragEvent(val js.Value) DragEvent { return DragEvent{Value: Value{Value: val}} }
+func JSValueToDragEvent(val js.Value) DragEvent { return DragEvent{Value: Value{Value: val}} }
 func (v Value) AsDragEvent() DragEvent          { return DragEvent{Value: v} }
 func (d DragEvent) GetDataTransfer() DataTransfer {
 	val := d.Get("dataTransfer")
-	return jsValueToDataTransfer(val.JSValue())
+	return JSValueToDataTransfer(val.JSValue())
 }

element.go

@@ -99,7 +99,7 @@ type Element struct {
 	EventTarget
 }
 
-func jsValueToElement(val js.Value) Element { return Element{Value: Value{Value: val}} }
+func JSValueToElement(val js.Value) Element { return Element{Value: Value{Value: val}} }
 func (v Value) AsElement() Element          { return Element{Value: v} }
 func (e Element) After(args ...interface{}) {
 	e.Call("after", args...)
@@ -109,15 +109,15 @@ func (e Element) Append(args ...interface{}) {
 }
 func (e Element) GetAssignedSlot() HTMLSlotElement {
 	val := e.Get("assignedSlot")
-	return jsValueToHTMLSlotElement(val.JSValue())
+	return JSValueToHTMLSlotElement(val.JSValue())
 }
 func (e Element) AttachShadow(args ...interface{}) ShadowRoot {
 	val := e.Call("attachShadow", args...)
-	return jsValueToShadowRoot(val.JSValue())
+	return JSValueToShadowRoot(val.JSValue())
 }
 func (e Element) GetAttributes() NamedNodeMap {
 	val := e.Get("attributes")
-	return jsValueToNamedNodeMap(val.JSValue())
+	return JSValueToNamedNodeMap(val.JSValue())
 }
 func (e Element) Before(args ...interface{}) {
 	e.Call("before", args...)
@@ -128,11 +128,11 @@ func (e Element) GetChildElementCount() float64 {
 }
 func (e Element) GetChildren() HTMLCollection {
 	val := e.Get("children")
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (e Element) GetClassList() DOMTokenList {
 	val := e.Get("classList")
-	return jsValueToDOMTokenList(val.JSValue())
+	return JSValueToDOMTokenList(val.JSValue())
 }
 func (e Element) GetClassName() string {
 	val := e.Get("className")
@@ -143,11 +143,11 @@ func (e Element) SetClassName(val string) {
 }
 func (e Element) Closest(args ...interface{}) Element {
 	val := e.Call("closest", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) GetFirstElementChild() Element {
 	val := e.Get("firstElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) GetAttribute(args ...interface{}) string {
 	val := e.Call("getAttribute", args...)
@@ -162,23 +162,23 @@ func (e Element) GetAttributeNames(args ...interface{}) {
 }
 func (e Element) GetAttributeNode(args ...interface{}) Attr {
 	val := e.Call("getAttributeNode", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (e Element) GetAttributeNodeNS(args ...interface{}) Attr {
 	val := e.Call("getAttributeNodeNS", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (e Element) GetElementsByClassName(args ...interface{}) HTMLCollection {
 	val := e.Call("getElementsByClassName", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (e Element) GetElementsByTagName(args ...interface{}) HTMLCollection {
 	val := e.Call("getElementsByTagName", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (e Element) GetElementsByTagNameNS(args ...interface{}) HTMLCollection {
 	val := e.Call("getElementsByTagNameNS", args...)
-	return jsValueToHTMLCollection(val.JSValue())
+	return JSValueToHTMLCollection(val.JSValue())
 }
 func (e Element) HasAttribute(args ...interface{}) bool {
 	val := e.Call("hasAttribute", args...)
@@ -201,14 +201,14 @@ func (e Element) SetId(val string) {
 }
 func (e Element) InsertAdjacentElement(args ...interface{}) Element {
 	val := e.Call("insertAdjacentElement", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) InsertAdjacentText(args ...interface{}) {
 	e.Call("insertAdjacentText", args...)
 }
 func (e Element) GetLastElementChild() Element {
 	val := e.Get("lastElementChild")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) GetLocalName() string {
 	val := e.Get("localName")
@@ -224,7 +224,7 @@ func (e Element) GetNamespaceURI() string {
 }
 func (e Element) GetNextElementSibling() Element {
 	val := e.Get("nextElementSibling")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) GetPrefix() string {
 	val := e.Get("prefix")
@@ -235,15 +235,15 @@ func (e Element) Prepend(args ...interface{}) {
 }
 func (e Element) GetPreviousElementSibling() Element {
 	val := e.Get("previousElementSibling")
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) QuerySelector(args ...interface{}) Element {
 	val := e.Call("querySelector", args...)
-	return jsValueToElement(val.JSValue())
+	return JSValueToElement(val.JSValue())
 }
 func (e Element) QuerySelectorAll(args ...interface{}) NodeList {
 	val := e.Call("querySelectorAll", args...)
-	return jsValueToNodeList(val.JSValue())
+	return JSValueToNodeList(val.JSValue())
 }
 func (e Element) Remove(args ...interface{}) {
 	e.Call("remove", args...)
@@ -256,7 +256,7 @@ func (e Element) RemoveAttributeNS(args ...interface{}) {
 }
 func (e Element) RemoveAttributeNode(args ...interface{}) Attr {
 	val := e.Call("removeAttributeNode", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (e Element) ReplaceWith(args ...interface{}) {
 	e.Call("replaceWith", args...)
@@ -269,15 +269,15 @@ func (e Element) SetAttributeNS(args ...interface{}) {
 }
 func (e Element) SetAttributeNode(args ...interface{}) Attr {
 	val := e.Call("setAttributeNode", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (e Element) SetAttributeNodeNS(args ...interface{}) Attr {
 	val := e.Call("setAttributeNodeNS", args...)
-	return jsValueToAttr(val.JSValue())
+	return JSValueToAttr(val.JSValue())
 }
 func (e Element) GetShadowRoot() ShadowRoot {
 	val := e.Get("shadowRoot")
-	return jsValueToShadowRoot(val.JSValue())
+	return JSValueToShadowRoot(val.JSValue())
 }
 func (e Element) GetSlot() string {
 	val := e.Get("slot")

endingtype.go

@@ -11,6 +11,6 @@ const (
 	EndingTypeNative      EndingType = "native"
 )
 
-func jsValueToEndingType(val js.Value) EndingType {
+func JSValueToEndingType(val js.Value) EndingType {
 	return EndingType(val.String())
 }

errorevent.go

@@ -36,7 +36,7 @@ type ErrorEvent struct {
 	Event
 }
 
-func jsValueToErrorEvent(val js.Value) ErrorEvent { return ErrorEvent{Value: Value{Value: val}} }
+func JSValueToErrorEvent(val js.Value) ErrorEvent { return ErrorEvent{Value: Value{Value: val}} }
 func (v Value) AsErrorEvent() ErrorEvent          { return ErrorEvent{Value: v} }
 func (e ErrorEvent) GetColno() float64 {
 	val := e.Get("colno")

event.go

@@ -30,7 +30,7 @@ type Event struct {
 	Value
 }
 
-func jsValueToEvent(val js.Value) Event { return Event{Value: Value{Value: val}} }
+func JSValueToEvent(val js.Value) Event { return Event{Value: Value{Value: val}} }
 func (v Value) AsEvent() Event          { return Event{Value: v} }
 func (e Event) GetBubbles() bool {
 	val := e.Get("bubbles")
@@ -56,7 +56,7 @@ func (e Event) ComposedPath(args ...interface{}) {
 }
 func (e Event) GetCurrentTarget() EventTarget {
 	val := e.Get("currentTarget")
-	return jsValueToEventTarget(val.JSValue())
+	return JSValueToEventTarget(val.JSValue())
 }
 func (e Event) GetDefaultPrevented() bool {
 	val := e.Get("defaultPrevented")
@@ -85,7 +85,7 @@ func (e Event) SetReturnValue(val bool) {
 }
 func (e Event) GetSrcElement() EventTarget {
 	val := e.Get("srcElement")
-	return jsValueToEventTarget(val.JSValue())
+	return JSValueToEventTarget(val.JSValue())
 }
 func (e Event) StopImmediatePropagation(args ...interface{}) {
 	e.Call("stopImmediatePropagation", args...)
@@ -95,11 +95,11 @@ func (e Event) StopPropagation(args ...interface{}) {
 }
 func (e Event) GetTarget() EventTarget {
 	val := e.Get("target")
-	return jsValueToEventTarget(val.JSValue())
+	return JSValueToEventTarget(val.JSValue())
 }
 func (e Event) GetTimeStamp() DOMHighResTimeStamp {
 	val := e.Get("timeStamp")
-	return jsValueToDOMHighResTimeStamp(val.JSValue())
+	return JSValueToDOMHighResTimeStamp(val.JSValue())
 }
 func (e Event) GetType() string {
 	val := e.Get("type")

eventhandler.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type EventHandler EventHandlerNonNull
 
-func jsValueToEventHandler(val js.Value) EventHandler {
-	return EventHandler(jsValueToEventHandlerNonNull(val))
+func JSValueToEventHandler(val js.Value) EventHandler {
+	return EventHandler(JSValueToEventHandlerNonNull(val))
 }

eventhandlernonnull.go

@@ -9,12 +9,12 @@ type EventHandlerNonNull struct {
 	Callback
 }
 
-func jsValueToEventHandlerNonNull(val js.Value) EventHandlerNonNull {
-	return EventHandlerNonNull{Callback: jsValueToCallback(val)}
+func JSValueToEventHandlerNonNull(val js.Value) EventHandlerNonNull {
+	return EventHandlerNonNull{Callback: JSValueToCallback(val)}
 }
 func NewEventHandlerNonNull(c EventHandlerNonNullCallback) EventHandlerNonNull {
 	callback := js.NewCallback(func(args []js.Value) {
-		event := jsValueToEvent(args[0])
+		event := JSValueToEvent(args[0])
 		c(event)
 	})
 	return EventHandlerNonNull{Callback: Callback{Callback: callback}}

eventlistener.go

@@ -9,12 +9,12 @@ type EventListenerHandleEvent struct {
 	Callback
 }
 
-func jsValueToEventListenerHandleEvent(val js.Value) EventListenerHandleEvent {
-	return EventListenerHandleEvent{Callback: jsValueToCallback(val)}
+func JSValueToEventListenerHandleEvent(val js.Value) EventListenerHandleEvent {
+	return EventListenerHandleEvent{Callback: JSValueToCallback(val)}
 }
 func NewEventListenerHandleEvent(c EventListenerHandleEventCallback) EventListenerHandleEvent {
 	callback := js.NewCallback(func(args []js.Value) {
-		event := jsValueToEvent(args[0])
+		event := JSValueToEvent(args[0])
 		c(event)
 	})
 	return EventListenerHandleEvent{Callback: Callback{Callback: callback}}
@@ -25,7 +25,7 @@ type EventListener struct {
 	HandleEvent EventListenerHandleEventCallback
 }
 
-func jsValueToEventListener(val js.Value) EventListener {
+func JSValueToEventListener(val js.Value) EventListener {
 	return EventListener{Value: Value{Value: val}}
 }
 func (v Value) AsEventListener() EventListener { return EventListener{Value: v} }

eventsource.go

@@ -24,28 +24,28 @@ type EventSource struct {
 	EventTarget
 }
 
-func jsValueToEventSource(val js.Value) EventSource { return EventSource{Value: Value{Value: val}} }
+func JSValueToEventSource(val js.Value) EventSource { return EventSource{Value: Value{Value: val}} }
 func (v Value) AsEventSource() EventSource          { return EventSource{Value: v} }
 func (e EventSource) Close(args ...interface{}) {
 	e.Call("close", args...)
 }
 func (e EventSource) GetOnerror() EventHandler {
 	val := e.Get("onerror")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (e EventSource) SetOnerror(val EventHandler) {
 	e.Set("onerror", val)
 }
 func (e EventSource) GetOnmessage() EventHandler {
 	val := e.Get("onmessage")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (e EventSource) SetOnmessage(val EventHandler) {
 	e.Set("onmessage", val)
 }
 func (e EventSource) GetOnopen() EventHandler {
 	val := e.Get("onopen")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (e EventSource) SetOnopen(val EventHandler) {
 	e.Set("onopen", val)

eventtarget.go

@@ -13,7 +13,7 @@ type EventTarget struct {
 	Value
 }
 
-func jsValueToEventTarget(val js.Value) EventTarget { return EventTarget{Value: Value{Value: val}} }
+func JSValueToEventTarget(val js.Value) EventTarget { return EventTarget{Value: Value{Value: val}} }
 func (v Value) AsEventTarget() EventTarget          { return EventTarget{Value: v} }
 func (e EventTarget) AddEventListener(args ...interface{}) {
 	e.Call("addEventListener", args...)

example.go

@@ -10,5 +10,5 @@ type Example struct {
 	Value
 }
 
-func jsValueToExample(val js.Value) Example { return Example{Value: Value{Value: val}} }
+func JSValueToExample(val js.Value) Example { return Example{Value: Value{Value: val}} }
 func (v Value) AsExample() Example          { return Example{Value: v} }

external.go

@@ -12,7 +12,7 @@ type External struct {
 	Value
 }
 
-func jsValueToExternal(val js.Value) External { return External{Value: Value{Value: val}} }
+func JSValueToExternal(val js.Value) External { return External{Value: Value{Value: val}} }
 func (v Value) AsExternal() External          { return External{Value: v} }
 func (e External) AddSearchProvider(args ...interface{}) {
 	e.Call("AddSearchProvider", args...)

file.go

@@ -16,7 +16,7 @@ type File struct {
 	Blob
 }
 
-func jsValueToFile(val js.Value) File { return File{Value: Value{Value: val}} }
+func JSValueToFile(val js.Value) File { return File{Value: Value{Value: val}} }
 func (v Value) AsFile() File          { return File{Value: v} }
 func (f File) GetLastModified() float64 {
 	val := f.Get("lastModified")

filelist.go

@@ -12,11 +12,11 @@ type FileList struct {
 	Value
 }
 
-func jsValueToFileList(val js.Value) FileList { return FileList{Value: Value{Value: val}} }
+func JSValueToFileList(val js.Value) FileList { return FileList{Value: Value{Value: val}} }
 func (v Value) AsFileList() FileList          { return FileList{Value: v} }
 func (f FileList) Item(args ...interface{}) File {
 	val := f.Call("item", args...)
-	return jsValueToFile(val.JSValue())
+	return JSValueToFile(val.JSValue())
 }
 func (f FileList) GetLength() float64 {
 	val := f.Get("length")

filereader.go

@@ -34,53 +34,53 @@ type FileReader struct {
 	EventTarget
 }
 
-func jsValueToFileReader(val js.Value) FileReader { return FileReader{Value: Value{Value: val}} }
+func JSValueToFileReader(val js.Value) FileReader { return FileReader{Value: Value{Value: val}} }
 func (v Value) AsFileReader() FileReader          { return FileReader{Value: v} }
 func (f FileReader) Abort(args ...interface{}) {
 	f.Call("abort", args...)
 }
 func (f FileReader) GetError() DOMException {
 	val := f.Get("error")
-	return jsValueToDOMException(val.JSValue())
+	return JSValueToDOMException(val.JSValue())
 }
 func (f FileReader) GetOnabort() EventHandler {
 	val := f.Get("onabort")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnabort(val EventHandler) {
 	f.Set("onabort", val)
 }
 func (f FileReader) GetOnerror() EventHandler {
 	val := f.Get("onerror")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnerror(val EventHandler) {
 	f.Set("onerror", val)
 }
 func (f FileReader) GetOnload() EventHandler {
 	val := f.Get("onload")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnload(val EventHandler) {
 	f.Set("onload", val)
 }
 func (f FileReader) GetOnloadend() EventHandler {
 	val := f.Get("onloadend")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnloadend(val EventHandler) {
 	f.Set("onloadend", val)
 }
 func (f FileReader) GetOnloadstart() EventHandler {
 	val := f.Get("onloadstart")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnloadstart(val EventHandler) {
 	f.Set("onloadstart", val)
 }
 func (f FileReader) GetOnprogress() EventHandler {
 	val := f.Get("onprogress")
-	return jsValueToEventHandler(val.JSValue())
+	return JSValueToEventHandler(val.JSValue())
 }
 func (f FileReader) SetOnprogress(val EventHandler) {
 	f.Set("onprogress", val)

filereadersync.go

@@ -14,13 +14,13 @@ type FileReaderSync struct {
 	Value
 }
 
-func jsValueToFileReaderSync(val js.Value) FileReaderSync {
+func JSValueToFileReaderSync(val js.Value) FileReaderSync {
 	return FileReaderSync{Value: Value{Value: val}}
 }
 func (v Value) AsFileReaderSync() FileReaderSync { return FileReaderSync{Value: v} }
 func (f FileReaderSync) ReadAsArrayBuffer(args ...interface{}) ArrayBuffer {
 	val := f.Call("readAsArrayBuffer", args...)
-	return jsValueToArrayBuffer(val.JSValue())
+	return JSValueToArrayBuffer(val.JSValue())
 }
 func (f FileReaderSync) ReadAsBinaryString(args ...interface{}) string {
 	val := f.Call("readAsBinaryString", args...)

float32array.go

@@ -6,7 +6,7 @@ type Float32Array struct {
 	js.TypedArray
 }
 
-func jsValueToFloat32Array(val js.Value) Float32Array {
+func JSValueToFloat32Array(val js.Value) Float32Array {
 	return Float32Array{TypedArray: js.TypedArray{Value: val}}
 }
 func (u Float32Array) JSValue() js.Value { return u.TypedArray.Value }

float64array.go

@@ -6,7 +6,7 @@ type Float64Array struct {
 	js.TypedArray
 }
 
-func jsValueToFloat64Array(val js.Value) Float64Array {
+func JSValueToFloat64Array(val js.Value) Float64Array {
 	return Float64Array{TypedArray: js.TypedArray{Value: val}}
 }
 func (u Float64Array) JSValue() js.Value { return u.TypedArray.Value }

formdata.go

@@ -18,7 +18,7 @@ type FormData struct {
 	Value
 }
 
-func jsValueToFormData(val js.Value) FormData { return FormData{Value: Value{Value: val}} }
+func JSValueToFormData(val js.Value) FormData { return FormData{Value: Value{Value: val}} }
 func (v Value) AsFormData() FormData          { return FormData{Value: v} }
 func (f FormData) Append(args ...interface{}) {
 	f.Call("append", args...)
@@ -31,7 +31,7 @@ func (f FormData) Delete(args ...interface{}) {
 }
 func (f FormData) Get(args ...interface{}) FormDataEntryValue {
 	val := f.Call("get", args...)
-	return jsValueToFormDataEntryValue(val.JSValue())
+	return JSValueToFormDataEntryValue(val.JSValue())
 }
 func (f FormData) GetAll(args ...interface{}) {
 	f.Call("getAll", args...)

formdataentryvalue.go

@@ -6,6 +6,6 @@ import "syscall/js"
 
 type FormDataEntryValue Value
 
-func jsValueToFormDataEntryValue(val js.Value) FormDataEntryValue {
-	return FormDataEntryValue(jsValueToValue(val))
+func JSValueToFormDataEntryValue(val js.Value) FormDataEntryValue {
+	return FormDataEntryValue(JSValueToValue(val))
 }

framerequestcallback.go

@@ -9,12 +9,12 @@ type FrameRequestCallback struct {
 	Callback
 }
 
-func jsValueToFrameRequestCallback(val js.Value) FrameRequestCallback {
-	return FrameRequestCallback{Callback: jsValueToCallback(val)}
+func JSValueToFrameRequestCallback(val js.Value) FrameRequestCallback {
+	return FrameRequestCallback{Callback: JSValueToCallback(val)}
 }
 func NewFrameRequestCallback(c FrameRequestCallbackCallback) FrameRequestCallback {
 	callback := js.NewCallback(func(args []js.Value) {
-		time := jsValueToDOMHighResTimeStamp(args[0])
+		time := JSValueToDOMHighResTimeStamp(args[0])
 		c(time)
 	})
 	return FrameRequestCallback{Callback: Callback{Callback: callback}}

functionstringcallback.go

@@ -9,8 +9,8 @@ type FunctionStringCallback struct {
 	Callback
 }
 
-func jsValueToFunctionStringCallback(val js.Value) FunctionStringCallback {
-	return FunctionStringCallback{Callback: jsValueToCallback(val)}
+func JSValueToFunctionStringCallback(val js.Value) FunctionStringCallback {
+	return FunctionStringCallback{Callback: JSValueToCallback(val)}
 }
 func NewFunctionStringCallback(c FunctionStringCallbackCallback) FunctionStringCallback {
 	callback := js.NewCallback(func(args []js.Value) {

generate/generator.go

@@ -67,7 +67,7 @@ func (g *Generator) writeStructMember(s Spec, m Member, b *Builder) error {
 			case "Value":
 				b.WriteString("return val")
 			default:
-				b.WriteF("return jsValueTo%s(val.JSValue())", rt)
+				b.WriteF("return JSValueTo%s(val.JSValue())", rt)
 			}
 		} else {
 			b.WriteF("%s.Get(\"%s\")", s.Shortname(), m.Name)
@@ -99,7 +99,7 @@ func (g *Generator) writeStructMember(s Spec, m Member, b *Builder) error {
 			case "Value":
 				b.WriteF("return val")
 			default:
-				b.WriteF("return jsValueTo%s(val.JSValue())", rt)
+				b.WriteF("return JSValueTo%s(val.JSValue())", rt)
 			}
 		} else {
 			b.WriteF("%s.Call(\"%s\", args...)", s.Shortname(), m.Body.Name.Value)
@@ -167,7 +167,7 @@ func (g *Generator) generateInterface(spec Spec) error {
 
 	b.WriteString("}")
 
-	b.WriteF("func jsValueTo%s(val js.Value) %s { return %s{ Value: Value { Value: val }}}", spec.Name, spec.Name, spec.Name)
+	b.WriteF("func JSValueTo%s(val js.Value) %s { return %s{ Value: Value { Value: val }}}", spec.Name, spec.Name, spec.Name)
 	b.WriteF("func (v Value) As%s() %s { return %s{Value: v} }", spec.Name, spec.Name, spec.Name)
 
 	mems, err = spec.ResolveMembers(g.specs, false)
@@ -238,8 +238,8 @@ func (g *Generator) generateCallbackInterface(spec Spec) error {
 		b.WriteString("Callback")
 		b.WriteString("}")
 
-		b.WriteF("func jsValueTo%s(val js.Value) %s {", n, n)
-		b.WriteF("return %s{ Callback: jsValueToCallback(val) }", n)
+		b.WriteF("func JSValueTo%s(val js.Value) %s {", n, n)
+		b.WriteF("return %s{ Callback: JSValueToCallback(val) }", n)
 		b.WriteString("}")
 		b.WriteF("func New%s(c %sCallback) %s {", n, n, n)
 		b.WriteF("callback := js.NewCallback(func (args []js.Value) {")
@@ -264,7 +264,7 @@ func (g *Generator) generateCallbackInterface(spec Spec) error {
 			case "int":
 				b.WriteF("%s := args[%d].Int()", a.Name, i)
 			default:
-				b.WriteF("%s := jsValueTo%s(args[%d])", a.Name, t, i)
+				b.WriteF("%s := JSValueTo%s(args[%d])", a.Name, t, i)
 			}
 		}
 		b.WriteF("c(%s)", params)
@@ -284,7 +284,7 @@ func (g *Generator) generateCallbackInterface(spec Spec) error {
 
 	b.WriteString("}")
 
-	b.WriteF("func jsValueTo%s(val js.Value) %s { return %s{ Value: Value { Value: val }}}", spec.Name, spec.Name, spec.Name)
+	b.WriteF("func JSValueTo%s(val js.Value) %s { return %s{ Value: Value { Value: val }}}", spec.Name, spec.Name, spec.Name)
 	b.WriteF("func (v Value) As%s() %s { return %s{Value: v} }", spec.Name, spec.Name, spec.Name)
 	return g.writeFile(spec, b)
 }
@@ -313,8 +313,8 @@ func (g *Generator) generateCallback(spec Spec) (err error) {
 	b.WriteString("Callback")
 	b.WriteString("}")
 
-	b.WriteF("func jsValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
-	b.WriteF("return %s{ Callback: jsValueToCallback(val) }", spec.Name)
+	b.WriteF("func JSValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
+	b.WriteF("return %s{ Callback: JSValueToCallback(val) }", spec.Name)
 	b.WriteString("}")
 	b.WriteF("func New%s(c %sCallback) %s {", spec.Name, spec.Name, spec.Name)
 	b.WriteF("callback := js.NewCallback(func (args []js.Value) {")
@@ -339,7 +339,7 @@ func (g *Generator) generateCallback(spec Spec) (err error) {
 		case "int":
 			b.WriteF("%s := args[%d].Int()", a.Name, i)
 		default:
-			b.WriteF("%s := jsValueTo%s(args[%d])", a.Name, t, i)
+			b.WriteF("%s := JSValueTo%s(args[%d])", a.Name, t, i)
 		}
 	}
 	b.WriteF("c(%s)", params)
@@ -361,7 +361,7 @@ func (g *Generator) generateTypedef(spec Spec) (err error) {
 	}
 	b.WriteF("type %s %s", spec.Name, t)
 
-	b.WriteF("func jsValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
+	b.WriteF("func JSValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
 	switch t {
 	case "string":
 		b.WriteF("return %s(val.String())", spec.Name)
@@ -374,7 +374,7 @@ func (g *Generator) generateTypedef(spec Spec) (err error) {
 	case "int":
 		b.WriteF("return %s(val.Int())", spec.Name)
 	default:
-		b.WriteF("return %s(jsValueTo%s(val))", spec.Name, t)
+		b.WriteF("return %s(JSValueTo%s(val))", spec.Name, t)
 	}
 	b.WriteString("}")
 
@@ -403,7 +403,7 @@ func (g *Generator) generateEnum(spec Spec) (err error) {
 	}
 	b.WriteString(")")
 
-	b.WriteF("func jsValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
+	b.WriteF("func JSValueTo%s(val js.Value) %s {", spec.Name, spec.Name)
 	switch t {
 	case "string":
 		b.WriteF("return %s(val.String())", spec.Name)
@@ -416,7 +416,7 @@ func (g *Generator) generateEnum(spec Spec) (err error) {
 	case "int":
 		b.WriteF("return %s(val.Int())", spec.Name)
 	default:
-		b.WriteF("return %s(jsValueTo%s(val))", spec.Name, t)
+		b.WriteF("return %s(JSValueTo%s(val))", spec.Name, t)
 	}
 	b.WriteString("}")
 
@@ -435,21 +435,113 @@ func (g *Generator) generateNamespace(spec Spec) (err error) {
 	b.WriteString("// Code generated DO NOT EDIT")
 	b.WriteF("// %s", fname)
 	b.WriteF("package %s", d)
+	b.WriteString("import dom \"github.com/brettlangdon/go-dom/v1\"")
 	b.WriteString("import \"syscall/js\"")
 
-	b.WriteString("var value Value")
-	b.WriteF("func init() { value = Value{ Value: js.Global().Get(\"%s\") } }", spec.Name)
+	vt := "Value"
+	if spec.Type == "interface" {
+		vt = spec.Name
+	}
+	b.WriteF("var value dom.%s", vt)
+
+	b.WriteF("func init() { value = dom.JSValueTo%s(js.Global().Get(\"%s\")) }", vt, strings.ToLower(spec.Name))
 
-	for _, m := range spec.Members() {
+	mems, err := spec.ResolveMembers(g.specs, true)
+	if err != nil {
+		return
+	}
+
+	for _, m := range mems {
 		switch m.Type {
+		case "attribute":
+			t := convertIDLType(m.IDLType)
+			if t == "" {
+				t = "Value"
+			}
+			rt := t
+			switch rt {
+			case "string", "[]byte", "bool", "float64", "int":
+			default:
+				rt = "dom." + rt
+			}
+
+			b.WriteF("func Get%s() %s {", m.Title(), rt)
+			if spec.Type == "interface" {
+				b.WriteF("return value.Get%s()", m.Title())
+			} else {
+				if rt != "" {
+					b.WriteF("val := value.Get(\"%s\")", m.Name)
+					switch rt {
+					case "string":
+						b.WriteF("return val.String()")
+					case "[]byte":
+						b.WriteF("return []byte(val.String())")
+					case "bool":
+						b.WriteF("return val.Bool()")
+					case "float64":
+						b.WriteF("return val.Float()")
+					case "int":
+						b.WriteF("return val.Int()")
+					case "Value":
+						b.WriteString("return val")
+					default:
+						b.WriteF("return dom.JSValueTo%s(val.JSValue())", t)
+					}
+				} else {
+					b.WriteF("value.Get(\"%s\")", m.Name)
+				}
+			}
+
+			b.WriteString("}")
+
+			if !m.IsReadOnly() {
+				if spec.Type == "interface" {
+					b.WriteF("func Set%s(val %s) { value.Set%s(val) }", m.Title(), rt, m.Title())
+				} else {
+					b.WriteF("func Set%s(val %s) { value.Set(\"%s\", val) }", m.Title(), rt, m.Name)
+				}
+			}
 		case "operation":
 			n := m.Body.Name.Value
-			rt := convertIDLType(m)
-			b.WriteF("func %s(args ...interface{}) %s { return value.Call(\"%s\", args...) }", m.Title(), rt, n)
+			t := convertIDLType(m.Body.IDLType)
+			rt := t
+			switch rt {
+			case "string", "[]byte", "bool", "float64", "int":
+			case "":
+			default:
+				rt = "dom." + rt
+			}
+
+			b.WriteF("func %s(args ...interface{}) %s {", m.Title(), rt)
+			if rt != "" {
+				b.WriteF("val := value.Call(\"%s\", args...)", n)
+				switch rt {
+				case "string":
+					b.WriteString("return val.String()")
+				case "[]byte":
+					b.WriteString("return []byte(val.String())")
+				case "bool":
+					b.WriteString("return val.Bool()")
+				case "float64":
+					b.WriteString("return val.Float()")
+				case "int":
+					b.WriteString("return val.Int()")
+				case "dom.Value":
+					b.WriteString("return val")
+				default:
+					b.WriteF("return dom.JSValueTo%s(val.JSValue())", t)
+				}
+			} else {
+				b.WriteF("value.Call(\"%s\", args...)", n)
+			}
+			b.WriteString("}")
 		}
 	}
 
 	source, err := format.Source(b.Bytes())
+	if err != nil {
+		return
+	}
 	out, err := os.OpenFile(fname, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
 		return
@@ -481,6 +573,13 @@ func (g *Generator) generateSpec(spec Spec) (err error) {
 	default:
 		err = fmt.Errorf("Unknown or unsupported spec type %q", spec.Type)
 	}
+
+	if spec.Name == "Document" || spec.Name == "Window" {
+		if err == nil {
+			err = g.generateNamespace(spec)
+		}
+	}
+
 	return
 }
 

generate/static/arraybuffer.go

@@ -6,7 +6,7 @@ type ArrayBuffer struct {
 	js.TypedArray
 }
 
-func jsValueToArrayBuffer(val js.Value) ArrayBuffer {
+func JSValueToArrayBuffer(val js.Value) ArrayBuffer {
 	return ArrayBuffer{TypedArray: js.TypedArray{Value: val}}
 }
 func (u ArrayBuffer) JSValue() js.Value { return u.TypedArray.Value }