@dooboostore/simple-web-component 1.0.49 → 1.0.51

package/dist/esm/decorators/addEventListener.js

@@ -19,7 +19,7 @@ function addEventListener(selectorOrType, typeOrOptions, maybeOptions) {
       opts = typeOrOptions ?? {};
     }
     const constructor = targetObj.constructor;
-    let listeners = ReflectUtils.getMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor);
+    let listeners = ReflectUtils.getOwnMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor);
     if (!listeners) {
       listeners = [];
       ReflectUtils.defineMetadata(ADD_EVENT_LISTENER_METADATA_KEY, listeners, constructor);
@@ -60,9 +60,6 @@ function addEventListenerShadow(selector, type, options) {
 function addEventListenerAll(selector, type, options) {
   return addEventListener(selector, type, { ...options ?? {}, root: "all" });
 }
-function addEventListenerThis(type, options) {
-  return addEventListener("$this", type, options);
-}
 function addEventListenerAppHost(type, options) {
   return addEventListener("$appHost", type, options);
 }
@@ -87,14 +84,992 @@ const eventAll = addEventListenerAll;
 const eventAppHost = addEventListenerAppHost;
 const eventWindow = addEventListenerWindow;
 const eventDocument = addEventListenerDocument;
-const eventThis = addEventListenerThis;
+function makeTypedEventDecorator(type) {
+  return (a, b, c) => {
+    if (typeof b === "string" || typeof b === "symbol") return addEventListener("$this", type)(a, b, c);
+    if (typeof a === "string" || typeof a === "function") return addEventListener(a, type, b);
+    return addEventListener("$this", type, a);
+  };
+}
+function makeBareableEventDecorator(bind) {
+  return (a, b, c) => {
+    if (typeof b === "string" || typeof b === "symbol") {
+      return bind()(a, b, c);
+    }
+    return bind(a);
+  };
+}
+function makeTypedEventAliases(type) {
+  return {
+    base: makeTypedEventDecorator(type),
+    delegateLight: (selector, options) => addEventListenerDelegateLight(selector, type, options),
+    delegateShadow: (selector, options) => addEventListenerDelegateShadow(selector, type, options),
+    delegateAll: (selector, options) => addEventListenerDelegateAll(selector, type, options),
+    delegate: (selector, options) => addEventListenerDelegate(selector, type, options),
+    mutationLight: (selector, options) => addEventListenerMutationLight(selector, type, options),
+    mutationShadow: (selector, options) => addEventListenerMutationShadow(selector, type, options),
+    mutationAll: (selector, options) => addEventListenerMutationAll(selector, type, options),
+    mutation: (selector, options) => addEventListenerMutation(selector, type, options),
+    light: (selector, options) => addEventListenerLight(selector, type, options),
+    shadow: (selector, options) => addEventListenerShadow(selector, type, options),
+    all: (selector, options) => addEventListenerAll(selector, type, options),
+    appHost: makeBareableEventDecorator((options) => addEventListenerAppHost(type, options)),
+    window: makeBareableEventDecorator((options) => addEventListenerWindow(type, options)),
+    document: makeBareableEventDecorator((options) => addEventListenerDocument(type, options))
+  };
+}
+const clickAliases = makeTypedEventAliases("click");
+const eventClick = clickAliases.base;
+const eventClickDelegateLight = clickAliases.delegateLight;
+const eventClickDelegateShadow = clickAliases.delegateShadow;
+const eventClickDelegateAll = clickAliases.delegateAll;
+const eventClickDelegate = clickAliases.delegate;
+const eventClickMutationLight = clickAliases.mutationLight;
+const eventClickMutationShadow = clickAliases.mutationShadow;
+const eventClickMutationAll = clickAliases.mutationAll;
+const eventClickMutation = clickAliases.mutation;
+const eventClickLight = clickAliases.light;
+const eventClickShadow = clickAliases.shadow;
+const eventClickAll = clickAliases.all;
+const eventClickAppHost = clickAliases.appHost;
+const eventClickWindow = clickAliases.window;
+const eventClickDocument = clickAliases.document;
+const dblclickAliases = makeTypedEventAliases("dblclick");
+const eventDblclick = dblclickAliases.base;
+const eventDblclickDelegateLight = dblclickAliases.delegateLight;
+const eventDblclickDelegateShadow = dblclickAliases.delegateShadow;
+const eventDblclickDelegateAll = dblclickAliases.delegateAll;
+const eventDblclickDelegate = dblclickAliases.delegate;
+const eventDblclickMutationLight = dblclickAliases.mutationLight;
+const eventDblclickMutationShadow = dblclickAliases.mutationShadow;
+const eventDblclickMutationAll = dblclickAliases.mutationAll;
+const eventDblclickMutation = dblclickAliases.mutation;
+const eventDblclickLight = dblclickAliases.light;
+const eventDblclickShadow = dblclickAliases.shadow;
+const eventDblclickAll = dblclickAliases.all;
+const eventDblclickAppHost = dblclickAliases.appHost;
+const eventDblclickWindow = dblclickAliases.window;
+const eventDblclickDocument = dblclickAliases.document;
+const mousedownAliases = makeTypedEventAliases("mousedown");
+const eventMousedown = mousedownAliases.base;
+const eventMousedownDelegateLight = mousedownAliases.delegateLight;
+const eventMousedownDelegateShadow = mousedownAliases.delegateShadow;
+const eventMousedownDelegateAll = mousedownAliases.delegateAll;
+const eventMousedownDelegate = mousedownAliases.delegate;
+const eventMousedownMutationLight = mousedownAliases.mutationLight;
+const eventMousedownMutationShadow = mousedownAliases.mutationShadow;
+const eventMousedownMutationAll = mousedownAliases.mutationAll;
+const eventMousedownMutation = mousedownAliases.mutation;
+const eventMousedownLight = mousedownAliases.light;
+const eventMousedownShadow = mousedownAliases.shadow;
+const eventMousedownAll = mousedownAliases.all;
+const eventMousedownAppHost = mousedownAliases.appHost;
+const eventMousedownWindow = mousedownAliases.window;
+const eventMousedownDocument = mousedownAliases.document;
+const mouseupAliases = makeTypedEventAliases("mouseup");
+const eventMouseup = mouseupAliases.base;
+const eventMouseupDelegateLight = mouseupAliases.delegateLight;
+const eventMouseupDelegateShadow = mouseupAliases.delegateShadow;
+const eventMouseupDelegateAll = mouseupAliases.delegateAll;
+const eventMouseupDelegate = mouseupAliases.delegate;
+const eventMouseupMutationLight = mouseupAliases.mutationLight;
+const eventMouseupMutationShadow = mouseupAliases.mutationShadow;
+const eventMouseupMutationAll = mouseupAliases.mutationAll;
+const eventMouseupMutation = mouseupAliases.mutation;
+const eventMouseupLight = mouseupAliases.light;
+const eventMouseupShadow = mouseupAliases.shadow;
+const eventMouseupAll = mouseupAliases.all;
+const eventMouseupAppHost = mouseupAliases.appHost;
+const eventMouseupWindow = mouseupAliases.window;
+const eventMouseupDocument = mouseupAliases.document;
+const mousemoveAliases = makeTypedEventAliases("mousemove");
+const eventMousemove = mousemoveAliases.base;
+const eventMousemoveDelegateLight = mousemoveAliases.delegateLight;
+const eventMousemoveDelegateShadow = mousemoveAliases.delegateShadow;
+const eventMousemoveDelegateAll = mousemoveAliases.delegateAll;
+const eventMousemoveDelegate = mousemoveAliases.delegate;
+const eventMousemoveMutationLight = mousemoveAliases.mutationLight;
+const eventMousemoveMutationShadow = mousemoveAliases.mutationShadow;
+const eventMousemoveMutationAll = mousemoveAliases.mutationAll;
+const eventMousemoveMutation = mousemoveAliases.mutation;
+const eventMousemoveLight = mousemoveAliases.light;
+const eventMousemoveShadow = mousemoveAliases.shadow;
+const eventMousemoveAll = mousemoveAliases.all;
+const eventMousemoveAppHost = mousemoveAliases.appHost;
+const eventMousemoveWindow = mousemoveAliases.window;
+const eventMousemoveDocument = mousemoveAliases.document;
+const mouseoverAliases = makeTypedEventAliases("mouseover");
+const eventMouseover = mouseoverAliases.base;
+const eventMouseoverDelegateLight = mouseoverAliases.delegateLight;
+const eventMouseoverDelegateShadow = mouseoverAliases.delegateShadow;
+const eventMouseoverDelegateAll = mouseoverAliases.delegateAll;
+const eventMouseoverDelegate = mouseoverAliases.delegate;
+const eventMouseoverMutationLight = mouseoverAliases.mutationLight;
+const eventMouseoverMutationShadow = mouseoverAliases.mutationShadow;
+const eventMouseoverMutationAll = mouseoverAliases.mutationAll;
+const eventMouseoverMutation = mouseoverAliases.mutation;
+const eventMouseoverLight = mouseoverAliases.light;
+const eventMouseoverShadow = mouseoverAliases.shadow;
+const eventMouseoverAll = mouseoverAliases.all;
+const eventMouseoverAppHost = mouseoverAliases.appHost;
+const eventMouseoverWindow = mouseoverAliases.window;
+const eventMouseoverDocument = mouseoverAliases.document;
+const mouseoutAliases = makeTypedEventAliases("mouseout");
+const eventMouseout = mouseoutAliases.base;
+const eventMouseoutDelegateLight = mouseoutAliases.delegateLight;
+const eventMouseoutDelegateShadow = mouseoutAliases.delegateShadow;
+const eventMouseoutDelegateAll = mouseoutAliases.delegateAll;
+const eventMouseoutDelegate = mouseoutAliases.delegate;
+const eventMouseoutMutationLight = mouseoutAliases.mutationLight;
+const eventMouseoutMutationShadow = mouseoutAliases.mutationShadow;
+const eventMouseoutMutationAll = mouseoutAliases.mutationAll;
+const eventMouseoutMutation = mouseoutAliases.mutation;
+const eventMouseoutLight = mouseoutAliases.light;
+const eventMouseoutShadow = mouseoutAliases.shadow;
+const eventMouseoutAll = mouseoutAliases.all;
+const eventMouseoutAppHost = mouseoutAliases.appHost;
+const eventMouseoutWindow = mouseoutAliases.window;
+const eventMouseoutDocument = mouseoutAliases.document;
+const mouseenterAliases = makeTypedEventAliases("mouseenter");
+const eventMouseenter = mouseenterAliases.base;
+const eventMouseenterDelegateLight = mouseenterAliases.delegateLight;
+const eventMouseenterDelegateShadow = mouseenterAliases.delegateShadow;
+const eventMouseenterDelegateAll = mouseenterAliases.delegateAll;
+const eventMouseenterDelegate = mouseenterAliases.delegate;
+const eventMouseenterMutationLight = mouseenterAliases.mutationLight;
+const eventMouseenterMutationShadow = mouseenterAliases.mutationShadow;
+const eventMouseenterMutationAll = mouseenterAliases.mutationAll;
+const eventMouseenterMutation = mouseenterAliases.mutation;
+const eventMouseenterLight = mouseenterAliases.light;
+const eventMouseenterShadow = mouseenterAliases.shadow;
+const eventMouseenterAll = mouseenterAliases.all;
+const eventMouseenterAppHost = mouseenterAliases.appHost;
+const eventMouseenterWindow = mouseenterAliases.window;
+const eventMouseenterDocument = mouseenterAliases.document;
+const mouseleaveAliases = makeTypedEventAliases("mouseleave");
+const eventMouseleave = mouseleaveAliases.base;
+const eventMouseleaveDelegateLight = mouseleaveAliases.delegateLight;
+const eventMouseleaveDelegateShadow = mouseleaveAliases.delegateShadow;
+const eventMouseleaveDelegateAll = mouseleaveAliases.delegateAll;
+const eventMouseleaveDelegate = mouseleaveAliases.delegate;
+const eventMouseleaveMutationLight = mouseleaveAliases.mutationLight;
+const eventMouseleaveMutationShadow = mouseleaveAliases.mutationShadow;
+const eventMouseleaveMutationAll = mouseleaveAliases.mutationAll;
+const eventMouseleaveMutation = mouseleaveAliases.mutation;
+const eventMouseleaveLight = mouseleaveAliases.light;
+const eventMouseleaveShadow = mouseleaveAliases.shadow;
+const eventMouseleaveAll = mouseleaveAliases.all;
+const eventMouseleaveAppHost = mouseleaveAliases.appHost;
+const eventMouseleaveWindow = mouseleaveAliases.window;
+const eventMouseleaveDocument = mouseleaveAliases.document;
+const contextmenuAliases = makeTypedEventAliases("contextmenu");
+const eventContextmenu = contextmenuAliases.base;
+const eventContextmenuDelegateLight = contextmenuAliases.delegateLight;
+const eventContextmenuDelegateShadow = contextmenuAliases.delegateShadow;
+const eventContextmenuDelegateAll = contextmenuAliases.delegateAll;
+const eventContextmenuDelegate = contextmenuAliases.delegate;
+const eventContextmenuMutationLight = contextmenuAliases.mutationLight;
+const eventContextmenuMutationShadow = contextmenuAliases.mutationShadow;
+const eventContextmenuMutationAll = contextmenuAliases.mutationAll;
+const eventContextmenuMutation = contextmenuAliases.mutation;
+const eventContextmenuLight = contextmenuAliases.light;
+const eventContextmenuShadow = contextmenuAliases.shadow;
+const eventContextmenuAll = contextmenuAliases.all;
+const eventContextmenuAppHost = contextmenuAliases.appHost;
+const eventContextmenuWindow = contextmenuAliases.window;
+const eventContextmenuDocument = contextmenuAliases.document;
+const wheelAliases = makeTypedEventAliases("wheel");
+const eventWheel = wheelAliases.base;
+const eventWheelDelegateLight = wheelAliases.delegateLight;
+const eventWheelDelegateShadow = wheelAliases.delegateShadow;
+const eventWheelDelegateAll = wheelAliases.delegateAll;
+const eventWheelDelegate = wheelAliases.delegate;
+const eventWheelMutationLight = wheelAliases.mutationLight;
+const eventWheelMutationShadow = wheelAliases.mutationShadow;
+const eventWheelMutationAll = wheelAliases.mutationAll;
+const eventWheelMutation = wheelAliases.mutation;
+const eventWheelLight = wheelAliases.light;
+const eventWheelShadow = wheelAliases.shadow;
+const eventWheelAll = wheelAliases.all;
+const eventWheelAppHost = wheelAliases.appHost;
+const eventWheelWindow = wheelAliases.window;
+const eventWheelDocument = wheelAliases.document;
+const keydownAliases = makeTypedEventAliases("keydown");
+const eventKeydown = keydownAliases.base;
+const eventKeydownDelegateLight = keydownAliases.delegateLight;
+const eventKeydownDelegateShadow = keydownAliases.delegateShadow;
+const eventKeydownDelegateAll = keydownAliases.delegateAll;
+const eventKeydownDelegate = keydownAliases.delegate;
+const eventKeydownMutationLight = keydownAliases.mutationLight;
+const eventKeydownMutationShadow = keydownAliases.mutationShadow;
+const eventKeydownMutationAll = keydownAliases.mutationAll;
+const eventKeydownMutation = keydownAliases.mutation;
+const eventKeydownLight = keydownAliases.light;
+const eventKeydownShadow = keydownAliases.shadow;
+const eventKeydownAll = keydownAliases.all;
+const eventKeydownAppHost = keydownAliases.appHost;
+const eventKeydownWindow = keydownAliases.window;
+const eventKeydownDocument = keydownAliases.document;
+const keyupAliases = makeTypedEventAliases("keyup");
+const eventKeyup = keyupAliases.base;
+const eventKeyupDelegateLight = keyupAliases.delegateLight;
+const eventKeyupDelegateShadow = keyupAliases.delegateShadow;
+const eventKeyupDelegateAll = keyupAliases.delegateAll;
+const eventKeyupDelegate = keyupAliases.delegate;
+const eventKeyupMutationLight = keyupAliases.mutationLight;
+const eventKeyupMutationShadow = keyupAliases.mutationShadow;
+const eventKeyupMutationAll = keyupAliases.mutationAll;
+const eventKeyupMutation = keyupAliases.mutation;
+const eventKeyupLight = keyupAliases.light;
+const eventKeyupShadow = keyupAliases.shadow;
+const eventKeyupAll = keyupAliases.all;
+const eventKeyupAppHost = keyupAliases.appHost;
+const eventKeyupWindow = keyupAliases.window;
+const eventKeyupDocument = keyupAliases.document;
+const keypressAliases = makeTypedEventAliases("keypress");
+const eventKeypress = keypressAliases.base;
+const eventKeypressDelegateLight = keypressAliases.delegateLight;
+const eventKeypressDelegateShadow = keypressAliases.delegateShadow;
+const eventKeypressDelegateAll = keypressAliases.delegateAll;
+const eventKeypressDelegate = keypressAliases.delegate;
+const eventKeypressMutationLight = keypressAliases.mutationLight;
+const eventKeypressMutationShadow = keypressAliases.mutationShadow;
+const eventKeypressMutationAll = keypressAliases.mutationAll;
+const eventKeypressMutation = keypressAliases.mutation;
+const eventKeypressLight = keypressAliases.light;
+const eventKeypressShadow = keypressAliases.shadow;
+const eventKeypressAll = keypressAliases.all;
+const eventKeypressAppHost = keypressAliases.appHost;
+const eventKeypressWindow = keypressAliases.window;
+const eventKeypressDocument = keypressAliases.document;
+const inputAliases = makeTypedEventAliases("input");
+const eventInput = inputAliases.base;
+const eventInputDelegateLight = inputAliases.delegateLight;
+const eventInputDelegateShadow = inputAliases.delegateShadow;
+const eventInputDelegateAll = inputAliases.delegateAll;
+const eventInputDelegate = inputAliases.delegate;
+const eventInputMutationLight = inputAliases.mutationLight;
+const eventInputMutationShadow = inputAliases.mutationShadow;
+const eventInputMutationAll = inputAliases.mutationAll;
+const eventInputMutation = inputAliases.mutation;
+const eventInputLight = inputAliases.light;
+const eventInputShadow = inputAliases.shadow;
+const eventInputAll = inputAliases.all;
+const eventInputAppHost = inputAliases.appHost;
+const eventInputWindow = inputAliases.window;
+const eventInputDocument = inputAliases.document;
+const changeAliases = makeTypedEventAliases("change");
+const eventChange = changeAliases.base;
+const eventChangeDelegateLight = changeAliases.delegateLight;
+const eventChangeDelegateShadow = changeAliases.delegateShadow;
+const eventChangeDelegateAll = changeAliases.delegateAll;
+const eventChangeDelegate = changeAliases.delegate;
+const eventChangeMutationLight = changeAliases.mutationLight;
+const eventChangeMutationShadow = changeAliases.mutationShadow;
+const eventChangeMutationAll = changeAliases.mutationAll;
+const eventChangeMutation = changeAliases.mutation;
+const eventChangeLight = changeAliases.light;
+const eventChangeShadow = changeAliases.shadow;
+const eventChangeAll = changeAliases.all;
+const eventChangeAppHost = changeAliases.appHost;
+const eventChangeWindow = changeAliases.window;
+const eventChangeDocument = changeAliases.document;
+const submitAliases = makeTypedEventAliases("submit");
+const eventSubmit = submitAliases.base;
+const eventSubmitDelegateLight = submitAliases.delegateLight;
+const eventSubmitDelegateShadow = submitAliases.delegateShadow;
+const eventSubmitDelegateAll = submitAliases.delegateAll;
+const eventSubmitDelegate = submitAliases.delegate;
+const eventSubmitMutationLight = submitAliases.mutationLight;
+const eventSubmitMutationShadow = submitAliases.mutationShadow;
+const eventSubmitMutationAll = submitAliases.mutationAll;
+const eventSubmitMutation = submitAliases.mutation;
+const eventSubmitLight = submitAliases.light;
+const eventSubmitShadow = submitAliases.shadow;
+const eventSubmitAll = submitAliases.all;
+const eventSubmitAppHost = submitAliases.appHost;
+const eventSubmitWindow = submitAliases.window;
+const eventSubmitDocument = submitAliases.document;
+const resetAliases = makeTypedEventAliases("reset");
+const eventReset = resetAliases.base;
+const eventResetDelegateLight = resetAliases.delegateLight;
+const eventResetDelegateShadow = resetAliases.delegateShadow;
+const eventResetDelegateAll = resetAliases.delegateAll;
+const eventResetDelegate = resetAliases.delegate;
+const eventResetMutationLight = resetAliases.mutationLight;
+const eventResetMutationShadow = resetAliases.mutationShadow;
+const eventResetMutationAll = resetAliases.mutationAll;
+const eventResetMutation = resetAliases.mutation;
+const eventResetLight = resetAliases.light;
+const eventResetShadow = resetAliases.shadow;
+const eventResetAll = resetAliases.all;
+const eventResetAppHost = resetAliases.appHost;
+const eventResetWindow = resetAliases.window;
+const eventResetDocument = resetAliases.document;
+const invalidAliases = makeTypedEventAliases("invalid");
+const eventInvalid = invalidAliases.base;
+const eventInvalidDelegateLight = invalidAliases.delegateLight;
+const eventInvalidDelegateShadow = invalidAliases.delegateShadow;
+const eventInvalidDelegateAll = invalidAliases.delegateAll;
+const eventInvalidDelegate = invalidAliases.delegate;
+const eventInvalidMutationLight = invalidAliases.mutationLight;
+const eventInvalidMutationShadow = invalidAliases.mutationShadow;
+const eventInvalidMutationAll = invalidAliases.mutationAll;
+const eventInvalidMutation = invalidAliases.mutation;
+const eventInvalidLight = invalidAliases.light;
+const eventInvalidShadow = invalidAliases.shadow;
+const eventInvalidAll = invalidAliases.all;
+const eventInvalidAppHost = invalidAliases.appHost;
+const eventInvalidWindow = invalidAliases.window;
+const eventInvalidDocument = invalidAliases.document;
+const selectAliases = makeTypedEventAliases("select");
+const eventSelect = selectAliases.base;
+const eventSelectDelegateLight = selectAliases.delegateLight;
+const eventSelectDelegateShadow = selectAliases.delegateShadow;
+const eventSelectDelegateAll = selectAliases.delegateAll;
+const eventSelectDelegate = selectAliases.delegate;
+const eventSelectMutationLight = selectAliases.mutationLight;
+const eventSelectMutationShadow = selectAliases.mutationShadow;
+const eventSelectMutationAll = selectAliases.mutationAll;
+const eventSelectMutation = selectAliases.mutation;
+const eventSelectLight = selectAliases.light;
+const eventSelectShadow = selectAliases.shadow;
+const eventSelectAll = selectAliases.all;
+const eventSelectAppHost = selectAliases.appHost;
+const eventSelectWindow = selectAliases.window;
+const eventSelectDocument = selectAliases.document;
+const focusAliases = makeTypedEventAliases("focus");
+const eventFocus = focusAliases.base;
+const eventFocusDelegateLight = focusAliases.delegateLight;
+const eventFocusDelegateShadow = focusAliases.delegateShadow;
+const eventFocusDelegateAll = focusAliases.delegateAll;
+const eventFocusDelegate = focusAliases.delegate;
+const eventFocusMutationLight = focusAliases.mutationLight;
+const eventFocusMutationShadow = focusAliases.mutationShadow;
+const eventFocusMutationAll = focusAliases.mutationAll;
+const eventFocusMutation = focusAliases.mutation;
+const eventFocusLight = focusAliases.light;
+const eventFocusShadow = focusAliases.shadow;
+const eventFocusAll = focusAliases.all;
+const eventFocusAppHost = focusAliases.appHost;
+const eventFocusWindow = focusAliases.window;
+const eventFocusDocument = focusAliases.document;
+const blurAliases = makeTypedEventAliases("blur");
+const eventBlur = blurAliases.base;
+const eventBlurDelegateLight = blurAliases.delegateLight;
+const eventBlurDelegateShadow = blurAliases.delegateShadow;
+const eventBlurDelegateAll = blurAliases.delegateAll;
+const eventBlurDelegate = blurAliases.delegate;
+const eventBlurMutationLight = blurAliases.mutationLight;
+const eventBlurMutationShadow = blurAliases.mutationShadow;
+const eventBlurMutationAll = blurAliases.mutationAll;
+const eventBlurMutation = blurAliases.mutation;
+const eventBlurLight = blurAliases.light;
+const eventBlurShadow = blurAliases.shadow;
+const eventBlurAll = blurAliases.all;
+const eventBlurAppHost = blurAliases.appHost;
+const eventBlurWindow = blurAliases.window;
+const eventBlurDocument = blurAliases.document;
+const focusinAliases = makeTypedEventAliases("focusin");
+const eventFocusin = focusinAliases.base;
+const eventFocusinDelegateLight = focusinAliases.delegateLight;
+const eventFocusinDelegateShadow = focusinAliases.delegateShadow;
+const eventFocusinDelegateAll = focusinAliases.delegateAll;
+const eventFocusinDelegate = focusinAliases.delegate;
+const eventFocusinMutationLight = focusinAliases.mutationLight;
+const eventFocusinMutationShadow = focusinAliases.mutationShadow;
+const eventFocusinMutationAll = focusinAliases.mutationAll;
+const eventFocusinMutation = focusinAliases.mutation;
+const eventFocusinLight = focusinAliases.light;
+const eventFocusinShadow = focusinAliases.shadow;
+const eventFocusinAll = focusinAliases.all;
+const eventFocusinAppHost = focusinAliases.appHost;
+const eventFocusinWindow = focusinAliases.window;
+const eventFocusinDocument = focusinAliases.document;
+const focusoutAliases = makeTypedEventAliases("focusout");
+const eventFocusout = focusoutAliases.base;
+const eventFocusoutDelegateLight = focusoutAliases.delegateLight;
+const eventFocusoutDelegateShadow = focusoutAliases.delegateShadow;
+const eventFocusoutDelegateAll = focusoutAliases.delegateAll;
+const eventFocusoutDelegate = focusoutAliases.delegate;
+const eventFocusoutMutationLight = focusoutAliases.mutationLight;
+const eventFocusoutMutationShadow = focusoutAliases.mutationShadow;
+const eventFocusoutMutationAll = focusoutAliases.mutationAll;
+const eventFocusoutMutation = focusoutAliases.mutation;
+const eventFocusoutLight = focusoutAliases.light;
+const eventFocusoutShadow = focusoutAliases.shadow;
+const eventFocusoutAll = focusoutAliases.all;
+const eventFocusoutAppHost = focusoutAliases.appHost;
+const eventFocusoutWindow = focusoutAliases.window;
+const eventFocusoutDocument = focusoutAliases.document;
+const dragstartAliases = makeTypedEventAliases("dragstart");
+const eventDragstart = dragstartAliases.base;
+const eventDragstartDelegateLight = dragstartAliases.delegateLight;
+const eventDragstartDelegateShadow = dragstartAliases.delegateShadow;
+const eventDragstartDelegateAll = dragstartAliases.delegateAll;
+const eventDragstartDelegate = dragstartAliases.delegate;
+const eventDragstartMutationLight = dragstartAliases.mutationLight;
+const eventDragstartMutationShadow = dragstartAliases.mutationShadow;
+const eventDragstartMutationAll = dragstartAliases.mutationAll;
+const eventDragstartMutation = dragstartAliases.mutation;
+const eventDragstartLight = dragstartAliases.light;
+const eventDragstartShadow = dragstartAliases.shadow;
+const eventDragstartAll = dragstartAliases.all;
+const eventDragstartAppHost = dragstartAliases.appHost;
+const eventDragstartWindow = dragstartAliases.window;
+const eventDragstartDocument = dragstartAliases.document;
+const dragAliases = makeTypedEventAliases("drag");
+const eventDrag = dragAliases.base;
+const eventDragDelegateLight = dragAliases.delegateLight;
+const eventDragDelegateShadow = dragAliases.delegateShadow;
+const eventDragDelegateAll = dragAliases.delegateAll;
+const eventDragDelegate = dragAliases.delegate;
+const eventDragMutationLight = dragAliases.mutationLight;
+const eventDragMutationShadow = dragAliases.mutationShadow;
+const eventDragMutationAll = dragAliases.mutationAll;
+const eventDragMutation = dragAliases.mutation;
+const eventDragLight = dragAliases.light;
+const eventDragShadow = dragAliases.shadow;
+const eventDragAll = dragAliases.all;
+const eventDragAppHost = dragAliases.appHost;
+const eventDragWindow = dragAliases.window;
+const eventDragDocument = dragAliases.document;
+const dragendAliases = makeTypedEventAliases("dragend");
+const eventDragend = dragendAliases.base;
+const eventDragendDelegateLight = dragendAliases.delegateLight;
+const eventDragendDelegateShadow = dragendAliases.delegateShadow;
+const eventDragendDelegateAll = dragendAliases.delegateAll;
+const eventDragendDelegate = dragendAliases.delegate;
+const eventDragendMutationLight = dragendAliases.mutationLight;
+const eventDragendMutationShadow = dragendAliases.mutationShadow;
+const eventDragendMutationAll = dragendAliases.mutationAll;
+const eventDragendMutation = dragendAliases.mutation;
+const eventDragendLight = dragendAliases.light;
+const eventDragendShadow = dragendAliases.shadow;
+const eventDragendAll = dragendAliases.all;
+const eventDragendAppHost = dragendAliases.appHost;
+const eventDragendWindow = dragendAliases.window;
+const eventDragendDocument = dragendAliases.document;
+const dragenterAliases = makeTypedEventAliases("dragenter");
+const eventDragenter = dragenterAliases.base;
+const eventDragenterDelegateLight = dragenterAliases.delegateLight;
+const eventDragenterDelegateShadow = dragenterAliases.delegateShadow;
+const eventDragenterDelegateAll = dragenterAliases.delegateAll;
+const eventDragenterDelegate = dragenterAliases.delegate;
+const eventDragenterMutationLight = dragenterAliases.mutationLight;
+const eventDragenterMutationShadow = dragenterAliases.mutationShadow;
+const eventDragenterMutationAll = dragenterAliases.mutationAll;
+const eventDragenterMutation = dragenterAliases.mutation;
+const eventDragenterLight = dragenterAliases.light;
+const eventDragenterShadow = dragenterAliases.shadow;
+const eventDragenterAll = dragenterAliases.all;
+const eventDragenterAppHost = dragenterAliases.appHost;
+const eventDragenterWindow = dragenterAliases.window;
+const eventDragenterDocument = dragenterAliases.document;
+const dragleaveAliases = makeTypedEventAliases("dragleave");
+const eventDragleave = dragleaveAliases.base;
+const eventDragleaveDelegateLight = dragleaveAliases.delegateLight;
+const eventDragleaveDelegateShadow = dragleaveAliases.delegateShadow;
+const eventDragleaveDelegateAll = dragleaveAliases.delegateAll;
+const eventDragleaveDelegate = dragleaveAliases.delegate;
+const eventDragleaveMutationLight = dragleaveAliases.mutationLight;
+const eventDragleaveMutationShadow = dragleaveAliases.mutationShadow;
+const eventDragleaveMutationAll = dragleaveAliases.mutationAll;
+const eventDragleaveMutation = dragleaveAliases.mutation;
+const eventDragleaveLight = dragleaveAliases.light;
+const eventDragleaveShadow = dragleaveAliases.shadow;
+const eventDragleaveAll = dragleaveAliases.all;
+const eventDragleaveAppHost = dragleaveAliases.appHost;
+const eventDragleaveWindow = dragleaveAliases.window;
+const eventDragleaveDocument = dragleaveAliases.document;
+const dragoverAliases = makeTypedEventAliases("dragover");
+const eventDragover = dragoverAliases.base;
+const eventDragoverDelegateLight = dragoverAliases.delegateLight;
+const eventDragoverDelegateShadow = dragoverAliases.delegateShadow;
+const eventDragoverDelegateAll = dragoverAliases.delegateAll;
+const eventDragoverDelegate = dragoverAliases.delegate;
+const eventDragoverMutationLight = dragoverAliases.mutationLight;
+const eventDragoverMutationShadow = dragoverAliases.mutationShadow;
+const eventDragoverMutationAll = dragoverAliases.mutationAll;
+const eventDragoverMutation = dragoverAliases.mutation;
+const eventDragoverLight = dragoverAliases.light;
+const eventDragoverShadow = dragoverAliases.shadow;
+const eventDragoverAll = dragoverAliases.all;
+const eventDragoverAppHost = dragoverAliases.appHost;
+const eventDragoverWindow = dragoverAliases.window;
+const eventDragoverDocument = dragoverAliases.document;
+const dropAliases = makeTypedEventAliases("drop");
+const eventDrop = dropAliases.base;
+const eventDropDelegateLight = dropAliases.delegateLight;
+const eventDropDelegateShadow = dropAliases.delegateShadow;
+const eventDropDelegateAll = dropAliases.delegateAll;
+const eventDropDelegate = dropAliases.delegate;
+const eventDropMutationLight = dropAliases.mutationLight;
+const eventDropMutationShadow = dropAliases.mutationShadow;
+const eventDropMutationAll = dropAliases.mutationAll;
+const eventDropMutation = dropAliases.mutation;
+const eventDropLight = dropAliases.light;
+const eventDropShadow = dropAliases.shadow;
+const eventDropAll = dropAliases.all;
+const eventDropAppHost = dropAliases.appHost;
+const eventDropWindow = dropAliases.window;
+const eventDropDocument = dropAliases.document;
+const touchstartAliases = makeTypedEventAliases("touchstart");
+const eventTouchstart = touchstartAliases.base;
+const eventTouchstartDelegateLight = touchstartAliases.delegateLight;
+const eventTouchstartDelegateShadow = touchstartAliases.delegateShadow;
+const eventTouchstartDelegateAll = touchstartAliases.delegateAll;
+const eventTouchstartDelegate = touchstartAliases.delegate;
+const eventTouchstartMutationLight = touchstartAliases.mutationLight;
+const eventTouchstartMutationShadow = touchstartAliases.mutationShadow;
+const eventTouchstartMutationAll = touchstartAliases.mutationAll;
+const eventTouchstartMutation = touchstartAliases.mutation;
+const eventTouchstartLight = touchstartAliases.light;
+const eventTouchstartShadow = touchstartAliases.shadow;
+const eventTouchstartAll = touchstartAliases.all;
+const eventTouchstartAppHost = touchstartAliases.appHost;
+const eventTouchstartWindow = touchstartAliases.window;
+const eventTouchstartDocument = touchstartAliases.document;
+const touchmoveAliases = makeTypedEventAliases("touchmove");
+const eventTouchmove = touchmoveAliases.base;
+const eventTouchmoveDelegateLight = touchmoveAliases.delegateLight;
+const eventTouchmoveDelegateShadow = touchmoveAliases.delegateShadow;
+const eventTouchmoveDelegateAll = touchmoveAliases.delegateAll;
+const eventTouchmoveDelegate = touchmoveAliases.delegate;
+const eventTouchmoveMutationLight = touchmoveAliases.mutationLight;
+const eventTouchmoveMutationShadow = touchmoveAliases.mutationShadow;
+const eventTouchmoveMutationAll = touchmoveAliases.mutationAll;
+const eventTouchmoveMutation = touchmoveAliases.mutation;
+const eventTouchmoveLight = touchmoveAliases.light;
+const eventTouchmoveShadow = touchmoveAliases.shadow;
+const eventTouchmoveAll = touchmoveAliases.all;
+const eventTouchmoveAppHost = touchmoveAliases.appHost;
+const eventTouchmoveWindow = touchmoveAliases.window;
+const eventTouchmoveDocument = touchmoveAliases.document;
+const touchendAliases = makeTypedEventAliases("touchend");
+const eventTouchend = touchendAliases.base;
+const eventTouchendDelegateLight = touchendAliases.delegateLight;
+const eventTouchendDelegateShadow = touchendAliases.delegateShadow;
+const eventTouchendDelegateAll = touchendAliases.delegateAll;
+const eventTouchendDelegate = touchendAliases.delegate;
+const eventTouchendMutationLight = touchendAliases.mutationLight;
+const eventTouchendMutationShadow = touchendAliases.mutationShadow;
+const eventTouchendMutationAll = touchendAliases.mutationAll;
+const eventTouchendMutation = touchendAliases.mutation;
+const eventTouchendLight = touchendAliases.light;
+const eventTouchendShadow = touchendAliases.shadow;
+const eventTouchendAll = touchendAliases.all;
+const eventTouchendAppHost = touchendAliases.appHost;
+const eventTouchendWindow = touchendAliases.window;
+const eventTouchendDocument = touchendAliases.document;
+const touchcancelAliases = makeTypedEventAliases("touchcancel");
+const eventTouchcancel = touchcancelAliases.base;
+const eventTouchcancelDelegateLight = touchcancelAliases.delegateLight;
+const eventTouchcancelDelegateShadow = touchcancelAliases.delegateShadow;
+const eventTouchcancelDelegateAll = touchcancelAliases.delegateAll;
+const eventTouchcancelDelegate = touchcancelAliases.delegate;
+const eventTouchcancelMutationLight = touchcancelAliases.mutationLight;
+const eventTouchcancelMutationShadow = touchcancelAliases.mutationShadow;
+const eventTouchcancelMutationAll = touchcancelAliases.mutationAll;
+const eventTouchcancelMutation = touchcancelAliases.mutation;
+const eventTouchcancelLight = touchcancelAliases.light;
+const eventTouchcancelShadow = touchcancelAliases.shadow;
+const eventTouchcancelAll = touchcancelAliases.all;
+const eventTouchcancelAppHost = touchcancelAliases.appHost;
+const eventTouchcancelWindow = touchcancelAliases.window;
+const eventTouchcancelDocument = touchcancelAliases.document;
+const pointerdownAliases = makeTypedEventAliases("pointerdown");
+const eventPointerdown = pointerdownAliases.base;
+const eventPointerdownDelegateLight = pointerdownAliases.delegateLight;
+const eventPointerdownDelegateShadow = pointerdownAliases.delegateShadow;
+const eventPointerdownDelegateAll = pointerdownAliases.delegateAll;
+const eventPointerdownDelegate = pointerdownAliases.delegate;
+const eventPointerdownMutationLight = pointerdownAliases.mutationLight;
+const eventPointerdownMutationShadow = pointerdownAliases.mutationShadow;
+const eventPointerdownMutationAll = pointerdownAliases.mutationAll;
+const eventPointerdownMutation = pointerdownAliases.mutation;
+const eventPointerdownLight = pointerdownAliases.light;
+const eventPointerdownShadow = pointerdownAliases.shadow;
+const eventPointerdownAll = pointerdownAliases.all;
+const eventPointerdownAppHost = pointerdownAliases.appHost;
+const eventPointerdownWindow = pointerdownAliases.window;
+const eventPointerdownDocument = pointerdownAliases.document;
+const pointerupAliases = makeTypedEventAliases("pointerup");
+const eventPointerup = pointerupAliases.base;
+const eventPointerupDelegateLight = pointerupAliases.delegateLight;
+const eventPointerupDelegateShadow = pointerupAliases.delegateShadow;
+const eventPointerupDelegateAll = pointerupAliases.delegateAll;
+const eventPointerupDelegate = pointerupAliases.delegate;
+const eventPointerupMutationLight = pointerupAliases.mutationLight;
+const eventPointerupMutationShadow = pointerupAliases.mutationShadow;
+const eventPointerupMutationAll = pointerupAliases.mutationAll;
+const eventPointerupMutation = pointerupAliases.mutation;
+const eventPointerupLight = pointerupAliases.light;
+const eventPointerupShadow = pointerupAliases.shadow;
+const eventPointerupAll = pointerupAliases.all;
+const eventPointerupAppHost = pointerupAliases.appHost;
+const eventPointerupWindow = pointerupAliases.window;
+const eventPointerupDocument = pointerupAliases.document;
+const pointermoveAliases = makeTypedEventAliases("pointermove");
+const eventPointermove = pointermoveAliases.base;
+const eventPointermoveDelegateLight = pointermoveAliases.delegateLight;
+const eventPointermoveDelegateShadow = pointermoveAliases.delegateShadow;
+const eventPointermoveDelegateAll = pointermoveAliases.delegateAll;
+const eventPointermoveDelegate = pointermoveAliases.delegate;
+const eventPointermoveMutationLight = pointermoveAliases.mutationLight;
+const eventPointermoveMutationShadow = pointermoveAliases.mutationShadow;
+const eventPointermoveMutationAll = pointermoveAliases.mutationAll;
+const eventPointermoveMutation = pointermoveAliases.mutation;
+const eventPointermoveLight = pointermoveAliases.light;
+const eventPointermoveShadow = pointermoveAliases.shadow;
+const eventPointermoveAll = pointermoveAliases.all;
+const eventPointermoveAppHost = pointermoveAliases.appHost;
+const eventPointermoveWindow = pointermoveAliases.window;
+const eventPointermoveDocument = pointermoveAliases.document;
+const pointeroverAliases = makeTypedEventAliases("pointerover");
+const eventPointerover = pointeroverAliases.base;
+const eventPointeroverDelegateLight = pointeroverAliases.delegateLight;
+const eventPointeroverDelegateShadow = pointeroverAliases.delegateShadow;
+const eventPointeroverDelegateAll = pointeroverAliases.delegateAll;
+const eventPointeroverDelegate = pointeroverAliases.delegate;
+const eventPointeroverMutationLight = pointeroverAliases.mutationLight;
+const eventPointeroverMutationShadow = pointeroverAliases.mutationShadow;
+const eventPointeroverMutationAll = pointeroverAliases.mutationAll;
+const eventPointeroverMutation = pointeroverAliases.mutation;
+const eventPointeroverLight = pointeroverAliases.light;
+const eventPointeroverShadow = pointeroverAliases.shadow;
+const eventPointeroverAll = pointeroverAliases.all;
+const eventPointeroverAppHost = pointeroverAliases.appHost;
+const eventPointeroverWindow = pointeroverAliases.window;
+const eventPointeroverDocument = pointeroverAliases.document;
+const pointeroutAliases = makeTypedEventAliases("pointerout");
+const eventPointerout = pointeroutAliases.base;
+const eventPointeroutDelegateLight = pointeroutAliases.delegateLight;
+const eventPointeroutDelegateShadow = pointeroutAliases.delegateShadow;
+const eventPointeroutDelegateAll = pointeroutAliases.delegateAll;
+const eventPointeroutDelegate = pointeroutAliases.delegate;
+const eventPointeroutMutationLight = pointeroutAliases.mutationLight;
+const eventPointeroutMutationShadow = pointeroutAliases.mutationShadow;
+const eventPointeroutMutationAll = pointeroutAliases.mutationAll;
+const eventPointeroutMutation = pointeroutAliases.mutation;
+const eventPointeroutLight = pointeroutAliases.light;
+const eventPointeroutShadow = pointeroutAliases.shadow;
+const eventPointeroutAll = pointeroutAliases.all;
+const eventPointeroutAppHost = pointeroutAliases.appHost;
+const eventPointeroutWindow = pointeroutAliases.window;
+const eventPointeroutDocument = pointeroutAliases.document;
+const pointerenterAliases = makeTypedEventAliases("pointerenter");
+const eventPointerenter = pointerenterAliases.base;
+const eventPointerenterDelegateLight = pointerenterAliases.delegateLight;
+const eventPointerenterDelegateShadow = pointerenterAliases.delegateShadow;
+const eventPointerenterDelegateAll = pointerenterAliases.delegateAll;
+const eventPointerenterDelegate = pointerenterAliases.delegate;
+const eventPointerenterMutationLight = pointerenterAliases.mutationLight;
+const eventPointerenterMutationShadow = pointerenterAliases.mutationShadow;
+const eventPointerenterMutationAll = pointerenterAliases.mutationAll;
+const eventPointerenterMutation = pointerenterAliases.mutation;
+const eventPointerenterLight = pointerenterAliases.light;
+const eventPointerenterShadow = pointerenterAliases.shadow;
+const eventPointerenterAll = pointerenterAliases.all;
+const eventPointerenterAppHost = pointerenterAliases.appHost;
+const eventPointerenterWindow = pointerenterAliases.window;
+const eventPointerenterDocument = pointerenterAliases.document;
+const pointerleaveAliases = makeTypedEventAliases("pointerleave");
+const eventPointerleave = pointerleaveAliases.base;
+const eventPointerleaveDelegateLight = pointerleaveAliases.delegateLight;
+const eventPointerleaveDelegateShadow = pointerleaveAliases.delegateShadow;
+const eventPointerleaveDelegateAll = pointerleaveAliases.delegateAll;
+const eventPointerleaveDelegate = pointerleaveAliases.delegate;
+const eventPointerleaveMutationLight = pointerleaveAliases.mutationLight;
+const eventPointerleaveMutationShadow = pointerleaveAliases.mutationShadow;
+const eventPointerleaveMutationAll = pointerleaveAliases.mutationAll;
+const eventPointerleaveMutation = pointerleaveAliases.mutation;
+const eventPointerleaveLight = pointerleaveAliases.light;
+const eventPointerleaveShadow = pointerleaveAliases.shadow;
+const eventPointerleaveAll = pointerleaveAliases.all;
+const eventPointerleaveAppHost = pointerleaveAliases.appHost;
+const eventPointerleaveWindow = pointerleaveAliases.window;
+const eventPointerleaveDocument = pointerleaveAliases.document;
+const pointercancelAliases = makeTypedEventAliases("pointercancel");
+const eventPointercancel = pointercancelAliases.base;
+const eventPointercancelDelegateLight = pointercancelAliases.delegateLight;
+const eventPointercancelDelegateShadow = pointercancelAliases.delegateShadow;
+const eventPointercancelDelegateAll = pointercancelAliases.delegateAll;
+const eventPointercancelDelegate = pointercancelAliases.delegate;
+const eventPointercancelMutationLight = pointercancelAliases.mutationLight;
+const eventPointercancelMutationShadow = pointercancelAliases.mutationShadow;
+const eventPointercancelMutationAll = pointercancelAliases.mutationAll;
+const eventPointercancelMutation = pointercancelAliases.mutation;
+const eventPointercancelLight = pointercancelAliases.light;
+const eventPointercancelShadow = pointercancelAliases.shadow;
+const eventPointercancelAll = pointercancelAliases.all;
+const eventPointercancelAppHost = pointercancelAliases.appHost;
+const eventPointercancelWindow = pointercancelAliases.window;
+const eventPointercancelDocument = pointercancelAliases.document;
+const copyAliases = makeTypedEventAliases("copy");
+const eventCopy = copyAliases.base;
+const eventCopyDelegateLight = copyAliases.delegateLight;
+const eventCopyDelegateShadow = copyAliases.delegateShadow;
+const eventCopyDelegateAll = copyAliases.delegateAll;
+const eventCopyDelegate = copyAliases.delegate;
+const eventCopyMutationLight = copyAliases.mutationLight;
+const eventCopyMutationShadow = copyAliases.mutationShadow;
+const eventCopyMutationAll = copyAliases.mutationAll;
+const eventCopyMutation = copyAliases.mutation;
+const eventCopyLight = copyAliases.light;
+const eventCopyShadow = copyAliases.shadow;
+const eventCopyAll = copyAliases.all;
+const eventCopyAppHost = copyAliases.appHost;
+const eventCopyWindow = copyAliases.window;
+const eventCopyDocument = copyAliases.document;
+const cutAliases = makeTypedEventAliases("cut");
+const eventCut = cutAliases.base;
+const eventCutDelegateLight = cutAliases.delegateLight;
+const eventCutDelegateShadow = cutAliases.delegateShadow;
+const eventCutDelegateAll = cutAliases.delegateAll;
+const eventCutDelegate = cutAliases.delegate;
+const eventCutMutationLight = cutAliases.mutationLight;
+const eventCutMutationShadow = cutAliases.mutationShadow;
+const eventCutMutationAll = cutAliases.mutationAll;
+const eventCutMutation = cutAliases.mutation;
+const eventCutLight = cutAliases.light;
+const eventCutShadow = cutAliases.shadow;
+const eventCutAll = cutAliases.all;
+const eventCutAppHost = cutAliases.appHost;
+const eventCutWindow = cutAliases.window;
+const eventCutDocument = cutAliases.document;
+const pasteAliases = makeTypedEventAliases("paste");
+const eventPaste = pasteAliases.base;
+const eventPasteDelegateLight = pasteAliases.delegateLight;
+const eventPasteDelegateShadow = pasteAliases.delegateShadow;
+const eventPasteDelegateAll = pasteAliases.delegateAll;
+const eventPasteDelegate = pasteAliases.delegate;
+const eventPasteMutationLight = pasteAliases.mutationLight;
+const eventPasteMutationShadow = pasteAliases.mutationShadow;
+const eventPasteMutationAll = pasteAliases.mutationAll;
+const eventPasteMutation = pasteAliases.mutation;
+const eventPasteLight = pasteAliases.light;
+const eventPasteShadow = pasteAliases.shadow;
+const eventPasteAll = pasteAliases.all;
+const eventPasteAppHost = pasteAliases.appHost;
+const eventPasteWindow = pasteAliases.window;
+const eventPasteDocument = pasteAliases.document;
+const animationstartAliases = makeTypedEventAliases("animationstart");
+const eventAnimationstart = animationstartAliases.base;
+const eventAnimationstartDelegateLight = animationstartAliases.delegateLight;
+const eventAnimationstartDelegateShadow = animationstartAliases.delegateShadow;
+const eventAnimationstartDelegateAll = animationstartAliases.delegateAll;
+const eventAnimationstartDelegate = animationstartAliases.delegate;
+const eventAnimationstartMutationLight = animationstartAliases.mutationLight;
+const eventAnimationstartMutationShadow = animationstartAliases.mutationShadow;
+const eventAnimationstartMutationAll = animationstartAliases.mutationAll;
+const eventAnimationstartMutation = animationstartAliases.mutation;
+const eventAnimationstartLight = animationstartAliases.light;
+const eventAnimationstartShadow = animationstartAliases.shadow;
+const eventAnimationstartAll = animationstartAliases.all;
+const eventAnimationstartAppHost = animationstartAliases.appHost;
+const eventAnimationstartWindow = animationstartAliases.window;
+const eventAnimationstartDocument = animationstartAliases.document;
+const animationendAliases = makeTypedEventAliases("animationend");
+const eventAnimationend = animationendAliases.base;
+const eventAnimationendDelegateLight = animationendAliases.delegateLight;
+const eventAnimationendDelegateShadow = animationendAliases.delegateShadow;
+const eventAnimationendDelegateAll = animationendAliases.delegateAll;
+const eventAnimationendDelegate = animationendAliases.delegate;
+const eventAnimationendMutationLight = animationendAliases.mutationLight;
+const eventAnimationendMutationShadow = animationendAliases.mutationShadow;
+const eventAnimationendMutationAll = animationendAliases.mutationAll;
+const eventAnimationendMutation = animationendAliases.mutation;
+const eventAnimationendLight = animationendAliases.light;
+const eventAnimationendShadow = animationendAliases.shadow;
+const eventAnimationendAll = animationendAliases.all;
+const eventAnimationendAppHost = animationendAliases.appHost;
+const eventAnimationendWindow = animationendAliases.window;
+const eventAnimationendDocument = animationendAliases.document;
+const animationiterationAliases = makeTypedEventAliases("animationiteration");
+const eventAnimationiteration = animationiterationAliases.base;
+const eventAnimationiterationDelegateLight = animationiterationAliases.delegateLight;
+const eventAnimationiterationDelegateShadow = animationiterationAliases.delegateShadow;
+const eventAnimationiterationDelegateAll = animationiterationAliases.delegateAll;
+const eventAnimationiterationDelegate = animationiterationAliases.delegate;
+const eventAnimationiterationMutationLight = animationiterationAliases.mutationLight;
+const eventAnimationiterationMutationShadow = animationiterationAliases.mutationShadow;
+const eventAnimationiterationMutationAll = animationiterationAliases.mutationAll;
+const eventAnimationiterationMutation = animationiterationAliases.mutation;
+const eventAnimationiterationLight = animationiterationAliases.light;
+const eventAnimationiterationShadow = animationiterationAliases.shadow;
+const eventAnimationiterationAll = animationiterationAliases.all;
+const eventAnimationiterationAppHost = animationiterationAliases.appHost;
+const eventAnimationiterationWindow = animationiterationAliases.window;
+const eventAnimationiterationDocument = animationiterationAliases.document;
+const animationcancelAliases = makeTypedEventAliases("animationcancel");
+const eventAnimationcancel = animationcancelAliases.base;
+const eventAnimationcancelDelegateLight = animationcancelAliases.delegateLight;
+const eventAnimationcancelDelegateShadow = animationcancelAliases.delegateShadow;
+const eventAnimationcancelDelegateAll = animationcancelAliases.delegateAll;
+const eventAnimationcancelDelegate = animationcancelAliases.delegate;
+const eventAnimationcancelMutationLight = animationcancelAliases.mutationLight;
+const eventAnimationcancelMutationShadow = animationcancelAliases.mutationShadow;
+const eventAnimationcancelMutationAll = animationcancelAliases.mutationAll;
+const eventAnimationcancelMutation = animationcancelAliases.mutation;
+const eventAnimationcancelLight = animationcancelAliases.light;
+const eventAnimationcancelShadow = animationcancelAliases.shadow;
+const eventAnimationcancelAll = animationcancelAliases.all;
+const eventAnimationcancelAppHost = animationcancelAliases.appHost;
+const eventAnimationcancelWindow = animationcancelAliases.window;
+const eventAnimationcancelDocument = animationcancelAliases.document;
+const transitionstartAliases = makeTypedEventAliases("transitionstart");
+const eventTransitionstart = transitionstartAliases.base;
+const eventTransitionstartDelegateLight = transitionstartAliases.delegateLight;
+const eventTransitionstartDelegateShadow = transitionstartAliases.delegateShadow;
+const eventTransitionstartDelegateAll = transitionstartAliases.delegateAll;
+const eventTransitionstartDelegate = transitionstartAliases.delegate;
+const eventTransitionstartMutationLight = transitionstartAliases.mutationLight;
+const eventTransitionstartMutationShadow = transitionstartAliases.mutationShadow;
+const eventTransitionstartMutationAll = transitionstartAliases.mutationAll;
+const eventTransitionstartMutation = transitionstartAliases.mutation;
+const eventTransitionstartLight = transitionstartAliases.light;
+const eventTransitionstartShadow = transitionstartAliases.shadow;
+const eventTransitionstartAll = transitionstartAliases.all;
+const eventTransitionstartAppHost = transitionstartAliases.appHost;
+const eventTransitionstartWindow = transitionstartAliases.window;
+const eventTransitionstartDocument = transitionstartAliases.document;
+const transitionendAliases = makeTypedEventAliases("transitionend");
+const eventTransitionend = transitionendAliases.base;
+const eventTransitionendDelegateLight = transitionendAliases.delegateLight;
+const eventTransitionendDelegateShadow = transitionendAliases.delegateShadow;
+const eventTransitionendDelegateAll = transitionendAliases.delegateAll;
+const eventTransitionendDelegate = transitionendAliases.delegate;
+const eventTransitionendMutationLight = transitionendAliases.mutationLight;
+const eventTransitionendMutationShadow = transitionendAliases.mutationShadow;
+const eventTransitionendMutationAll = transitionendAliases.mutationAll;
+const eventTransitionendMutation = transitionendAliases.mutation;
+const eventTransitionendLight = transitionendAliases.light;
+const eventTransitionendShadow = transitionendAliases.shadow;
+const eventTransitionendAll = transitionendAliases.all;
+const eventTransitionendAppHost = transitionendAliases.appHost;
+const eventTransitionendWindow = transitionendAliases.window;
+const eventTransitionendDocument = transitionendAliases.document;
+const transitioncancelAliases = makeTypedEventAliases("transitioncancel");
+const eventTransitioncancel = transitioncancelAliases.base;
+const eventTransitioncancelDelegateLight = transitioncancelAliases.delegateLight;
+const eventTransitioncancelDelegateShadow = transitioncancelAliases.delegateShadow;
+const eventTransitioncancelDelegateAll = transitioncancelAliases.delegateAll;
+const eventTransitioncancelDelegate = transitioncancelAliases.delegate;
+const eventTransitioncancelMutationLight = transitioncancelAliases.mutationLight;
+const eventTransitioncancelMutationShadow = transitioncancelAliases.mutationShadow;
+const eventTransitioncancelMutationAll = transitioncancelAliases.mutationAll;
+const eventTransitioncancelMutation = transitioncancelAliases.mutation;
+const eventTransitioncancelLight = transitioncancelAliases.light;
+const eventTransitioncancelShadow = transitioncancelAliases.shadow;
+const eventTransitioncancelAll = transitioncancelAliases.all;
+const eventTransitioncancelAppHost = transitioncancelAliases.appHost;
+const eventTransitioncancelWindow = transitioncancelAliases.window;
+const eventTransitioncancelDocument = transitioncancelAliases.document;
+const transitionrunAliases = makeTypedEventAliases("transitionrun");
+const eventTransitionrun = transitionrunAliases.base;
+const eventTransitionrunDelegateLight = transitionrunAliases.delegateLight;
+const eventTransitionrunDelegateShadow = transitionrunAliases.delegateShadow;
+const eventTransitionrunDelegateAll = transitionrunAliases.delegateAll;
+const eventTransitionrunDelegate = transitionrunAliases.delegate;
+const eventTransitionrunMutationLight = transitionrunAliases.mutationLight;
+const eventTransitionrunMutationShadow = transitionrunAliases.mutationShadow;
+const eventTransitionrunMutationAll = transitionrunAliases.mutationAll;
+const eventTransitionrunMutation = transitionrunAliases.mutation;
+const eventTransitionrunLight = transitionrunAliases.light;
+const eventTransitionrunShadow = transitionrunAliases.shadow;
+const eventTransitionrunAll = transitionrunAliases.all;
+const eventTransitionrunAppHost = transitionrunAliases.appHost;
+const eventTransitionrunWindow = transitionrunAliases.window;
+const eventTransitionrunDocument = transitionrunAliases.document;
+const scrollAliases = makeTypedEventAliases("scroll");
+const eventScroll = scrollAliases.base;
+const eventScrollDelegateLight = scrollAliases.delegateLight;
+const eventScrollDelegateShadow = scrollAliases.delegateShadow;
+const eventScrollDelegateAll = scrollAliases.delegateAll;
+const eventScrollDelegate = scrollAliases.delegate;
+const eventScrollMutationLight = scrollAliases.mutationLight;
+const eventScrollMutationShadow = scrollAliases.mutationShadow;
+const eventScrollMutationAll = scrollAliases.mutationAll;
+const eventScrollMutation = scrollAliases.mutation;
+const eventScrollLight = scrollAliases.light;
+const eventScrollShadow = scrollAliases.shadow;
+const eventScrollAll = scrollAliases.all;
+const eventScrollAppHost = scrollAliases.appHost;
+const eventScrollWindow = scrollAliases.window;
+const eventScrollDocument = scrollAliases.document;
+const resizeAliases = makeTypedEventAliases("resize");
+const eventResize = resizeAliases.base;
+const eventResizeDelegateLight = resizeAliases.delegateLight;
+const eventResizeDelegateShadow = resizeAliases.delegateShadow;
+const eventResizeDelegateAll = resizeAliases.delegateAll;
+const eventResizeDelegate = resizeAliases.delegate;
+const eventResizeMutationLight = resizeAliases.mutationLight;
+const eventResizeMutationShadow = resizeAliases.mutationShadow;
+const eventResizeMutationAll = resizeAliases.mutationAll;
+const eventResizeMutation = resizeAliases.mutation;
+const eventResizeLight = resizeAliases.light;
+const eventResizeShadow = resizeAliases.shadow;
+const eventResizeAll = resizeAliases.all;
+const eventResizeAppHost = resizeAliases.appHost;
+const eventResizeWindow = resizeAliases.window;
+const eventResizeDocument = resizeAliases.document;
+const loadAliases = makeTypedEventAliases("load");
+const eventLoad = loadAliases.base;
+const eventLoadDelegateLight = loadAliases.delegateLight;
+const eventLoadDelegateShadow = loadAliases.delegateShadow;
+const eventLoadDelegateAll = loadAliases.delegateAll;
+const eventLoadDelegate = loadAliases.delegate;
+const eventLoadMutationLight = loadAliases.mutationLight;
+const eventLoadMutationShadow = loadAliases.mutationShadow;
+const eventLoadMutationAll = loadAliases.mutationAll;
+const eventLoadMutation = loadAliases.mutation;
+const eventLoadLight = loadAliases.light;
+const eventLoadShadow = loadAliases.shadow;
+const eventLoadAll = loadAliases.all;
+const eventLoadAppHost = loadAliases.appHost;
+const eventLoadWindow = loadAliases.window;
+const eventLoadDocument = loadAliases.document;
+const errorAliases = makeTypedEventAliases("error");
+const eventError = errorAliases.base;
+const eventErrorDelegateLight = errorAliases.delegateLight;
+const eventErrorDelegateShadow = errorAliases.delegateShadow;
+const eventErrorDelegateAll = errorAliases.delegateAll;
+const eventErrorDelegate = errorAliases.delegate;
+const eventErrorMutationLight = errorAliases.mutationLight;
+const eventErrorMutationShadow = errorAliases.mutationShadow;
+const eventErrorMutationAll = errorAliases.mutationAll;
+const eventErrorMutation = errorAliases.mutation;
+const eventErrorLight = errorAliases.light;
+const eventErrorShadow = errorAliases.shadow;
+const eventErrorAll = errorAliases.all;
+const eventErrorAppHost = errorAliases.appHost;
+const eventErrorWindow = errorAliases.window;
+const eventErrorDocument = errorAliases.document;
+const toggleAliases = makeTypedEventAliases("toggle");
+const eventToggle = toggleAliases.base;
+const eventToggleDelegateLight = toggleAliases.delegateLight;
+const eventToggleDelegateShadow = toggleAliases.delegateShadow;
+const eventToggleDelegateAll = toggleAliases.delegateAll;
+const eventToggleDelegate = toggleAliases.delegate;
+const eventToggleMutationLight = toggleAliases.mutationLight;
+const eventToggleMutationShadow = toggleAliases.mutationShadow;
+const eventToggleMutationAll = toggleAliases.mutationAll;
+const eventToggleMutation = toggleAliases.mutation;
+const eventToggleLight = toggleAliases.light;
+const eventToggleShadow = toggleAliases.shadow;
+const eventToggleAll = toggleAliases.all;
+const eventToggleAppHost = toggleAliases.appHost;
+const eventToggleWindow = toggleAliases.window;
+const eventToggleDocument = toggleAliases.document;
 const getAddEventListenerMetadata = (target) => {
-  const constructor = target instanceof Function ? target : target.constructor;
-  return ReflectUtils.getMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor);
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return ReflectUtils.findAllMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor).flat();
 };
 import { Subject } from "@dooboostore/core";
 import { debounceTime, distinctUntilChanged, throttleTime } from "@dooboostore/core/message/operators";
 import { SwcUtils } from "../utils/Utils.js";
+import { buildSwcParameterArgs } from "./parameter.js";
 class EventListenerLifeCycler {
   constructor() {
     /** 인스턴스별 boundListeners 상태 (시클러는 elementDefine 시 1회 생성되어 공유되므로) */
@@ -131,15 +1106,39 @@ class EventListenerLifeCycler {
     const { type, options } = meta;
     const opts = { capture: options.capture, once: options.once, passive: options.passive };
     const handler = async (event2) => {
+      const helper = options.filter || options.before || options.finally ? SwcUtils.getHelperAndHostSet(target, currentWin) : void 0;
       if (options.filter) {
-        const helper = SwcUtils.getHelperAndHostSet(currentWin, target);
-        if (!options.filter(event2, { currentThis: inst, helper })) return;
+        if (!await options.filter(event2, { currentThis: inst, helper })) return;
       }
       if (options.stopPropagation) event2.stopPropagation();
       if (options.stopImmediatePropagation) event2.stopImmediatePropagation();
       if (options.preventDefault) event2.preventDefault();
       const currentHostSet = SwcUtils.getHostSet(inst);
-      await inst[meta.propertyKey](event2, { currentHostSet, $matchedElement: event2.currentTarget }, { event: event2, ...currentHostSet, $el: target, $root: target });
+      const legacyArgs = [event2, { currentHostSet, $matchedElement: event2.currentTarget }, { event: event2, ...currentHostSet, $el: target, $root: target }];
+      const currentHelperSet = SwcUtils.getHelperSet(currentWin);
+      const currentHelperHostSet = { ...currentHelperSet, ...currentHostSet, $this: inst };
+      const buildArgs = (beforeReturn) => buildSwcParameterArgs(inst, meta.propertyKey, {
+        eventObject: event2,
+        matchedElement: event2.currentTarget,
+        hostSet: currentHostSet,
+        helperHostSet: currentHelperHostSet,
+        helperSet: currentHelperSet,
+        eventBeforeReturn: beforeReturn
+      }, legacyArgs);
+      let args = buildArgs(void 0);
+      if (options.before) {
+        const beforeReturn = await options.before(event2, { currentThis: inst, helper }, args);
+        args = buildArgs(beforeReturn);
+      }
+      let result, error;
+      try {
+        result = await inst[meta.propertyKey](...args);
+      } catch (e) {
+        error = e;
+      } finally {
+        if (options.finally) await options.finally(event2, { currentThis: inst, helper }, { args, result, error });
+      }
+      if (error) throw error;
     };
     const eventSubject = new Subject();
     let eventStream = eventSubject;
@@ -246,27 +1245,47 @@ class EventListenerLifeCycler {
       for (const br of roots) {
         const sorted = [...metaList].sort((a, b) => (b.options.stopPropagation ? 1 : 0) - (a.options.stopPropagation ? 1 : 0));
         const handler = async (event2) => {
-          for (const m of sorted) {
-            const matchedEl = event2.target?.closest(m.selector);
-            console.log("[DBG][delegate] type=", event2.type, "| evtTarget=", event2.target?.tagName, "| sel=", m.selector, "| matchedEl=", matchedEl?.className || matchedEl?.tagName, "| brContains=", br.contains?.(matchedEl), "| brTag=", br.tagName || br.constructor?.name);
+          const matches = sorted.map((m) => ({ m, matchedEl: event2.target?.closest(m.selector) }));
+          for (const { m, matchedEl } of matches) {
             if (matchedEl && br.contains(matchedEl)) {
+              const helper = m.options.filter || m.options.before || m.options.finally ? SwcUtils.getHelperAndHostSet(matchedEl, currentWin) : void 0;
               if (m.options.filter) {
-                const helper = SwcUtils.getHelperAndHostSet(currentWin, matchedEl);
-                if (!m.options.filter(event2, { currentThis: inst, helper })) continue;
+                if (!await m.options.filter(event2, { currentThis: inst, helper })) continue;
               }
               if (m.options.stopPropagation) event2.stopPropagation();
               if (m.options.stopImmediatePropagation) event2.stopImmediatePropagation();
               if (m.options.preventDefault) event2.preventDefault();
               const hs = SwcUtils.getHostSet(inst);
-              await inst[m.propertyKey](event2, { ...hs, $matchedElement: matchedEl }, { event: event2, ...hs, $el: matchedEl, $root: br });
+              const legacyArgs = [event2, { ...hs, $matchedElement: matchedEl }, { event: event2, ...hs, $el: matchedEl, $root: br }];
+              const helperSetForMatch = SwcUtils.getHelperSet(currentWin);
+              const helperHostSetForMatch = { ...helperSetForMatch, ...hs, $this: inst };
+              const buildArgs = (beforeReturn) => buildSwcParameterArgs(inst, m.propertyKey, {
+                eventObject: event2,
+                matchedElement: matchedEl,
+                hostSet: hs,
+                helperHostSet: helperHostSetForMatch,
+                helperSet: helperSetForMatch,
+                eventBeforeReturn: beforeReturn
+              }, legacyArgs);
+              let args = buildArgs(void 0);
+              if (m.options.before) {
+                const beforeReturn = await m.options.before(event2, { currentThis: inst, helper }, args);
+                args = buildArgs(beforeReturn);
+              }
+              let result, error;
+              try {
+                result = await inst[m.propertyKey](...args);
+              } catch (e) {
+                error = e;
+              } finally {
+                if (m.options.finally) await m.options.finally(event2, { currentThis: inst, helper }, { args, result, error });
+              }
+              if (error) throw error;
               if (event2.cancelBubble) break;
             }
           }
         };
         br.addEventListener(type, handler, opts);
-        if (type === "click") {
-          console.log("[DBG][eventCycler] bound click on br=", br.tagName || br.constructor?.name, "| inst=", inst.tagName || inst.constructor?.name, "| isSame=", br === inst);
-        }
         const onRemoves = sorted.filter((m) => m.options.removeListener).map((m) => ({ fn: m.options.removeListener, opts: m.options }));
         this.getBoundListeners(inst).push({ target: br, type, handler, options: opts, onRemoves });
       }
@@ -439,24 +1458,908 @@ export {
   addEventListenerMutationLight,
   addEventListenerMutationShadow,
   addEventListenerShadow,
-  addEventListenerThis,
   addEventListenerWindow,
   event,
   eventAll,
+  eventAnimationcancel,
+  eventAnimationcancelAll,
+  eventAnimationcancelAppHost,
+  eventAnimationcancelDelegate,
+  eventAnimationcancelDelegateAll,
+  eventAnimationcancelDelegateLight,
+  eventAnimationcancelDelegateShadow,
+  eventAnimationcancelDocument,
+  eventAnimationcancelLight,
+  eventAnimationcancelMutation,
+  eventAnimationcancelMutationAll,
+  eventAnimationcancelMutationLight,
+  eventAnimationcancelMutationShadow,
+  eventAnimationcancelShadow,
+  eventAnimationcancelWindow,
+  eventAnimationend,
+  eventAnimationendAll,
+  eventAnimationendAppHost,
+  eventAnimationendDelegate,
+  eventAnimationendDelegateAll,
+  eventAnimationendDelegateLight,
+  eventAnimationendDelegateShadow,
+  eventAnimationendDocument,
+  eventAnimationendLight,
+  eventAnimationendMutation,
+  eventAnimationendMutationAll,
+  eventAnimationendMutationLight,
+  eventAnimationendMutationShadow,
+  eventAnimationendShadow,
+  eventAnimationendWindow,
+  eventAnimationiteration,
+  eventAnimationiterationAll,
+  eventAnimationiterationAppHost,
+  eventAnimationiterationDelegate,
+  eventAnimationiterationDelegateAll,
+  eventAnimationiterationDelegateLight,
+  eventAnimationiterationDelegateShadow,
+  eventAnimationiterationDocument,
+  eventAnimationiterationLight,
+  eventAnimationiterationMutation,
+  eventAnimationiterationMutationAll,
+  eventAnimationiterationMutationLight,
+  eventAnimationiterationMutationShadow,
+  eventAnimationiterationShadow,
+  eventAnimationiterationWindow,
+  eventAnimationstart,
+  eventAnimationstartAll,
+  eventAnimationstartAppHost,
+  eventAnimationstartDelegate,
+  eventAnimationstartDelegateAll,
+  eventAnimationstartDelegateLight,
+  eventAnimationstartDelegateShadow,
+  eventAnimationstartDocument,
+  eventAnimationstartLight,
+  eventAnimationstartMutation,
+  eventAnimationstartMutationAll,
+  eventAnimationstartMutationLight,
+  eventAnimationstartMutationShadow,
+  eventAnimationstartShadow,
+  eventAnimationstartWindow,
   eventAppHost,
+  eventBlur,
+  eventBlurAll,
+  eventBlurAppHost,
+  eventBlurDelegate,
+  eventBlurDelegateAll,
+  eventBlurDelegateLight,
+  eventBlurDelegateShadow,
+  eventBlurDocument,
+  eventBlurLight,
+  eventBlurMutation,
+  eventBlurMutationAll,
+  eventBlurMutationLight,
+  eventBlurMutationShadow,
+  eventBlurShadow,
+  eventBlurWindow,
+  eventChange,
+  eventChangeAll,
+  eventChangeAppHost,
+  eventChangeDelegate,
+  eventChangeDelegateAll,
+  eventChangeDelegateLight,
+  eventChangeDelegateShadow,
+  eventChangeDocument,
+  eventChangeLight,
+  eventChangeMutation,
+  eventChangeMutationAll,
+  eventChangeMutationLight,
+  eventChangeMutationShadow,
+  eventChangeShadow,
+  eventChangeWindow,
+  eventClick,
+  eventClickAll,
+  eventClickAppHost,
+  eventClickDelegate,
+  eventClickDelegateAll,
+  eventClickDelegateLight,
+  eventClickDelegateShadow,
+  eventClickDocument,
+  eventClickLight,
+  eventClickMutation,
+  eventClickMutationAll,
+  eventClickMutationLight,
+  eventClickMutationShadow,
+  eventClickShadow,
+  eventClickWindow,
+  eventContextmenu,
+  eventContextmenuAll,
+  eventContextmenuAppHost,
+  eventContextmenuDelegate,
+  eventContextmenuDelegateAll,
+  eventContextmenuDelegateLight,
+  eventContextmenuDelegateShadow,
+  eventContextmenuDocument,
+  eventContextmenuLight,
+  eventContextmenuMutation,
+  eventContextmenuMutationAll,
+  eventContextmenuMutationLight,
+  eventContextmenuMutationShadow,
+  eventContextmenuShadow,
+  eventContextmenuWindow,
+  eventCopy,
+  eventCopyAll,
+  eventCopyAppHost,
+  eventCopyDelegate,
+  eventCopyDelegateAll,
+  eventCopyDelegateLight,
+  eventCopyDelegateShadow,
+  eventCopyDocument,
+  eventCopyLight,
+  eventCopyMutation,
+  eventCopyMutationAll,
+  eventCopyMutationLight,
+  eventCopyMutationShadow,
+  eventCopyShadow,
+  eventCopyWindow,
+  eventCut,
+  eventCutAll,
+  eventCutAppHost,
+  eventCutDelegate,
+  eventCutDelegateAll,
+  eventCutDelegateLight,
+  eventCutDelegateShadow,
+  eventCutDocument,
+  eventCutLight,
+  eventCutMutation,
+  eventCutMutationAll,
+  eventCutMutationLight,
+  eventCutMutationShadow,
+  eventCutShadow,
+  eventCutWindow,
+  eventDblclick,
+  eventDblclickAll,
+  eventDblclickAppHost,
+  eventDblclickDelegate,
+  eventDblclickDelegateAll,
+  eventDblclickDelegateLight,
+  eventDblclickDelegateShadow,
+  eventDblclickDocument,
+  eventDblclickLight,
+  eventDblclickMutation,
+  eventDblclickMutationAll,
+  eventDblclickMutationLight,
+  eventDblclickMutationShadow,
+  eventDblclickShadow,
+  eventDblclickWindow,
   eventDelegate,
   eventDelegateAll,
   eventDelegateLight,
   eventDelegateShadow,
   eventDocument,
+  eventDrag,
+  eventDragAll,
+  eventDragAppHost,
+  eventDragDelegate,
+  eventDragDelegateAll,
+  eventDragDelegateLight,
+  eventDragDelegateShadow,
+  eventDragDocument,
+  eventDragLight,
+  eventDragMutation,
+  eventDragMutationAll,
+  eventDragMutationLight,
+  eventDragMutationShadow,
+  eventDragShadow,
+  eventDragWindow,
+  eventDragend,
+  eventDragendAll,
+  eventDragendAppHost,
+  eventDragendDelegate,
+  eventDragendDelegateAll,
+  eventDragendDelegateLight,
+  eventDragendDelegateShadow,
+  eventDragendDocument,
+  eventDragendLight,
+  eventDragendMutation,
+  eventDragendMutationAll,
+  eventDragendMutationLight,
+  eventDragendMutationShadow,
+  eventDragendShadow,
+  eventDragendWindow,
+  eventDragenter,
+  eventDragenterAll,
+  eventDragenterAppHost,
+  eventDragenterDelegate,
+  eventDragenterDelegateAll,
+  eventDragenterDelegateLight,
+  eventDragenterDelegateShadow,
+  eventDragenterDocument,
+  eventDragenterLight,
+  eventDragenterMutation,
+  eventDragenterMutationAll,
+  eventDragenterMutationLight,
+  eventDragenterMutationShadow,
+  eventDragenterShadow,
+  eventDragenterWindow,
+  eventDragleave,
+  eventDragleaveAll,
+  eventDragleaveAppHost,
+  eventDragleaveDelegate,
+  eventDragleaveDelegateAll,
+  eventDragleaveDelegateLight,
+  eventDragleaveDelegateShadow,
+  eventDragleaveDocument,
+  eventDragleaveLight,
+  eventDragleaveMutation,
+  eventDragleaveMutationAll,
+  eventDragleaveMutationLight,
+  eventDragleaveMutationShadow,
+  eventDragleaveShadow,
+  eventDragleaveWindow,
+  eventDragover,
+  eventDragoverAll,
+  eventDragoverAppHost,
+  eventDragoverDelegate,
+  eventDragoverDelegateAll,
+  eventDragoverDelegateLight,
+  eventDragoverDelegateShadow,
+  eventDragoverDocument,
+  eventDragoverLight,
+  eventDragoverMutation,
+  eventDragoverMutationAll,
+  eventDragoverMutationLight,
+  eventDragoverMutationShadow,
+  eventDragoverShadow,
+  eventDragoverWindow,
+  eventDragstart,
+  eventDragstartAll,
+  eventDragstartAppHost,
+  eventDragstartDelegate,
+  eventDragstartDelegateAll,
+  eventDragstartDelegateLight,
+  eventDragstartDelegateShadow,
+  eventDragstartDocument,
+  eventDragstartLight,
+  eventDragstartMutation,
+  eventDragstartMutationAll,
+  eventDragstartMutationLight,
+  eventDragstartMutationShadow,
+  eventDragstartShadow,
+  eventDragstartWindow,
+  eventDrop,
+  eventDropAll,
+  eventDropAppHost,
+  eventDropDelegate,
+  eventDropDelegateAll,
+  eventDropDelegateLight,
+  eventDropDelegateShadow,
+  eventDropDocument,
+  eventDropLight,
+  eventDropMutation,
+  eventDropMutationAll,
+  eventDropMutationLight,
+  eventDropMutationShadow,
+  eventDropShadow,
+  eventDropWindow,
+  eventError,
+  eventErrorAll,
+  eventErrorAppHost,
+  eventErrorDelegate,
+  eventErrorDelegateAll,
+  eventErrorDelegateLight,
+  eventErrorDelegateShadow,
+  eventErrorDocument,
+  eventErrorLight,
+  eventErrorMutation,
+  eventErrorMutationAll,
+  eventErrorMutationLight,
+  eventErrorMutationShadow,
+  eventErrorShadow,
+  eventErrorWindow,
+  eventFocus,
+  eventFocusAll,
+  eventFocusAppHost,
+  eventFocusDelegate,
+  eventFocusDelegateAll,
+  eventFocusDelegateLight,
+  eventFocusDelegateShadow,
+  eventFocusDocument,
+  eventFocusLight,
+  eventFocusMutation,
+  eventFocusMutationAll,
+  eventFocusMutationLight,
+  eventFocusMutationShadow,
+  eventFocusShadow,
+  eventFocusWindow,
+  eventFocusin,
+  eventFocusinAll,
+  eventFocusinAppHost,
+  eventFocusinDelegate,
+  eventFocusinDelegateAll,
+  eventFocusinDelegateLight,
+  eventFocusinDelegateShadow,
+  eventFocusinDocument,
+  eventFocusinLight,
+  eventFocusinMutation,
+  eventFocusinMutationAll,
+  eventFocusinMutationLight,
+  eventFocusinMutationShadow,
+  eventFocusinShadow,
+  eventFocusinWindow,
+  eventFocusout,
+  eventFocusoutAll,
+  eventFocusoutAppHost,
+  eventFocusoutDelegate,
+  eventFocusoutDelegateAll,
+  eventFocusoutDelegateLight,
+  eventFocusoutDelegateShadow,
+  eventFocusoutDocument,
+  eventFocusoutLight,
+  eventFocusoutMutation,
+  eventFocusoutMutationAll,
+  eventFocusoutMutationLight,
+  eventFocusoutMutationShadow,
+  eventFocusoutShadow,
+  eventFocusoutWindow,
+  eventInput,
+  eventInputAll,
+  eventInputAppHost,
+  eventInputDelegate,
+  eventInputDelegateAll,
+  eventInputDelegateLight,
+  eventInputDelegateShadow,
+  eventInputDocument,
+  eventInputLight,
+  eventInputMutation,
+  eventInputMutationAll,
+  eventInputMutationLight,
+  eventInputMutationShadow,
+  eventInputShadow,
+  eventInputWindow,
+  eventInvalid,
+  eventInvalidAll,
+  eventInvalidAppHost,
+  eventInvalidDelegate,
+  eventInvalidDelegateAll,
+  eventInvalidDelegateLight,
+  eventInvalidDelegateShadow,
+  eventInvalidDocument,
+  eventInvalidLight,
+  eventInvalidMutation,
+  eventInvalidMutationAll,
+  eventInvalidMutationLight,
+  eventInvalidMutationShadow,
+  eventInvalidShadow,
+  eventInvalidWindow,
+  eventKeydown,
+  eventKeydownAll,
+  eventKeydownAppHost,
+  eventKeydownDelegate,
+  eventKeydownDelegateAll,
+  eventKeydownDelegateLight,
+  eventKeydownDelegateShadow,
+  eventKeydownDocument,
+  eventKeydownLight,
+  eventKeydownMutation,
+  eventKeydownMutationAll,
+  eventKeydownMutationLight,
+  eventKeydownMutationShadow,
+  eventKeydownShadow,
+  eventKeydownWindow,
+  eventKeypress,
+  eventKeypressAll,
+  eventKeypressAppHost,
+  eventKeypressDelegate,
+  eventKeypressDelegateAll,
+  eventKeypressDelegateLight,
+  eventKeypressDelegateShadow,
+  eventKeypressDocument,
+  eventKeypressLight,
+  eventKeypressMutation,
+  eventKeypressMutationAll,
+  eventKeypressMutationLight,
+  eventKeypressMutationShadow,
+  eventKeypressShadow,
+  eventKeypressWindow,
+  eventKeyup,
+  eventKeyupAll,
+  eventKeyupAppHost,
+  eventKeyupDelegate,
+  eventKeyupDelegateAll,
+  eventKeyupDelegateLight,
+  eventKeyupDelegateShadow,
+  eventKeyupDocument,
+  eventKeyupLight,
+  eventKeyupMutation,
+  eventKeyupMutationAll,
+  eventKeyupMutationLight,
+  eventKeyupMutationShadow,
+  eventKeyupShadow,
+  eventKeyupWindow,
   eventLight,
+  eventLoad,
+  eventLoadAll,
+  eventLoadAppHost,
+  eventLoadDelegate,
+  eventLoadDelegateAll,
+  eventLoadDelegateLight,
+  eventLoadDelegateShadow,
+  eventLoadDocument,
+  eventLoadLight,
+  eventLoadMutation,
+  eventLoadMutationAll,
+  eventLoadMutationLight,
+  eventLoadMutationShadow,
+  eventLoadShadow,
+  eventLoadWindow,
+  eventMousedown,
+  eventMousedownAll,
+  eventMousedownAppHost,
+  eventMousedownDelegate,
+  eventMousedownDelegateAll,
+  eventMousedownDelegateLight,
+  eventMousedownDelegateShadow,
+  eventMousedownDocument,
+  eventMousedownLight,
+  eventMousedownMutation,
+  eventMousedownMutationAll,
+  eventMousedownMutationLight,
+  eventMousedownMutationShadow,
+  eventMousedownShadow,
+  eventMousedownWindow,
+  eventMouseenter,
+  eventMouseenterAll,
+  eventMouseenterAppHost,
+  eventMouseenterDelegate,
+  eventMouseenterDelegateAll,
+  eventMouseenterDelegateLight,
+  eventMouseenterDelegateShadow,
+  eventMouseenterDocument,
+  eventMouseenterLight,
+  eventMouseenterMutation,
+  eventMouseenterMutationAll,
+  eventMouseenterMutationLight,
+  eventMouseenterMutationShadow,
+  eventMouseenterShadow,
+  eventMouseenterWindow,
+  eventMouseleave,
+  eventMouseleaveAll,
+  eventMouseleaveAppHost,
+  eventMouseleaveDelegate,
+  eventMouseleaveDelegateAll,
+  eventMouseleaveDelegateLight,
+  eventMouseleaveDelegateShadow,
+  eventMouseleaveDocument,
+  eventMouseleaveLight,
+  eventMouseleaveMutation,
+  eventMouseleaveMutationAll,
+  eventMouseleaveMutationLight,
+  eventMouseleaveMutationShadow,
+  eventMouseleaveShadow,
+  eventMouseleaveWindow,
+  eventMousemove,
+  eventMousemoveAll,
+  eventMousemoveAppHost,
+  eventMousemoveDelegate,
+  eventMousemoveDelegateAll,
+  eventMousemoveDelegateLight,
+  eventMousemoveDelegateShadow,
+  eventMousemoveDocument,
+  eventMousemoveLight,
+  eventMousemoveMutation,
+  eventMousemoveMutationAll,
+  eventMousemoveMutationLight,
+  eventMousemoveMutationShadow,
+  eventMousemoveShadow,
+  eventMousemoveWindow,
+  eventMouseout,
+  eventMouseoutAll,
+  eventMouseoutAppHost,
+  eventMouseoutDelegate,
+  eventMouseoutDelegateAll,
+  eventMouseoutDelegateLight,
+  eventMouseoutDelegateShadow,
+  eventMouseoutDocument,
+  eventMouseoutLight,
+  eventMouseoutMutation,
+  eventMouseoutMutationAll,
+  eventMouseoutMutationLight,
+  eventMouseoutMutationShadow,
+  eventMouseoutShadow,
+  eventMouseoutWindow,
+  eventMouseover,
+  eventMouseoverAll,
+  eventMouseoverAppHost,
+  eventMouseoverDelegate,
+  eventMouseoverDelegateAll,
+  eventMouseoverDelegateLight,
+  eventMouseoverDelegateShadow,
+  eventMouseoverDocument,
+  eventMouseoverLight,
+  eventMouseoverMutation,
+  eventMouseoverMutationAll,
+  eventMouseoverMutationLight,
+  eventMouseoverMutationShadow,
+  eventMouseoverShadow,
+  eventMouseoverWindow,
+  eventMouseup,
+  eventMouseupAll,
+  eventMouseupAppHost,
+  eventMouseupDelegate,
+  eventMouseupDelegateAll,
+  eventMouseupDelegateLight,
+  eventMouseupDelegateShadow,
+  eventMouseupDocument,
+  eventMouseupLight,
+  eventMouseupMutation,
+  eventMouseupMutationAll,
+  eventMouseupMutationLight,
+  eventMouseupMutationShadow,
+  eventMouseupShadow,
+  eventMouseupWindow,
   eventMutation,
   eventMutationAll,
   eventMutationLight,
   eventMutationShadow,
+  eventPaste,
+  eventPasteAll,
+  eventPasteAppHost,
+  eventPasteDelegate,
+  eventPasteDelegateAll,
+  eventPasteDelegateLight,
+  eventPasteDelegateShadow,
+  eventPasteDocument,
+  eventPasteLight,
+  eventPasteMutation,
+  eventPasteMutationAll,
+  eventPasteMutationLight,
+  eventPasteMutationShadow,
+  eventPasteShadow,
+  eventPasteWindow,
+  eventPointercancel,
+  eventPointercancelAll,
+  eventPointercancelAppHost,
+  eventPointercancelDelegate,
+  eventPointercancelDelegateAll,
+  eventPointercancelDelegateLight,
+  eventPointercancelDelegateShadow,
+  eventPointercancelDocument,
+  eventPointercancelLight,
+  eventPointercancelMutation,
+  eventPointercancelMutationAll,
+  eventPointercancelMutationLight,
+  eventPointercancelMutationShadow,
+  eventPointercancelShadow,
+  eventPointercancelWindow,
+  eventPointerdown,
+  eventPointerdownAll,
+  eventPointerdownAppHost,
+  eventPointerdownDelegate,
+  eventPointerdownDelegateAll,
+  eventPointerdownDelegateLight,
+  eventPointerdownDelegateShadow,
+  eventPointerdownDocument,
+  eventPointerdownLight,
+  eventPointerdownMutation,
+  eventPointerdownMutationAll,
+  eventPointerdownMutationLight,
+  eventPointerdownMutationShadow,
+  eventPointerdownShadow,
+  eventPointerdownWindow,
+  eventPointerenter,
+  eventPointerenterAll,
+  eventPointerenterAppHost,
+  eventPointerenterDelegate,
+  eventPointerenterDelegateAll,
+  eventPointerenterDelegateLight,
+  eventPointerenterDelegateShadow,
+  eventPointerenterDocument,
+  eventPointerenterLight,
+  eventPointerenterMutation,
+  eventPointerenterMutationAll,
+  eventPointerenterMutationLight,
+  eventPointerenterMutationShadow,
+  eventPointerenterShadow,
+  eventPointerenterWindow,
+  eventPointerleave,
+  eventPointerleaveAll,
+  eventPointerleaveAppHost,
+  eventPointerleaveDelegate,
+  eventPointerleaveDelegateAll,
+  eventPointerleaveDelegateLight,
+  eventPointerleaveDelegateShadow,
+  eventPointerleaveDocument,
+  eventPointerleaveLight,
+  eventPointerleaveMutation,
+  eventPointerleaveMutationAll,
+  eventPointerleaveMutationLight,
+  eventPointerleaveMutationShadow,
+  eventPointerleaveShadow,
+  eventPointerleaveWindow,
+  eventPointermove,
+  eventPointermoveAll,
+  eventPointermoveAppHost,
+  eventPointermoveDelegate,
+  eventPointermoveDelegateAll,
+  eventPointermoveDelegateLight,
+  eventPointermoveDelegateShadow,
+  eventPointermoveDocument,
+  eventPointermoveLight,
+  eventPointermoveMutation,
+  eventPointermoveMutationAll,
+  eventPointermoveMutationLight,
+  eventPointermoveMutationShadow,
+  eventPointermoveShadow,
+  eventPointermoveWindow,
+  eventPointerout,
+  eventPointeroutAll,
+  eventPointeroutAppHost,
+  eventPointeroutDelegate,
+  eventPointeroutDelegateAll,
+  eventPointeroutDelegateLight,
+  eventPointeroutDelegateShadow,
+  eventPointeroutDocument,
+  eventPointeroutLight,
+  eventPointeroutMutation,
+  eventPointeroutMutationAll,
+  eventPointeroutMutationLight,
+  eventPointeroutMutationShadow,
+  eventPointeroutShadow,
+  eventPointeroutWindow,
+  eventPointerover,
+  eventPointeroverAll,
+  eventPointeroverAppHost,
+  eventPointeroverDelegate,
+  eventPointeroverDelegateAll,
+  eventPointeroverDelegateLight,
+  eventPointeroverDelegateShadow,
+  eventPointeroverDocument,
+  eventPointeroverLight,
+  eventPointeroverMutation,
+  eventPointeroverMutationAll,
+  eventPointeroverMutationLight,
+  eventPointeroverMutationShadow,
+  eventPointeroverShadow,
+  eventPointeroverWindow,
+  eventPointerup,
+  eventPointerupAll,
+  eventPointerupAppHost,
+  eventPointerupDelegate,
+  eventPointerupDelegateAll,
+  eventPointerupDelegateLight,
+  eventPointerupDelegateShadow,
+  eventPointerupDocument,
+  eventPointerupLight,
+  eventPointerupMutation,
+  eventPointerupMutationAll,
+  eventPointerupMutationLight,
+  eventPointerupMutationShadow,
+  eventPointerupShadow,
+  eventPointerupWindow,
+  eventReset,
+  eventResetAll,
+  eventResetAppHost,
+  eventResetDelegate,
+  eventResetDelegateAll,
+  eventResetDelegateLight,
+  eventResetDelegateShadow,
+  eventResetDocument,
+  eventResetLight,
+  eventResetMutation,
+  eventResetMutationAll,
+  eventResetMutationLight,
+  eventResetMutationShadow,
+  eventResetShadow,
+  eventResetWindow,
+  eventResize,
+  eventResizeAll,
+  eventResizeAppHost,
+  eventResizeDelegate,
+  eventResizeDelegateAll,
+  eventResizeDelegateLight,
+  eventResizeDelegateShadow,
+  eventResizeDocument,
+  eventResizeLight,
+  eventResizeMutation,
+  eventResizeMutationAll,
+  eventResizeMutationLight,
+  eventResizeMutationShadow,
+  eventResizeShadow,
+  eventResizeWindow,
+  eventScroll,
+  eventScrollAll,
+  eventScrollAppHost,
+  eventScrollDelegate,
+  eventScrollDelegateAll,
+  eventScrollDelegateLight,
+  eventScrollDelegateShadow,
+  eventScrollDocument,
+  eventScrollLight,
+  eventScrollMutation,
+  eventScrollMutationAll,
+  eventScrollMutationLight,
+  eventScrollMutationShadow,
+  eventScrollShadow,
+  eventScrollWindow,
+  eventSelect,
+  eventSelectAll,
+  eventSelectAppHost,
+  eventSelectDelegate,
+  eventSelectDelegateAll,
+  eventSelectDelegateLight,
+  eventSelectDelegateShadow,
+  eventSelectDocument,
+  eventSelectLight,
+  eventSelectMutation,
+  eventSelectMutationAll,
+  eventSelectMutationLight,
+  eventSelectMutationShadow,
+  eventSelectShadow,
+  eventSelectWindow,
   eventShadow,
-  eventThis,
+  eventSubmit,
+  eventSubmitAll,
+  eventSubmitAppHost,
+  eventSubmitDelegate,
+  eventSubmitDelegateAll,
+  eventSubmitDelegateLight,
+  eventSubmitDelegateShadow,
+  eventSubmitDocument,
+  eventSubmitLight,
+  eventSubmitMutation,
+  eventSubmitMutationAll,
+  eventSubmitMutationLight,
+  eventSubmitMutationShadow,
+  eventSubmitShadow,
+  eventSubmitWindow,
+  eventToggle,
+  eventToggleAll,
+  eventToggleAppHost,
+  eventToggleDelegate,
+  eventToggleDelegateAll,
+  eventToggleDelegateLight,
+  eventToggleDelegateShadow,
+  eventToggleDocument,
+  eventToggleLight,
+  eventToggleMutation,
+  eventToggleMutationAll,
+  eventToggleMutationLight,
+  eventToggleMutationShadow,
+  eventToggleShadow,
+  eventToggleWindow,
+  eventTouchcancel,
+  eventTouchcancelAll,
+  eventTouchcancelAppHost,
+  eventTouchcancelDelegate,
+  eventTouchcancelDelegateAll,
+  eventTouchcancelDelegateLight,
+  eventTouchcancelDelegateShadow,
+  eventTouchcancelDocument,
+  eventTouchcancelLight,
+  eventTouchcancelMutation,
+  eventTouchcancelMutationAll,
+  eventTouchcancelMutationLight,
+  eventTouchcancelMutationShadow,
+  eventTouchcancelShadow,
+  eventTouchcancelWindow,
+  eventTouchend,
+  eventTouchendAll,
+  eventTouchendAppHost,
+  eventTouchendDelegate,
+  eventTouchendDelegateAll,
+  eventTouchendDelegateLight,
+  eventTouchendDelegateShadow,
+  eventTouchendDocument,
+  eventTouchendLight,
+  eventTouchendMutation,
+  eventTouchendMutationAll,
+  eventTouchendMutationLight,
+  eventTouchendMutationShadow,
+  eventTouchendShadow,
+  eventTouchendWindow,
+  eventTouchmove,
+  eventTouchmoveAll,
+  eventTouchmoveAppHost,
+  eventTouchmoveDelegate,
+  eventTouchmoveDelegateAll,
+  eventTouchmoveDelegateLight,
+  eventTouchmoveDelegateShadow,
+  eventTouchmoveDocument,
+  eventTouchmoveLight,
+  eventTouchmoveMutation,
+  eventTouchmoveMutationAll,
+  eventTouchmoveMutationLight,
+  eventTouchmoveMutationShadow,
+  eventTouchmoveShadow,
+  eventTouchmoveWindow,
+  eventTouchstart,
+  eventTouchstartAll,
+  eventTouchstartAppHost,
+  eventTouchstartDelegate,
+  eventTouchstartDelegateAll,
+  eventTouchstartDelegateLight,
+  eventTouchstartDelegateShadow,
+  eventTouchstartDocument,
+  eventTouchstartLight,
+  eventTouchstartMutation,
+  eventTouchstartMutationAll,
+  eventTouchstartMutationLight,
+  eventTouchstartMutationShadow,
+  eventTouchstartShadow,
+  eventTouchstartWindow,
+  eventTransitioncancel,
+  eventTransitioncancelAll,
+  eventTransitioncancelAppHost,
+  eventTransitioncancelDelegate,
+  eventTransitioncancelDelegateAll,
+  eventTransitioncancelDelegateLight,
+  eventTransitioncancelDelegateShadow,
+  eventTransitioncancelDocument,
+  eventTransitioncancelLight,
+  eventTransitioncancelMutation,
+  eventTransitioncancelMutationAll,
+  eventTransitioncancelMutationLight,
+  eventTransitioncancelMutationShadow,
+  eventTransitioncancelShadow,
+  eventTransitioncancelWindow,
+  eventTransitionend,
+  eventTransitionendAll,
+  eventTransitionendAppHost,
+  eventTransitionendDelegate,
+  eventTransitionendDelegateAll,
+  eventTransitionendDelegateLight,
+  eventTransitionendDelegateShadow,
+  eventTransitionendDocument,
+  eventTransitionendLight,
+  eventTransitionendMutation,
+  eventTransitionendMutationAll,
+  eventTransitionendMutationLight,
+  eventTransitionendMutationShadow,
+  eventTransitionendShadow,
+  eventTransitionendWindow,
+  eventTransitionrun,
+  eventTransitionrunAll,
+  eventTransitionrunAppHost,
+  eventTransitionrunDelegate,
+  eventTransitionrunDelegateAll,
+  eventTransitionrunDelegateLight,
+  eventTransitionrunDelegateShadow,
+  eventTransitionrunDocument,
+  eventTransitionrunLight,
+  eventTransitionrunMutation,
+  eventTransitionrunMutationAll,
+  eventTransitionrunMutationLight,
+  eventTransitionrunMutationShadow,
+  eventTransitionrunShadow,
+  eventTransitionrunWindow,
+  eventTransitionstart,
+  eventTransitionstartAll,
+  eventTransitionstartAppHost,
+  eventTransitionstartDelegate,
+  eventTransitionstartDelegateAll,
+  eventTransitionstartDelegateLight,
+  eventTransitionstartDelegateShadow,
+  eventTransitionstartDocument,
+  eventTransitionstartLight,
+  eventTransitionstartMutation,
+  eventTransitionstartMutationAll,
+  eventTransitionstartMutationLight,
+  eventTransitionstartMutationShadow,
+  eventTransitionstartShadow,
+  eventTransitionstartWindow,
+  eventWheel,
+  eventWheelAll,
+  eventWheelAppHost,
+  eventWheelDelegate,
+  eventWheelDelegateAll,
+  eventWheelDelegateLight,
+  eventWheelDelegateShadow,
+  eventWheelDocument,
+  eventWheelLight,
+  eventWheelMutation,
+  eventWheelMutationAll,
+  eventWheelMutationLight,
+  eventWheelMutationShadow,
+  eventWheelShadow,
+  eventWheelWindow,
   eventWindow,
-  getAddEventListenerMetadata
+  getAddEventListenerMetadata,
+  makeTypedEventAliases
 };
 //# sourceMappingURL=addEventListener.js.map