bunch of renaming

src/browser/webapi/Element.zig

@@ -59,101 +59,101 @@ pub const AttrListenerLookup = std.AutoHashMapUnmanaged(AttrListenerKey, js.Func
 /// Enum of known event listeners; increasing the size of it (u7)
 /// can cause `AttrListenerKey` to behave incorrectly.
 pub const KnownListener = enum(u7) {
-    abort,
+    onabort,
-    animationcancel,
+    onanimationcancel,
-    animationend,
+    onanimationend,
-    animationiteration,
+    onanimationiteration,
-    animationstart,
+    onanimationstart,
-    auxclick,
+    onauxclick,
-    beforeinput,
+    onbeforeinput,
-    beforematch,
+    onbeforematch,
-    beforetoggle,
+    onbeforetoggle,
-    blur,
+    onblur,
-    cancel,
+    oncancel,
-    canplay,
+    oncanplay,
-    canplaythrough,
+    oncanplaythrough,
-    change,
+    onchange,
-    click,
+    onclick,
-    close,
+    onclose,
-    command,
+    oncommand,
-    contentvisibilityautostatechange,
+    oncontentvisibilityautostatechange,
-    contextlost,
+    oncontextlost,
-    contextmenu,
+    oncontextmenu,
-    contextrestored,
+    oncontextrestored,
-    copy,
+    oncopy,
-    cuechange,
+    oncuechange,
-    cut,
+    oncut,
-    dblclick,
+    ondblclick,
-    drag,
+    ondrag,
-    dragend,
+    ondragend,
-    dragenter,
+    ondragenter,
-    dragexit,
+    ondragexit,
-    dragleave,
+    ondragleave,
-    dragover,
+    ondragover,
-    dragstart,
+    ondragstart,
-    drop,
+    ondrop,
-    durationchange,
+    ondurationchange,
-    emptied,
+    onemptied,
-    ended,
+    onended,
-    @"error",
+    onerror,
-    focus,
+    onfocus,
-    formdata,
+    onformdata,
-    fullscreenchange,
+    onfullscreenchange,
-    fullscreenerror,
+    onfullscreenerror,
-    gotpointercapture,
+    ongotpointercapture,
-    input,
+    oninput,
-    invalid,
+    oninvalid,
-    keydown,
+    onkeydown,
-    keypress,
+    onkeypress,
-    keyup,
+    onkeyup,
-    load,
+    onload,
-    loadeddata,
+    onloadeddata,
-    loadedmetadata,
+    onloadedmetadata,
-    loadstart,
+    onloadstart,
-    lostpointercapture,
+    onlostpointercapture,
-    mousedown,
+    onmousedown,
-    mousemove,
+    onmousemove,
-    mouseout,
+    onmouseout,
-    mouseover,
+    onmouseover,
-    mouseup,
+    onmouseup,
-    paste,
+    onpaste,
-    pause,
+    onpause,
-    play,
+    onplay,
-    playing,
+    onplaying,
-    pointercancel,
+    onpointercancel,
-    pointerdown,
+    onpointerdown,
-    pointerenter,
+    onpointerenter,
-    pointerleave,
+    onpointerleave,
-    pointermove,
+    onpointermove,
-    pointerout,
+    onpointerout,
-    pointerover,
+    onpointerover,
-    pointerrawupdate,
+    onpointerrawupdate,
-    pointerup,
+    onpointerup,
-    progress,
+    onprogress,
-    ratechange,
+    onratechange,
-    reset,
+    onreset,
-    resize,
+    onresize,
-    scroll,
+    onscroll,
-    scrollend,
+    onscrollend,
-    securitypolicyviolation,
+    onsecuritypolicyviolation,
-    seeked,
+    onseeked,
-    seeking,
+    onseeking,
-    select,
+    onselect,
-    selectionchange,
+    onselectionchange,
-    selectstart,
+    onselectstart,
-    slotchange,
+    onslotchange,
-    stalled,
+    onstalled,
-    submit,
+    onsubmit,
-    @"suspend",
+    onsuspend,
-    timeupdate,
+    ontimeupdate,
-    toggle,
+    ontoggle,
-    transitioncancel,
+    ontransitioncancel,
-    transitionend,
+    ontransitionend,
-    transitionrun,
+    ontransitionrun,
-    transitionstart,
+    ontransitionstart,
-    volumechange,
+    onvolumechange,
-    waiting,
+    onwaiting,
-    wheel,
+    onwheel,
 };
 
 /// Calculates a lookup key (`AttrListenerKey`) to use with `AttrListenerLookup` for an element.

src/browser/webapi/element/Html.zig

@@ -368,763 +368,763 @@ fn getAttributeFunction(
 }
 
 pub fn setOnAbort(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .abort, callback);
+    return page.setAttrListener(self.asElement(), .onabort, callback);
 }
 
 pub fn getOnAbort(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .abort);
+    return self.getAttributeFunction(.onabort, page);
 }
 
 pub fn setOnAnimationCancel(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .animationcancel, callback);
+    return page.setAttrListener(self.asElement(), .onanimationcancel, callback);
 }
 
 pub fn getOnAnimationCancel(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .animationcancel);
+    return self.getAttributeFunction(.onanimationcancel, page);
 }
 
 pub fn setOnAnimationEnd(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .animationend, callback);
+    return page.setAttrListener(self.asElement(), .onanimationend, callback);
 }
 
 pub fn getOnAnimationEnd(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .animationend);
+    return self.getAttributeFunction(.onanimationend, page);
 }
 
 pub fn setOnAnimationIteration(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .animationiteration, callback);
+    return page.setAttrListener(self.asElement(), .onanimationiteration, callback);
 }
 
 pub fn getOnAnimationIteration(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .animationiteration);
+    return self.getAttributeFunction(.onanimationiteration, page);
 }
 
 pub fn setOnAnimationStart(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .animationstart, callback);
+    return page.setAttrListener(self.asElement(), .onanimationstart, callback);
 }
 
 pub fn getOnAnimationStart(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .animationstart);
+    return self.getAttributeFunction(.onanimationstart, page);
 }
 
 pub fn setOnAuxClick(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .auxclick, callback);
+    return page.setAttrListener(self.asElement(), .onauxclick, callback);
 }
 
 pub fn getOnAuxClick(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .auxclick);
+    return self.getAttributeFunction(.onauxclick, page);
 }
 
 pub fn setOnBeforeInput(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .beforeinput, callback);
+    return page.setAttrListener(self.asElement(), .onbeforeinput, callback);
 }
 
 pub fn getOnBeforeInput(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .beforeinput);
+    return self.getAttributeFunction(.onbeforeinput, page);
 }
 
 pub fn setOnBeforeMatch(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .beforematch, callback);
+    return page.setAttrListener(self.asElement(), .onbeforematch, callback);
 }
 
 pub fn getOnBeforeMatch(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .beforematch);
+    return self.getAttributeFunction(.onbeforematch, page);
 }
 
 pub fn setOnBeforeToggle(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .beforetoggle, callback);
+    return page.setAttrListener(self.asElement(), .onbeforetoggle, callback);
 }
 
 pub fn getOnBeforeToggle(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .beforetoggle);
+    return self.getAttributeFunction(.onbeforetoggle, page);
 }
 
 pub fn setOnBlur(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .blur, callback);
+    return page.setAttrListener(self.asElement(), .onblur, callback);
 }
 
 pub fn getOnBlur(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .blur);
+    return self.getAttributeFunction(.onblur, page);
 }
 
 pub fn setOnCancel(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .cancel, callback);
+    return page.setAttrListener(self.asElement(), .oncancel, callback);
 }
 
 pub fn getOnCancel(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .cancel);
+    return self.getAttributeFunction(.oncancel, page);
 }
 
 pub fn setOnCanPlay(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .canplay, callback);
+    return page.setAttrListener(self.asElement(), .oncanplay, callback);
 }
 
 pub fn getOnCanPlay(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .canplay);
+    return self.getAttributeFunction(.oncanplay, page);
 }
 
 pub fn setOnCanPlayThrough(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .canplaythrough, callback);
+    return page.setAttrListener(self.asElement(), .oncanplaythrough, callback);
 }
 
 pub fn getOnCanPlayThrough(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .canplaythrough);
+    return self.getAttributeFunction(.oncanplaythrough, page);
 }
 
 pub fn setOnChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .change, callback);
+    return page.setAttrListener(self.asElement(), .onchange, callback);
 }
 
 pub fn getOnChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .change);
+    return self.getAttributeFunction(.onchange, page);
 }
 
 pub fn setOnClick(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .click, callback);
+    return page.setAttrListener(self.asElement(), .onclick, callback);
 }
 
 pub fn getOnClick(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .click);
+    return self.getAttributeFunction(.onclick, page);
 }
 
 pub fn setOnClose(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .close, callback);
+    return page.setAttrListener(self.asElement(), .onclose, callback);
 }
 
 pub fn getOnClose(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .close);
+    return self.getAttributeFunction(.onclose, page);
 }
 
 pub fn setOnCommand(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .command, callback);
+    return page.setAttrListener(self.asElement(), .oncommand, callback);
 }
 
 pub fn getOnCommand(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .command);
+    return self.getAttributeFunction(.oncommand, page);
 }
 
 pub fn setOnContentVisibilityAutoStateChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .contentvisibilityautostatechange, callback);
+    return page.setAttrListener(self.asElement(), .oncontentvisibilityautostatechange, callback);
 }
 
 pub fn getOnContentVisibilityAutoStateChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .contentvisibilityautostatechange);
+    return self.getAttributeFunction(.oncontentvisibilityautostatechange, page);
 }
 
 pub fn setOnContextLost(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .contextlost, callback);
+    return page.setAttrListener(self.asElement(), .oncontextlost, callback);
 }
 
 pub fn getOnContextLost(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .contextlost);
+    return self.getAttributeFunction(.oncontextlost, page);
 }
 
 pub fn setOnContextMenu(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .contextmenu, callback);
+    return page.setAttrListener(self.asElement(), .oncontextmenu, callback);
 }
 
 pub fn getOnContextMenu(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .contextmenu);
+    return self.getAttributeFunction(.oncontextmenu, page);
 }
 
 pub fn setOnContextRestored(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .contextrestored, callback);
+    return page.setAttrListener(self.asElement(), .oncontextrestored, callback);
 }
 
 pub fn getOnContextRestored(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .contextrestored);
+    return self.getAttributeFunction(.oncontextrestored, page);
 }
 
 pub fn setOnCopy(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .copy, callback);
+    return page.setAttrListener(self.asElement(), .oncopy, callback);
 }
 
 pub fn getOnCopy(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .copy);
+    return self.getAttributeFunction(.oncopy, page);
 }
 
 pub fn setOnCueChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .cuechange, callback);
+    return page.setAttrListener(self.asElement(), .oncuechange, callback);
 }
 
 pub fn getOnCueChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .cuechange);
+    return self.getAttributeFunction(.oncuechange, page);
 }
 
 pub fn setOnCut(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .cut, callback);
+    return page.setAttrListener(self.asElement(), .oncut, callback);
 }
 
 pub fn getOnCut(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .cut);
+    return self.getAttributeFunction(.oncut, page);
 }
 
 pub fn setOnDblClick(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dblclick, callback);
+    return page.setAttrListener(self.asElement(), .ondblclick, callback);
 }
 
 pub fn getOnDblClick(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dblclick);
+    return self.getAttributeFunction(.ondblclick, page);
 }
 
 pub fn setOnDrag(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .drag, callback);
+    return page.setAttrListener(self.asElement(), .ondrag, callback);
 }
 
 pub fn getOnDrag(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .drag);
+    return self.getAttributeFunction(.ondrag, page);
 }
 
 pub fn setOnDragEnd(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragend, callback);
+    return page.setAttrListener(self.asElement(), .ondragend, callback);
 }
 
 pub fn getOnDragEnd(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragend);
+    return self.getAttributeFunction(.ondragend, page);
 }
 
 pub fn setOnDragEnter(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragenter, callback);
+    return page.setAttrListener(self.asElement(), .ondragenter, callback);
 }
 
 pub fn getOnDragEnter(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragenter);
+    return self.getAttributeFunction(.ondragenter, page);
 }
 
 pub fn setOnDragExit(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragexit, callback);
+    return page.setAttrListener(self.asElement(), .ondragexit, callback);
 }
 
 pub fn getOnDragExit(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragexit);
+    return self.getAttributeFunction(.ondragexit, page);
 }
 
 pub fn setOnDragLeave(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragleave, callback);
+    return page.setAttrListener(self.asElement(), .ondragleave, callback);
 }
 
 pub fn getOnDragLeave(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragleave);
+    return self.getAttributeFunction(.ondragleave, page);
 }
 
 pub fn setOnDragOver(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragover, callback);
+    return page.setAttrListener(self.asElement(), .ondragover, callback);
 }
 
 pub fn getOnDragOver(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragover);
+    return self.getAttributeFunction(.ondragover, page);
 }
 
 pub fn setOnDragStart(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .dragstart, callback);
+    return page.setAttrListener(self.asElement(), .ondragstart, callback);
 }
 
 pub fn getOnDragStart(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .dragstart);
+    return self.getAttributeFunction(.ondragstart, page);
 }
 
 pub fn setOnDrop(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .drop, callback);
+    return page.setAttrListener(self.asElement(), .ondrop, callback);
 }
 
 pub fn getOnDrop(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .drop);
+    return self.getAttributeFunction(.ondrop, page);
 }
 
 pub fn setOnDurationChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .durationchange, callback);
+    return page.setAttrListener(self.asElement(), .ondurationchange, callback);
 }
 
 pub fn getOnDurationChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .durationchange);
+    return self.getAttributeFunction(.ondurationchange, page);
 }
 
 pub fn setOnEmptied(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .emptied, callback);
+    return page.setAttrListener(self.asElement(), .onemptied, callback);
 }
 
 pub fn getOnEmptied(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .emptied);
+    return self.getAttributeFunction(.onemptied, page);
 }
 
 pub fn setOnEnded(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .ended, callback);
+    return page.setAttrListener(self.asElement(), .onended, callback);
 }
 
 pub fn getOnEnded(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .ended);
+    return self.getAttributeFunction(.onended, page);
 }
 
 pub fn setOnError(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .@"error", callback);
+    return page.setAttrListener(self.asElement(), .onerror, callback);
 }
 
 pub fn getOnError(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .@"error");
+    return self.getAttributeFunction(.onerror, page);
 }
 
 pub fn setOnFocus(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .focus, callback);
+    return page.setAttrListener(self.asElement(), .onfocus, callback);
 }
 
 pub fn getOnFocus(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .focus);
+    return self.getAttributeFunction(.onfocus, page);
 }
 
 pub fn setOnFormData(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .formdata, callback);
+    return page.setAttrListener(self.asElement(), .onformdata, callback);
 }
 
 pub fn getOnFormData(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .formdata);
+    return self.getAttributeFunction(.onformdata, page);
 }
 
 pub fn setOnFullscreenChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .fullscreenchange, callback);
+    return page.setAttrListener(self.asElement(), .onfullscreenchange, callback);
 }
 
 pub fn getOnFullscreenChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .fullscreenchange);
+    return self.getAttributeFunction(.onfullscreenchange, page);
 }
 
 pub fn setOnFullscreenError(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .fullscreenerror, callback);
+    return page.setAttrListener(self.asElement(), .onfullscreenerror, callback);
 }
 
 pub fn getOnFullscreenError(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .fullscreenerror);
+    return self.getAttributeFunction(.onfullscreenerror, page);
 }
 
 pub fn setOnGotPointerCapture(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .gotpointercapture, callback);
+    return page.setAttrListener(self.asElement(), .ongotpointercapture, callback);
 }
 
 pub fn getOnGotPointerCapture(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .gotpointercapture);
+    return self.getAttributeFunction(.ongotpointercapture, page);
 }
 
 pub fn setOnInput(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .input, callback);
+    return page.setAttrListener(self.asElement(), .oninput, callback);
 }
 
 pub fn getOnInput(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .input);
+    return self.getAttributeFunction(.oninput, page);
 }
 
 pub fn setOnInvalid(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .invalid, callback);
+    return page.setAttrListener(self.asElement(), .oninvalid, callback);
 }
 
 pub fn getOnInvalid(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .invalid);
+    return self.getAttributeFunction(.oninvalid, page);
 }
 
 pub fn setOnKeyDown(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .keydown, callback);
+    return page.setAttrListener(self.asElement(), .onkeydown, callback);
 }
 
 pub fn getOnKeyDown(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .keydown);
+    return self.getAttributeFunction(.onkeydown, page);
 }
 
 pub fn setOnKeyPress(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .keypress, callback);
+    return page.setAttrListener(self.asElement(), .onkeypress, callback);
 }
 
 pub fn getOnKeyPress(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .keypress);
+    return self.getAttributeFunction(.onkeypress, page);
 }
 
 pub fn setOnKeyUp(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .keyup, callback);
+    return page.setAttrListener(self.asElement(), .onkeyup, callback);
 }
 
 pub fn getOnKeyUp(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .keyup);
+    return self.getAttributeFunction(.onkeyup, page);
 }
 
 pub fn setOnLoad(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .load, callback);
+    return page.setAttrListener(self.asElement(), .onload, callback);
 }
 
 pub fn getOnLoad(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .load);
+    return self.getAttributeFunction(.onload, page);
 }
 
 pub fn setOnLoadedData(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .loadeddata, callback);
+    return page.setAttrListener(self.asElement(), .onloadeddata, callback);
 }
 
 pub fn getOnLoadedData(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .loadeddata);
+    return self.getAttributeFunction(.onloadeddata, page);
 }
 
 pub fn setOnLoadedMetadata(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .loadedmetadata, callback);
+    return page.setAttrListener(self.asElement(), .onloadedmetadata, callback);
 }
 
 pub fn getOnLoadedMetadata(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .loadedmetadata);
+    return self.getAttributeFunction(.onloadedmetadata, page);
 }
 
 pub fn setOnLoadStart(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .loadstart, callback);
+    return page.setAttrListener(self.asElement(), .onloadstart, callback);
 }
 
 pub fn getOnLoadStart(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .loadstart);
+    return self.getAttributeFunction(.onloadstart, page);
 }
 
 pub fn setOnLostPointerCapture(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .lostpointercapture, callback);
+    return page.setAttrListener(self.asElement(), .onlostpointercapture, callback);
 }
 
 pub fn getOnLostPointerCapture(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .lostpointercapture);
+    return self.getAttributeFunction(.onlostpointercapture, page);
 }
 
 pub fn setOnMouseDown(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .mousedown, callback);
+    return page.setAttrListener(self.asElement(), .onmousedown, callback);
 }
 
 pub fn getOnMouseDown(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .mousedown);
+    return self.getAttributeFunction(.onmousedown, page);
 }
 
 pub fn setOnMouseMove(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .mousemove, callback);
+    return page.setAttrListener(self.asElement(), .onmousemove, callback);
 }
 
 pub fn getOnMouseMove(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .mousemove);
+    return self.getAttributeFunction(.onmousemove, page);
 }
 
 pub fn setOnMouseOut(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .mouseout, callback);
+    return page.setAttrListener(self.asElement(), .onmouseout, callback);
 }
 
 pub fn getOnMouseOut(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .mouseout);
+    return self.getAttributeFunction(.onmouseout, page);
 }
 
 pub fn setOnMouseOver(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .mouseover, callback);
+    return page.setAttrListener(self.asElement(), .onmouseover, callback);
 }
 
 pub fn getOnMouseOver(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .mouseover);
+    return self.getAttributeFunction(.onmouseover, page);
 }
 
 pub fn setOnMouseUp(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .mouseup, callback);
+    return page.setAttrListener(self.asElement(), .onmouseup, callback);
 }
 
 pub fn getOnMouseUp(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .mouseup);
+    return self.getAttributeFunction(.onmouseup, page);
 }
 
 pub fn setOnPaste(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .paste, callback);
+    return page.setAttrListener(self.asElement(), .onpaste, callback);
 }
 
 pub fn getOnPaste(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .paste);
+    return self.getAttributeFunction(.onpaste, page);
 }
 
 pub fn setOnPause(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pause, callback);
+    return page.setAttrListener(self.asElement(), .onpause, callback);
 }
 
 pub fn getOnPause(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pause);
+    return self.getAttributeFunction(.onpause, page);
 }
 
 pub fn setOnPlay(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .play, callback);
+    return page.setAttrListener(self.asElement(), .onplay, callback);
 }
 
 pub fn getOnPlay(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .play);
+    return self.getAttributeFunction(.onplay, page);
 }
 
 pub fn setOnPlaying(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .playing, callback);
+    return page.setAttrListener(self.asElement(), .onplaying, callback);
 }
 
 pub fn getOnPlaying(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .playing);
+    return self.getAttributeFunction(.onplaying, page);
 }
 
 pub fn setOnPointerCancel(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointercancel, callback);
+    return page.setAttrListener(self.asElement(), .onpointercancel, callback);
 }
 
 pub fn getOnPointerCancel(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointercancel);
+    return self.getAttributeFunction(.onpointercancel, page);
 }
 
 pub fn setOnPointerDown(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerdown, callback);
+    return page.setAttrListener(self.asElement(), .onpointerdown, callback);
 }
 
 pub fn getOnPointerDown(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerdown);
+    return self.getAttributeFunction(.onpointerdown, page);
 }
 
 pub fn setOnPointerEnter(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerenter, callback);
+    return page.setAttrListener(self.asElement(), .onpointerenter, callback);
 }
 
 pub fn getOnPointerEnter(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerenter);
+    return self.getAttributeFunction(.onpointerenter, page);
 }
 
 pub fn setOnPointerLeave(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerleave, callback);
+    return page.setAttrListener(self.asElement(), .onpointerleave, callback);
 }
 
 pub fn getOnPointerLeave(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerleave);
+    return self.getAttributeFunction(.onpointerleave, page);
 }
 
 pub fn setOnPointerMove(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointermove, callback);
+    return page.setAttrListener(self.asElement(), .onpointermove, callback);
 }
 
 pub fn getOnPointerMove(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointermove);
+    return self.getAttributeFunction(.onpointermove, page);
 }
 
 pub fn setOnPointerOut(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerout, callback);
+    return page.setAttrListener(self.asElement(), .onpointerout, callback);
 }
 
 pub fn getOnPointerOut(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerout);
+    return self.getAttributeFunction(.onpointerout, page);
 }
 
 pub fn setOnPointerOver(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerover, callback);
+    return page.setAttrListener(self.asElement(), .onpointerover, callback);
 }
 
 pub fn getOnPointerOver(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerover);
+    return self.getAttributeFunction(.onpointerover, page);
 }
 
 pub fn setOnPointerRawUpdate(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerrawupdate, callback);
+    return page.setAttrListener(self.asElement(), .onpointerrawupdate, callback);
 }
 
 pub fn getOnPointerRawUpdate(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerrawupdate);
+    return self.getAttributeFunction(.onpointerrawupdate, page);
 }
 
 pub fn setOnPointerUp(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .pointerup, callback);
+    return page.setAttrListener(self.asElement(), .onpointerup, callback);
 }
 
 pub fn getOnPointerUp(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .pointerup);
+    return self.getAttributeFunction(.onpointerup, page);
 }
 
 pub fn setOnProgress(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .progress, callback);
+    return page.setAttrListener(self.asElement(), .onprogress, callback);
 }
 
 pub fn getOnProgress(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .progress);
+    return self.getAttributeFunction(.onprogress, page);
 }
 
 pub fn setOnRateChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .ratechange, callback);
+    return page.setAttrListener(self.asElement(), .onratechange, callback);
 }
 
 pub fn getOnRateChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .ratechange);
+    return self.getAttributeFunction(.onratechange, page);
 }
 
 pub fn setOnReset(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .reset, callback);
+    return page.setAttrListener(self.asElement(), .onreset, callback);
 }
 
 pub fn getOnReset(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .reset);
+    return self.getAttributeFunction(.onreset, page);
 }
 
 pub fn setOnResize(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .resize, callback);
+    return page.setAttrListener(self.asElement(), .onresize, callback);
 }
 
 pub fn getOnResize(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .resize);
+    return self.getAttributeFunction(.onresize, page);
 }
 
 pub fn setOnScroll(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .scroll, callback);
+    return page.setAttrListener(self.asElement(), .onscroll, callback);
 }
 
 pub fn getOnScroll(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .scroll);
+    return self.getAttributeFunction(.onscroll, page);
 }
 
 pub fn setOnScrollEnd(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .scrollend, callback);
+    return page.setAttrListener(self.asElement(), .onscrollend, callback);
 }
 
 pub fn getOnScrollEnd(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .scrollend);
+    return self.getAttributeFunction(.onscrollend, page);
 }
 
 pub fn setOnSecurityPolicyViolation(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .securitypolicyviolation, callback);
+    return page.setAttrListener(self.asElement(), .onsecuritypolicyviolation, callback);
 }
 
 pub fn getOnSecurityPolicyViolation(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .securitypolicyviolation);
+    return self.getAttributeFunction(.onsecuritypolicyviolation, page);
 }
 
 pub fn setOnSeeked(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .seeked, callback);
+    return page.setAttrListener(self.asElement(), .onseeked, callback);
 }
 
 pub fn getOnSeeked(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .seeked);
+    return self.getAttributeFunction(.onseeked, page);
 }
 
 pub fn setOnSeeking(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .seeking, callback);
+    return page.setAttrListener(self.asElement(), .onseeking, callback);
 }
 
 pub fn getOnSeeking(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .seeking);
+    return self.getAttributeFunction(.onseeking, page);
 }
 
 pub fn setOnSelect(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .select, callback);
+    return page.setAttrListener(self.asElement(), .onselect, callback);
 }
 
 pub fn getOnSelect(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .select);
+    return self.getAttributeFunction(.onselect, page);
 }
 
 pub fn setOnSelectionChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .selectionchange, callback);
+    return page.setAttrListener(self.asElement(), .onselectionchange, callback);
 }
 
 pub fn getOnSelectionChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .selectionchange);
+    return self.getAttributeFunction(.onselectionchange, page);
 }
 
 pub fn setOnSelectStart(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .selectstart, callback);
+    return page.setAttrListener(self.asElement(), .onselectstart, callback);
 }
 
 pub fn getOnSelectStart(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .selectstart);
+    return self.getAttributeFunction(.onselectstart, page);
 }
 
 pub fn setOnSlotChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .slotchange, callback);
+    return page.setAttrListener(self.asElement(), .onslotchange, callback);
 }
 
 pub fn getOnSlotChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .slotchange);
+    return self.getAttributeFunction(.onslotchange, page);
 }
 
 pub fn setOnStalled(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .stalled, callback);
+    return page.setAttrListener(self.asElement(), .onstalled, callback);
 }
 
 pub fn getOnStalled(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .stalled);
+    return self.getAttributeFunction(.onstalled, page);
 }
 
 pub fn setOnSubmit(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .submit, callback);
+    return page.setAttrListener(self.asElement(), .onsubmit, callback);
 }
 
 pub fn getOnSubmit(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .submit);
+    return self.getAttributeFunction(.onsubmit, page);
 }
 
 pub fn setOnSuspend(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .@"suspend", callback);
+    return page.setAttrListener(self.asElement(), .onsuspend, callback);
 }
 
 pub fn getOnSuspend(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .@"suspend");
+    return self.getAttributeFunction(.onsuspend, page);
 }
 
 pub fn setOnTimeUpdate(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .timeupdate, callback);
+    return page.setAttrListener(self.asElement(), .ontimeupdate, callback);
 }
 
 pub fn getOnTimeUpdate(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .timeupdate);
+    return self.getAttributeFunction(.ontimeupdate, page);
 }
 
 pub fn setOnToggle(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .toggle, callback);
+    return page.setAttrListener(self.asElement(), .ontoggle, callback);
 }
 
 pub fn getOnToggle(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .toggle);
+    return self.getAttributeFunction(.ontoggle, page);
 }
 
 pub fn setOnTransitionCancel(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .transitioncancel, callback);
+    return page.setAttrListener(self.asElement(), .ontransitioncancel, callback);
 }
 
 pub fn getOnTransitionCancel(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .transitioncancel);
+    return self.getAttributeFunction(.ontransitioncancel, page);
 }
 
 pub fn setOnTransitionEnd(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .transitionend, callback);
+    return page.setAttrListener(self.asElement(), .ontransitionend, callback);
 }
 
 pub fn getOnTransitionEnd(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .transitionend);
+    return self.getAttributeFunction(.ontransitionend, page);
 }
 
 pub fn setOnTransitionRun(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .transitionrun, callback);
+    return page.setAttrListener(self.asElement(), .ontransitionrun, callback);
 }
 
 pub fn getOnTransitionRun(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .transitionrun);
+    return self.getAttributeFunction(.ontransitionrun, page);
 }
 
 pub fn setOnTransitionStart(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .transitionstart, callback);
+    return page.setAttrListener(self.asElement(), .ontransitionstart, callback);
 }
 
 pub fn getOnTransitionStart(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .transitionstart);
+    return self.getAttributeFunction(.ontransitionstart, page);
 }
 
 pub fn setOnVolumeChange(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .volumechange, callback);
+    return page.setAttrListener(self.asElement(), .onvolumechange, callback);
 }
 
 pub fn getOnVolumeChange(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .volumechange);
+    return self.getAttributeFunction(.onvolumechange, page);
 }
 
 pub fn setOnWaiting(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .waiting, callback);
+    return page.setAttrListener(self.asElement(), .onwaiting, callback);
 }
 
 pub fn getOnWaiting(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .waiting);
+    return self.getAttributeFunction(.onwaiting, page);
 }
 
 pub fn setOnWheel(self: *HtmlElement, callback: js.Function.Global, page: *Page) !void {
-    return page.setAttrListener(self.asElement(), .wheel, callback);
+    return page.setAttrListener(self.asElement(), .onwheel, callback);
 }
 
 pub fn getOnWheel(self: *HtmlElement, page: *Page) ?js.Function.Global {
-    return page.getAttrListener(self.asElement(), .wheel);
+    return self.getAttributeFunction(.onwheel, page);
 }
 
 pub const JsApi = struct {