@dooboostore/simple-web-component 1.0.49 → 1.0.50

package/dist/esm-bundle/dooboostore-simple-web-component.esm.js

@@ -11793,15 +11793,21 @@ var NodeSlot = class _NodeSlot {
     const slots = this.findSlots();
     return slots.map((s) => s.nodes());
   }
-  append(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
+  /**
+   * Shared disambiguation for the `(...items)` / `(targetId, ...items)` overload pair.
+   * Items are always Node instances (or strings meant as literal content) coming from
+   * callers; a leading string is therefore always treated as `targetId`, even when no
+   * items follow — this avoids misclassifying `targetId` itself as content when the
+   * caller has zero items to insert (e.g. a decorated method returning undefined).
+   */
+  static parseTargetArgs(args) {
+    if (typeof args[0] === "string") {
+      return { targetId: args[0], items: args.slice(1) };
     }
+    return { targetId: void 0, items: args };
+  }
+  append(...args) {
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     if (!items || items.length === 0) return;
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
@@ -11810,38 +11816,17 @@ var NodeSlot = class _NodeSlot {
     }
   }
   appendHtml(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     for (const s of slots) s.appendHtml(...items);
   }
   appendText(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     for (const s of slots) s.appendText(...items);
   }
   appendCopy(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     if (!items || items.length === 0) return;
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
@@ -11850,14 +11835,7 @@ var NodeSlot = class _NodeSlot {
     }
   }
   prepend(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     if (!items || items.length === 0) return;
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
@@ -11866,38 +11844,17 @@ var NodeSlot = class _NodeSlot {
     }
   }
   prependHtml(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     for (const s of slots) s.prependHtml(...items);
   }
   prependText(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     for (const s of slots) s.prependText(...items);
   }
   prependCopy(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     if (!items || items.length === 0) return;
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
@@ -11917,14 +11874,7 @@ var NodeSlot = class _NodeSlot {
     }
   }
   replaceChildren(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
     for (const s of slots) {
@@ -11932,14 +11882,7 @@ var NodeSlot = class _NodeSlot {
     }
   }
   replaceChildrenHtml(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
     for (const s of slots) {
@@ -11947,14 +11890,7 @@ var NodeSlot = class _NodeSlot {
     }
   }
   replaceChildrenText(...args) {
-    let targetId;
-    let items = [];
-    if (typeof args[0] === "string" && args.length > 1) {
-      targetId = args[0];
-      items = args.slice(1);
-    } else {
-      items = args;
-    }
+    const { targetId, items } = _NodeSlot.parseTargetArgs(args);
     const slots = this.findSlots(targetId);
     if (!slots || slots.length === 0) return;
     for (const s of slots) {
@@ -13379,11 +13315,11 @@ var SwcUtils;
     };
   };
   SwcUtils2.getHelperAndHostSet = (win, el) => {
-    const helperSet = (0, SwcUtils2.getHelperSet)(win);
-    const hostSet = (0, SwcUtils2.getHostSet)(el);
+    const helperSet2 = (0, SwcUtils2.getHelperSet)(win);
+    const hostSet2 = (0, SwcUtils2.getHostSet)(el);
     return {
-      ...helperSet,
-      ...hostSet,
+      ...helperSet2,
+      ...hostSet2,
       $this: el
     };
   };
@@ -13646,6 +13582,49 @@ var SwcUtils;
   };
 })(SwcUtils || (SwcUtils = {}));
 
+// src/decorators/parameter.ts
+var SWC_PARAMETER_METADATA_KEY = Symbol.for("simple-web-component:parameter");
+var registerParam = (kind, target, propertyKey, parameterIndex) => {
+  if (!propertyKey) return;
+  const constructor = target.constructor;
+  const saves = ReflectUtils.getOwnMetadata(SWC_PARAMETER_METADATA_KEY, constructor, propertyKey) ?? [];
+  saves.push({ index: parameterIndex, kind });
+  ReflectUtils.defineMetadata(SWC_PARAMETER_METADATA_KEY, saves, constructor, propertyKey);
+};
+function eventObject(target, propertyKey, parameterIndex) {
+  registerParam("event", target, propertyKey, parameterIndex);
+}
+function matchedElement(target, propertyKey, parameterIndex) {
+  registerParam("matched", target, propertyKey, parameterIndex);
+}
+function hostSet(target, propertyKey, parameterIndex) {
+  registerParam("hostSet", target, propertyKey, parameterIndex);
+}
+function helperHostSet(target, propertyKey, parameterIndex) {
+  registerParam("helperHostSet", target, propertyKey, parameterIndex);
+}
+function helperSet(target, propertyKey, parameterIndex) {
+  registerParam("helperSet", target, propertyKey, parameterIndex);
+}
+function routerEvent(target, propertyKey, parameterIndex) {
+  registerParam("routerEvent", target, propertyKey, parameterIndex);
+}
+function appMessage(target, propertyKey, parameterIndex) {
+  registerParam("appMessage", target, propertyKey, parameterIndex);
+}
+var getParameterMetadata = (target, propertyKey) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return ReflectUtils.getMetadata(SWC_PARAMETER_METADATA_KEY, constructor, propertyKey) ?? [];
+};
+var buildSwcParameterArgs = (target, propertyKey, kindValues, legacyArgs) => {
+  const saves = getParameterMetadata(target, propertyKey);
+  if (saves.length === 0) return legacyArgs;
+  const maxIndex = Math.max(...saves.map((s) => s.index));
+  const args = new Array(maxIndex + 1);
+  for (const s of saves) args[s.index] = kindValues[s.kind];
+  return args;
+};
+
 // src/decorators/addEventListener.ts
 var ADD_EVENT_LISTENER_METADATA_KEY = Symbol.for("simple-web-component:add-event-listener");
 function addEventListener(selectorOrType, typeOrOptions, maybeOptions) {
@@ -13733,6 +13712,1029 @@ var eventAppHost = addEventListenerAppHost;
 var eventWindow = addEventListenerWindow;
 var eventDocument = addEventListenerDocument;
 var eventThis = addEventListenerThis;
+function makeTypedEventAliases(type) {
+  return {
+    base: (selector, options) => addEventListener(selector, type, options),
+    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),
+    this: (options) => addEventListenerThis(type, options),
+    appHost: (options) => addEventListenerAppHost(type, options),
+    window: (options) => addEventListenerWindow(type, options),
+    document: (options) => addEventListenerDocument(type, options)
+  };
+}
+var clickAliases = makeTypedEventAliases("click");
+var eventClick = clickAliases.base;
+var eventClickDelegateLight = clickAliases.delegateLight;
+var eventClickDelegateShadow = clickAliases.delegateShadow;
+var eventClickDelegateAll = clickAliases.delegateAll;
+var eventClickDelegate = clickAliases.delegate;
+var eventClickMutationLight = clickAliases.mutationLight;
+var eventClickMutationShadow = clickAliases.mutationShadow;
+var eventClickMutationAll = clickAliases.mutationAll;
+var eventClickMutation = clickAliases.mutation;
+var eventClickLight = clickAliases.light;
+var eventClickShadow = clickAliases.shadow;
+var eventClickAll = clickAliases.all;
+var eventClickThis = clickAliases.this;
+var eventClickAppHost = clickAliases.appHost;
+var eventClickWindow = clickAliases.window;
+var eventClickDocument = clickAliases.document;
+var dblclickAliases = makeTypedEventAliases("dblclick");
+var eventDblclick = dblclickAliases.base;
+var eventDblclickDelegateLight = dblclickAliases.delegateLight;
+var eventDblclickDelegateShadow = dblclickAliases.delegateShadow;
+var eventDblclickDelegateAll = dblclickAliases.delegateAll;
+var eventDblclickDelegate = dblclickAliases.delegate;
+var eventDblclickMutationLight = dblclickAliases.mutationLight;
+var eventDblclickMutationShadow = dblclickAliases.mutationShadow;
+var eventDblclickMutationAll = dblclickAliases.mutationAll;
+var eventDblclickMutation = dblclickAliases.mutation;
+var eventDblclickLight = dblclickAliases.light;
+var eventDblclickShadow = dblclickAliases.shadow;
+var eventDblclickAll = dblclickAliases.all;
+var eventDblclickThis = dblclickAliases.this;
+var eventDblclickAppHost = dblclickAliases.appHost;
+var eventDblclickWindow = dblclickAliases.window;
+var eventDblclickDocument = dblclickAliases.document;
+var mousedownAliases = makeTypedEventAliases("mousedown");
+var eventMousedown = mousedownAliases.base;
+var eventMousedownDelegateLight = mousedownAliases.delegateLight;
+var eventMousedownDelegateShadow = mousedownAliases.delegateShadow;
+var eventMousedownDelegateAll = mousedownAliases.delegateAll;
+var eventMousedownDelegate = mousedownAliases.delegate;
+var eventMousedownMutationLight = mousedownAliases.mutationLight;
+var eventMousedownMutationShadow = mousedownAliases.mutationShadow;
+var eventMousedownMutationAll = mousedownAliases.mutationAll;
+var eventMousedownMutation = mousedownAliases.mutation;
+var eventMousedownLight = mousedownAliases.light;
+var eventMousedownShadow = mousedownAliases.shadow;
+var eventMousedownAll = mousedownAliases.all;
+var eventMousedownThis = mousedownAliases.this;
+var eventMousedownAppHost = mousedownAliases.appHost;
+var eventMousedownWindow = mousedownAliases.window;
+var eventMousedownDocument = mousedownAliases.document;
+var mouseupAliases = makeTypedEventAliases("mouseup");
+var eventMouseup = mouseupAliases.base;
+var eventMouseupDelegateLight = mouseupAliases.delegateLight;
+var eventMouseupDelegateShadow = mouseupAliases.delegateShadow;
+var eventMouseupDelegateAll = mouseupAliases.delegateAll;
+var eventMouseupDelegate = mouseupAliases.delegate;
+var eventMouseupMutationLight = mouseupAliases.mutationLight;
+var eventMouseupMutationShadow = mouseupAliases.mutationShadow;
+var eventMouseupMutationAll = mouseupAliases.mutationAll;
+var eventMouseupMutation = mouseupAliases.mutation;
+var eventMouseupLight = mouseupAliases.light;
+var eventMouseupShadow = mouseupAliases.shadow;
+var eventMouseupAll = mouseupAliases.all;
+var eventMouseupThis = mouseupAliases.this;
+var eventMouseupAppHost = mouseupAliases.appHost;
+var eventMouseupWindow = mouseupAliases.window;
+var eventMouseupDocument = mouseupAliases.document;
+var mousemoveAliases = makeTypedEventAliases("mousemove");
+var eventMousemove = mousemoveAliases.base;
+var eventMousemoveDelegateLight = mousemoveAliases.delegateLight;
+var eventMousemoveDelegateShadow = mousemoveAliases.delegateShadow;
+var eventMousemoveDelegateAll = mousemoveAliases.delegateAll;
+var eventMousemoveDelegate = mousemoveAliases.delegate;
+var eventMousemoveMutationLight = mousemoveAliases.mutationLight;
+var eventMousemoveMutationShadow = mousemoveAliases.mutationShadow;
+var eventMousemoveMutationAll = mousemoveAliases.mutationAll;
+var eventMousemoveMutation = mousemoveAliases.mutation;
+var eventMousemoveLight = mousemoveAliases.light;
+var eventMousemoveShadow = mousemoveAliases.shadow;
+var eventMousemoveAll = mousemoveAliases.all;
+var eventMousemoveThis = mousemoveAliases.this;
+var eventMousemoveAppHost = mousemoveAliases.appHost;
+var eventMousemoveWindow = mousemoveAliases.window;
+var eventMousemoveDocument = mousemoveAliases.document;
+var mouseoverAliases = makeTypedEventAliases("mouseover");
+var eventMouseover = mouseoverAliases.base;
+var eventMouseoverDelegateLight = mouseoverAliases.delegateLight;
+var eventMouseoverDelegateShadow = mouseoverAliases.delegateShadow;
+var eventMouseoverDelegateAll = mouseoverAliases.delegateAll;
+var eventMouseoverDelegate = mouseoverAliases.delegate;
+var eventMouseoverMutationLight = mouseoverAliases.mutationLight;
+var eventMouseoverMutationShadow = mouseoverAliases.mutationShadow;
+var eventMouseoverMutationAll = mouseoverAliases.mutationAll;
+var eventMouseoverMutation = mouseoverAliases.mutation;
+var eventMouseoverLight = mouseoverAliases.light;
+var eventMouseoverShadow = mouseoverAliases.shadow;
+var eventMouseoverAll = mouseoverAliases.all;
+var eventMouseoverThis = mouseoverAliases.this;
+var eventMouseoverAppHost = mouseoverAliases.appHost;
+var eventMouseoverWindow = mouseoverAliases.window;
+var eventMouseoverDocument = mouseoverAliases.document;
+var mouseoutAliases = makeTypedEventAliases("mouseout");
+var eventMouseout = mouseoutAliases.base;
+var eventMouseoutDelegateLight = mouseoutAliases.delegateLight;
+var eventMouseoutDelegateShadow = mouseoutAliases.delegateShadow;
+var eventMouseoutDelegateAll = mouseoutAliases.delegateAll;
+var eventMouseoutDelegate = mouseoutAliases.delegate;
+var eventMouseoutMutationLight = mouseoutAliases.mutationLight;
+var eventMouseoutMutationShadow = mouseoutAliases.mutationShadow;
+var eventMouseoutMutationAll = mouseoutAliases.mutationAll;
+var eventMouseoutMutation = mouseoutAliases.mutation;
+var eventMouseoutLight = mouseoutAliases.light;
+var eventMouseoutShadow = mouseoutAliases.shadow;
+var eventMouseoutAll = mouseoutAliases.all;
+var eventMouseoutThis = mouseoutAliases.this;
+var eventMouseoutAppHost = mouseoutAliases.appHost;
+var eventMouseoutWindow = mouseoutAliases.window;
+var eventMouseoutDocument = mouseoutAliases.document;
+var mouseenterAliases = makeTypedEventAliases("mouseenter");
+var eventMouseenter = mouseenterAliases.base;
+var eventMouseenterDelegateLight = mouseenterAliases.delegateLight;
+var eventMouseenterDelegateShadow = mouseenterAliases.delegateShadow;
+var eventMouseenterDelegateAll = mouseenterAliases.delegateAll;
+var eventMouseenterDelegate = mouseenterAliases.delegate;
+var eventMouseenterMutationLight = mouseenterAliases.mutationLight;
+var eventMouseenterMutationShadow = mouseenterAliases.mutationShadow;
+var eventMouseenterMutationAll = mouseenterAliases.mutationAll;
+var eventMouseenterMutation = mouseenterAliases.mutation;
+var eventMouseenterLight = mouseenterAliases.light;
+var eventMouseenterShadow = mouseenterAliases.shadow;
+var eventMouseenterAll = mouseenterAliases.all;
+var eventMouseenterThis = mouseenterAliases.this;
+var eventMouseenterAppHost = mouseenterAliases.appHost;
+var eventMouseenterWindow = mouseenterAliases.window;
+var eventMouseenterDocument = mouseenterAliases.document;
+var mouseleaveAliases = makeTypedEventAliases("mouseleave");
+var eventMouseleave = mouseleaveAliases.base;
+var eventMouseleaveDelegateLight = mouseleaveAliases.delegateLight;
+var eventMouseleaveDelegateShadow = mouseleaveAliases.delegateShadow;
+var eventMouseleaveDelegateAll = mouseleaveAliases.delegateAll;
+var eventMouseleaveDelegate = mouseleaveAliases.delegate;
+var eventMouseleaveMutationLight = mouseleaveAliases.mutationLight;
+var eventMouseleaveMutationShadow = mouseleaveAliases.mutationShadow;
+var eventMouseleaveMutationAll = mouseleaveAliases.mutationAll;
+var eventMouseleaveMutation = mouseleaveAliases.mutation;
+var eventMouseleaveLight = mouseleaveAliases.light;
+var eventMouseleaveShadow = mouseleaveAliases.shadow;
+var eventMouseleaveAll = mouseleaveAliases.all;
+var eventMouseleaveThis = mouseleaveAliases.this;
+var eventMouseleaveAppHost = mouseleaveAliases.appHost;
+var eventMouseleaveWindow = mouseleaveAliases.window;
+var eventMouseleaveDocument = mouseleaveAliases.document;
+var contextmenuAliases = makeTypedEventAliases("contextmenu");
+var eventContextmenu = contextmenuAliases.base;
+var eventContextmenuDelegateLight = contextmenuAliases.delegateLight;
+var eventContextmenuDelegateShadow = contextmenuAliases.delegateShadow;
+var eventContextmenuDelegateAll = contextmenuAliases.delegateAll;
+var eventContextmenuDelegate = contextmenuAliases.delegate;
+var eventContextmenuMutationLight = contextmenuAliases.mutationLight;
+var eventContextmenuMutationShadow = contextmenuAliases.mutationShadow;
+var eventContextmenuMutationAll = contextmenuAliases.mutationAll;
+var eventContextmenuMutation = contextmenuAliases.mutation;
+var eventContextmenuLight = contextmenuAliases.light;
+var eventContextmenuShadow = contextmenuAliases.shadow;
+var eventContextmenuAll = contextmenuAliases.all;
+var eventContextmenuThis = contextmenuAliases.this;
+var eventContextmenuAppHost = contextmenuAliases.appHost;
+var eventContextmenuWindow = contextmenuAliases.window;
+var eventContextmenuDocument = contextmenuAliases.document;
+var wheelAliases = makeTypedEventAliases("wheel");
+var eventWheel = wheelAliases.base;
+var eventWheelDelegateLight = wheelAliases.delegateLight;
+var eventWheelDelegateShadow = wheelAliases.delegateShadow;
+var eventWheelDelegateAll = wheelAliases.delegateAll;
+var eventWheelDelegate = wheelAliases.delegate;
+var eventWheelMutationLight = wheelAliases.mutationLight;
+var eventWheelMutationShadow = wheelAliases.mutationShadow;
+var eventWheelMutationAll = wheelAliases.mutationAll;
+var eventWheelMutation = wheelAliases.mutation;
+var eventWheelLight = wheelAliases.light;
+var eventWheelShadow = wheelAliases.shadow;
+var eventWheelAll = wheelAliases.all;
+var eventWheelThis = wheelAliases.this;
+var eventWheelAppHost = wheelAliases.appHost;
+var eventWheelWindow = wheelAliases.window;
+var eventWheelDocument = wheelAliases.document;
+var keydownAliases = makeTypedEventAliases("keydown");
+var eventKeydown = keydownAliases.base;
+var eventKeydownDelegateLight = keydownAliases.delegateLight;
+var eventKeydownDelegateShadow = keydownAliases.delegateShadow;
+var eventKeydownDelegateAll = keydownAliases.delegateAll;
+var eventKeydownDelegate = keydownAliases.delegate;
+var eventKeydownMutationLight = keydownAliases.mutationLight;
+var eventKeydownMutationShadow = keydownAliases.mutationShadow;
+var eventKeydownMutationAll = keydownAliases.mutationAll;
+var eventKeydownMutation = keydownAliases.mutation;
+var eventKeydownLight = keydownAliases.light;
+var eventKeydownShadow = keydownAliases.shadow;
+var eventKeydownAll = keydownAliases.all;
+var eventKeydownThis = keydownAliases.this;
+var eventKeydownAppHost = keydownAliases.appHost;
+var eventKeydownWindow = keydownAliases.window;
+var eventKeydownDocument = keydownAliases.document;
+var keyupAliases = makeTypedEventAliases("keyup");
+var eventKeyup = keyupAliases.base;
+var eventKeyupDelegateLight = keyupAliases.delegateLight;
+var eventKeyupDelegateShadow = keyupAliases.delegateShadow;
+var eventKeyupDelegateAll = keyupAliases.delegateAll;
+var eventKeyupDelegate = keyupAliases.delegate;
+var eventKeyupMutationLight = keyupAliases.mutationLight;
+var eventKeyupMutationShadow = keyupAliases.mutationShadow;
+var eventKeyupMutationAll = keyupAliases.mutationAll;
+var eventKeyupMutation = keyupAliases.mutation;
+var eventKeyupLight = keyupAliases.light;
+var eventKeyupShadow = keyupAliases.shadow;
+var eventKeyupAll = keyupAliases.all;
+var eventKeyupThis = keyupAliases.this;
+var eventKeyupAppHost = keyupAliases.appHost;
+var eventKeyupWindow = keyupAliases.window;
+var eventKeyupDocument = keyupAliases.document;
+var keypressAliases = makeTypedEventAliases("keypress");
+var eventKeypress = keypressAliases.base;
+var eventKeypressDelegateLight = keypressAliases.delegateLight;
+var eventKeypressDelegateShadow = keypressAliases.delegateShadow;
+var eventKeypressDelegateAll = keypressAliases.delegateAll;
+var eventKeypressDelegate = keypressAliases.delegate;
+var eventKeypressMutationLight = keypressAliases.mutationLight;
+var eventKeypressMutationShadow = keypressAliases.mutationShadow;
+var eventKeypressMutationAll = keypressAliases.mutationAll;
+var eventKeypressMutation = keypressAliases.mutation;
+var eventKeypressLight = keypressAliases.light;
+var eventKeypressShadow = keypressAliases.shadow;
+var eventKeypressAll = keypressAliases.all;
+var eventKeypressThis = keypressAliases.this;
+var eventKeypressAppHost = keypressAliases.appHost;
+var eventKeypressWindow = keypressAliases.window;
+var eventKeypressDocument = keypressAliases.document;
+var inputAliases = makeTypedEventAliases("input");
+var eventInput = inputAliases.base;
+var eventInputDelegateLight = inputAliases.delegateLight;
+var eventInputDelegateShadow = inputAliases.delegateShadow;
+var eventInputDelegateAll = inputAliases.delegateAll;
+var eventInputDelegate = inputAliases.delegate;
+var eventInputMutationLight = inputAliases.mutationLight;
+var eventInputMutationShadow = inputAliases.mutationShadow;
+var eventInputMutationAll = inputAliases.mutationAll;
+var eventInputMutation = inputAliases.mutation;
+var eventInputLight = inputAliases.light;
+var eventInputShadow = inputAliases.shadow;
+var eventInputAll = inputAliases.all;
+var eventInputThis = inputAliases.this;
+var eventInputAppHost = inputAliases.appHost;
+var eventInputWindow = inputAliases.window;
+var eventInputDocument = inputAliases.document;
+var changeAliases = makeTypedEventAliases("change");
+var eventChange = changeAliases.base;
+var eventChangeDelegateLight = changeAliases.delegateLight;
+var eventChangeDelegateShadow = changeAliases.delegateShadow;
+var eventChangeDelegateAll = changeAliases.delegateAll;
+var eventChangeDelegate = changeAliases.delegate;
+var eventChangeMutationLight = changeAliases.mutationLight;
+var eventChangeMutationShadow = changeAliases.mutationShadow;
+var eventChangeMutationAll = changeAliases.mutationAll;
+var eventChangeMutation = changeAliases.mutation;
+var eventChangeLight = changeAliases.light;
+var eventChangeShadow = changeAliases.shadow;
+var eventChangeAll = changeAliases.all;
+var eventChangeThis = changeAliases.this;
+var eventChangeAppHost = changeAliases.appHost;
+var eventChangeWindow = changeAliases.window;
+var eventChangeDocument = changeAliases.document;
+var submitAliases = makeTypedEventAliases("submit");
+var eventSubmit = submitAliases.base;
+var eventSubmitDelegateLight = submitAliases.delegateLight;
+var eventSubmitDelegateShadow = submitAliases.delegateShadow;
+var eventSubmitDelegateAll = submitAliases.delegateAll;
+var eventSubmitDelegate = submitAliases.delegate;
+var eventSubmitMutationLight = submitAliases.mutationLight;
+var eventSubmitMutationShadow = submitAliases.mutationShadow;
+var eventSubmitMutationAll = submitAliases.mutationAll;
+var eventSubmitMutation = submitAliases.mutation;
+var eventSubmitLight = submitAliases.light;
+var eventSubmitShadow = submitAliases.shadow;
+var eventSubmitAll = submitAliases.all;
+var eventSubmitThis = submitAliases.this;
+var eventSubmitAppHost = submitAliases.appHost;
+var eventSubmitWindow = submitAliases.window;
+var eventSubmitDocument = submitAliases.document;
+var resetAliases = makeTypedEventAliases("reset");
+var eventReset = resetAliases.base;
+var eventResetDelegateLight = resetAliases.delegateLight;
+var eventResetDelegateShadow = resetAliases.delegateShadow;
+var eventResetDelegateAll = resetAliases.delegateAll;
+var eventResetDelegate = resetAliases.delegate;
+var eventResetMutationLight = resetAliases.mutationLight;
+var eventResetMutationShadow = resetAliases.mutationShadow;
+var eventResetMutationAll = resetAliases.mutationAll;
+var eventResetMutation = resetAliases.mutation;
+var eventResetLight = resetAliases.light;
+var eventResetShadow = resetAliases.shadow;
+var eventResetAll = resetAliases.all;
+var eventResetThis = resetAliases.this;
+var eventResetAppHost = resetAliases.appHost;
+var eventResetWindow = resetAliases.window;
+var eventResetDocument = resetAliases.document;
+var invalidAliases = makeTypedEventAliases("invalid");
+var eventInvalid = invalidAliases.base;
+var eventInvalidDelegateLight = invalidAliases.delegateLight;
+var eventInvalidDelegateShadow = invalidAliases.delegateShadow;
+var eventInvalidDelegateAll = invalidAliases.delegateAll;
+var eventInvalidDelegate = invalidAliases.delegate;
+var eventInvalidMutationLight = invalidAliases.mutationLight;
+var eventInvalidMutationShadow = invalidAliases.mutationShadow;
+var eventInvalidMutationAll = invalidAliases.mutationAll;
+var eventInvalidMutation = invalidAliases.mutation;
+var eventInvalidLight = invalidAliases.light;
+var eventInvalidShadow = invalidAliases.shadow;
+var eventInvalidAll = invalidAliases.all;
+var eventInvalidThis = invalidAliases.this;
+var eventInvalidAppHost = invalidAliases.appHost;
+var eventInvalidWindow = invalidAliases.window;
+var eventInvalidDocument = invalidAliases.document;
+var selectAliases = makeTypedEventAliases("select");
+var eventSelect = selectAliases.base;
+var eventSelectDelegateLight = selectAliases.delegateLight;
+var eventSelectDelegateShadow = selectAliases.delegateShadow;
+var eventSelectDelegateAll = selectAliases.delegateAll;
+var eventSelectDelegate = selectAliases.delegate;
+var eventSelectMutationLight = selectAliases.mutationLight;
+var eventSelectMutationShadow = selectAliases.mutationShadow;
+var eventSelectMutationAll = selectAliases.mutationAll;
+var eventSelectMutation = selectAliases.mutation;
+var eventSelectLight = selectAliases.light;
+var eventSelectShadow = selectAliases.shadow;
+var eventSelectAll = selectAliases.all;
+var eventSelectThis = selectAliases.this;
+var eventSelectAppHost = selectAliases.appHost;
+var eventSelectWindow = selectAliases.window;
+var eventSelectDocument = selectAliases.document;
+var focusAliases = makeTypedEventAliases("focus");
+var eventFocus = focusAliases.base;
+var eventFocusDelegateLight = focusAliases.delegateLight;
+var eventFocusDelegateShadow = focusAliases.delegateShadow;
+var eventFocusDelegateAll = focusAliases.delegateAll;
+var eventFocusDelegate = focusAliases.delegate;
+var eventFocusMutationLight = focusAliases.mutationLight;
+var eventFocusMutationShadow = focusAliases.mutationShadow;
+var eventFocusMutationAll = focusAliases.mutationAll;
+var eventFocusMutation = focusAliases.mutation;
+var eventFocusLight = focusAliases.light;
+var eventFocusShadow = focusAliases.shadow;
+var eventFocusAll = focusAliases.all;
+var eventFocusThis = focusAliases.this;
+var eventFocusAppHost = focusAliases.appHost;
+var eventFocusWindow = focusAliases.window;
+var eventFocusDocument = focusAliases.document;
+var blurAliases = makeTypedEventAliases("blur");
+var eventBlur = blurAliases.base;
+var eventBlurDelegateLight = blurAliases.delegateLight;
+var eventBlurDelegateShadow = blurAliases.delegateShadow;
+var eventBlurDelegateAll = blurAliases.delegateAll;
+var eventBlurDelegate = blurAliases.delegate;
+var eventBlurMutationLight = blurAliases.mutationLight;
+var eventBlurMutationShadow = blurAliases.mutationShadow;
+var eventBlurMutationAll = blurAliases.mutationAll;
+var eventBlurMutation = blurAliases.mutation;
+var eventBlurLight = blurAliases.light;
+var eventBlurShadow = blurAliases.shadow;
+var eventBlurAll = blurAliases.all;
+var eventBlurThis = blurAliases.this;
+var eventBlurAppHost = blurAliases.appHost;
+var eventBlurWindow = blurAliases.window;
+var eventBlurDocument = blurAliases.document;
+var focusinAliases = makeTypedEventAliases("focusin");
+var eventFocusin = focusinAliases.base;
+var eventFocusinDelegateLight = focusinAliases.delegateLight;
+var eventFocusinDelegateShadow = focusinAliases.delegateShadow;
+var eventFocusinDelegateAll = focusinAliases.delegateAll;
+var eventFocusinDelegate = focusinAliases.delegate;
+var eventFocusinMutationLight = focusinAliases.mutationLight;
+var eventFocusinMutationShadow = focusinAliases.mutationShadow;
+var eventFocusinMutationAll = focusinAliases.mutationAll;
+var eventFocusinMutation = focusinAliases.mutation;
+var eventFocusinLight = focusinAliases.light;
+var eventFocusinShadow = focusinAliases.shadow;
+var eventFocusinAll = focusinAliases.all;
+var eventFocusinThis = focusinAliases.this;
+var eventFocusinAppHost = focusinAliases.appHost;
+var eventFocusinWindow = focusinAliases.window;
+var eventFocusinDocument = focusinAliases.document;
+var focusoutAliases = makeTypedEventAliases("focusout");
+var eventFocusout = focusoutAliases.base;
+var eventFocusoutDelegateLight = focusoutAliases.delegateLight;
+var eventFocusoutDelegateShadow = focusoutAliases.delegateShadow;
+var eventFocusoutDelegateAll = focusoutAliases.delegateAll;
+var eventFocusoutDelegate = focusoutAliases.delegate;
+var eventFocusoutMutationLight = focusoutAliases.mutationLight;
+var eventFocusoutMutationShadow = focusoutAliases.mutationShadow;
+var eventFocusoutMutationAll = focusoutAliases.mutationAll;
+var eventFocusoutMutation = focusoutAliases.mutation;
+var eventFocusoutLight = focusoutAliases.light;
+var eventFocusoutShadow = focusoutAliases.shadow;
+var eventFocusoutAll = focusoutAliases.all;
+var eventFocusoutThis = focusoutAliases.this;
+var eventFocusoutAppHost = focusoutAliases.appHost;
+var eventFocusoutWindow = focusoutAliases.window;
+var eventFocusoutDocument = focusoutAliases.document;
+var dragstartAliases = makeTypedEventAliases("dragstart");
+var eventDragstart = dragstartAliases.base;
+var eventDragstartDelegateLight = dragstartAliases.delegateLight;
+var eventDragstartDelegateShadow = dragstartAliases.delegateShadow;
+var eventDragstartDelegateAll = dragstartAliases.delegateAll;
+var eventDragstartDelegate = dragstartAliases.delegate;
+var eventDragstartMutationLight = dragstartAliases.mutationLight;
+var eventDragstartMutationShadow = dragstartAliases.mutationShadow;
+var eventDragstartMutationAll = dragstartAliases.mutationAll;
+var eventDragstartMutation = dragstartAliases.mutation;
+var eventDragstartLight = dragstartAliases.light;
+var eventDragstartShadow = dragstartAliases.shadow;
+var eventDragstartAll = dragstartAliases.all;
+var eventDragstartThis = dragstartAliases.this;
+var eventDragstartAppHost = dragstartAliases.appHost;
+var eventDragstartWindow = dragstartAliases.window;
+var eventDragstartDocument = dragstartAliases.document;
+var dragAliases = makeTypedEventAliases("drag");
+var eventDrag = dragAliases.base;
+var eventDragDelegateLight = dragAliases.delegateLight;
+var eventDragDelegateShadow = dragAliases.delegateShadow;
+var eventDragDelegateAll = dragAliases.delegateAll;
+var eventDragDelegate = dragAliases.delegate;
+var eventDragMutationLight = dragAliases.mutationLight;
+var eventDragMutationShadow = dragAliases.mutationShadow;
+var eventDragMutationAll = dragAliases.mutationAll;
+var eventDragMutation = dragAliases.mutation;
+var eventDragLight = dragAliases.light;
+var eventDragShadow = dragAliases.shadow;
+var eventDragAll = dragAliases.all;
+var eventDragThis = dragAliases.this;
+var eventDragAppHost = dragAliases.appHost;
+var eventDragWindow = dragAliases.window;
+var eventDragDocument = dragAliases.document;
+var dragendAliases = makeTypedEventAliases("dragend");
+var eventDragend = dragendAliases.base;
+var eventDragendDelegateLight = dragendAliases.delegateLight;
+var eventDragendDelegateShadow = dragendAliases.delegateShadow;
+var eventDragendDelegateAll = dragendAliases.delegateAll;
+var eventDragendDelegate = dragendAliases.delegate;
+var eventDragendMutationLight = dragendAliases.mutationLight;
+var eventDragendMutationShadow = dragendAliases.mutationShadow;
+var eventDragendMutationAll = dragendAliases.mutationAll;
+var eventDragendMutation = dragendAliases.mutation;
+var eventDragendLight = dragendAliases.light;
+var eventDragendShadow = dragendAliases.shadow;
+var eventDragendAll = dragendAliases.all;
+var eventDragendThis = dragendAliases.this;
+var eventDragendAppHost = dragendAliases.appHost;
+var eventDragendWindow = dragendAliases.window;
+var eventDragendDocument = dragendAliases.document;
+var dragenterAliases = makeTypedEventAliases("dragenter");
+var eventDragenter = dragenterAliases.base;
+var eventDragenterDelegateLight = dragenterAliases.delegateLight;
+var eventDragenterDelegateShadow = dragenterAliases.delegateShadow;
+var eventDragenterDelegateAll = dragenterAliases.delegateAll;
+var eventDragenterDelegate = dragenterAliases.delegate;
+var eventDragenterMutationLight = dragenterAliases.mutationLight;
+var eventDragenterMutationShadow = dragenterAliases.mutationShadow;
+var eventDragenterMutationAll = dragenterAliases.mutationAll;
+var eventDragenterMutation = dragenterAliases.mutation;
+var eventDragenterLight = dragenterAliases.light;
+var eventDragenterShadow = dragenterAliases.shadow;
+var eventDragenterAll = dragenterAliases.all;
+var eventDragenterThis = dragenterAliases.this;
+var eventDragenterAppHost = dragenterAliases.appHost;
+var eventDragenterWindow = dragenterAliases.window;
+var eventDragenterDocument = dragenterAliases.document;
+var dragleaveAliases = makeTypedEventAliases("dragleave");
+var eventDragleave = dragleaveAliases.base;
+var eventDragleaveDelegateLight = dragleaveAliases.delegateLight;
+var eventDragleaveDelegateShadow = dragleaveAliases.delegateShadow;
+var eventDragleaveDelegateAll = dragleaveAliases.delegateAll;
+var eventDragleaveDelegate = dragleaveAliases.delegate;
+var eventDragleaveMutationLight = dragleaveAliases.mutationLight;
+var eventDragleaveMutationShadow = dragleaveAliases.mutationShadow;
+var eventDragleaveMutationAll = dragleaveAliases.mutationAll;
+var eventDragleaveMutation = dragleaveAliases.mutation;
+var eventDragleaveLight = dragleaveAliases.light;
+var eventDragleaveShadow = dragleaveAliases.shadow;
+var eventDragleaveAll = dragleaveAliases.all;
+var eventDragleaveThis = dragleaveAliases.this;
+var eventDragleaveAppHost = dragleaveAliases.appHost;
+var eventDragleaveWindow = dragleaveAliases.window;
+var eventDragleaveDocument = dragleaveAliases.document;
+var dragoverAliases = makeTypedEventAliases("dragover");
+var eventDragover = dragoverAliases.base;
+var eventDragoverDelegateLight = dragoverAliases.delegateLight;
+var eventDragoverDelegateShadow = dragoverAliases.delegateShadow;
+var eventDragoverDelegateAll = dragoverAliases.delegateAll;
+var eventDragoverDelegate = dragoverAliases.delegate;
+var eventDragoverMutationLight = dragoverAliases.mutationLight;
+var eventDragoverMutationShadow = dragoverAliases.mutationShadow;
+var eventDragoverMutationAll = dragoverAliases.mutationAll;
+var eventDragoverMutation = dragoverAliases.mutation;
+var eventDragoverLight = dragoverAliases.light;
+var eventDragoverShadow = dragoverAliases.shadow;
+var eventDragoverAll = dragoverAliases.all;
+var eventDragoverThis = dragoverAliases.this;
+var eventDragoverAppHost = dragoverAliases.appHost;
+var eventDragoverWindow = dragoverAliases.window;
+var eventDragoverDocument = dragoverAliases.document;
+var dropAliases = makeTypedEventAliases("drop");
+var eventDrop = dropAliases.base;
+var eventDropDelegateLight = dropAliases.delegateLight;
+var eventDropDelegateShadow = dropAliases.delegateShadow;
+var eventDropDelegateAll = dropAliases.delegateAll;
+var eventDropDelegate = dropAliases.delegate;
+var eventDropMutationLight = dropAliases.mutationLight;
+var eventDropMutationShadow = dropAliases.mutationShadow;
+var eventDropMutationAll = dropAliases.mutationAll;
+var eventDropMutation = dropAliases.mutation;
+var eventDropLight = dropAliases.light;
+var eventDropShadow = dropAliases.shadow;
+var eventDropAll = dropAliases.all;
+var eventDropThis = dropAliases.this;
+var eventDropAppHost = dropAliases.appHost;
+var eventDropWindow = dropAliases.window;
+var eventDropDocument = dropAliases.document;
+var touchstartAliases = makeTypedEventAliases("touchstart");
+var eventTouchstart = touchstartAliases.base;
+var eventTouchstartDelegateLight = touchstartAliases.delegateLight;
+var eventTouchstartDelegateShadow = touchstartAliases.delegateShadow;
+var eventTouchstartDelegateAll = touchstartAliases.delegateAll;
+var eventTouchstartDelegate = touchstartAliases.delegate;
+var eventTouchstartMutationLight = touchstartAliases.mutationLight;
+var eventTouchstartMutationShadow = touchstartAliases.mutationShadow;
+var eventTouchstartMutationAll = touchstartAliases.mutationAll;
+var eventTouchstartMutation = touchstartAliases.mutation;
+var eventTouchstartLight = touchstartAliases.light;
+var eventTouchstartShadow = touchstartAliases.shadow;
+var eventTouchstartAll = touchstartAliases.all;
+var eventTouchstartThis = touchstartAliases.this;
+var eventTouchstartAppHost = touchstartAliases.appHost;
+var eventTouchstartWindow = touchstartAliases.window;
+var eventTouchstartDocument = touchstartAliases.document;
+var touchmoveAliases = makeTypedEventAliases("touchmove");
+var eventTouchmove = touchmoveAliases.base;
+var eventTouchmoveDelegateLight = touchmoveAliases.delegateLight;
+var eventTouchmoveDelegateShadow = touchmoveAliases.delegateShadow;
+var eventTouchmoveDelegateAll = touchmoveAliases.delegateAll;
+var eventTouchmoveDelegate = touchmoveAliases.delegate;
+var eventTouchmoveMutationLight = touchmoveAliases.mutationLight;
+var eventTouchmoveMutationShadow = touchmoveAliases.mutationShadow;
+var eventTouchmoveMutationAll = touchmoveAliases.mutationAll;
+var eventTouchmoveMutation = touchmoveAliases.mutation;
+var eventTouchmoveLight = touchmoveAliases.light;
+var eventTouchmoveShadow = touchmoveAliases.shadow;
+var eventTouchmoveAll = touchmoveAliases.all;
+var eventTouchmoveThis = touchmoveAliases.this;
+var eventTouchmoveAppHost = touchmoveAliases.appHost;
+var eventTouchmoveWindow = touchmoveAliases.window;
+var eventTouchmoveDocument = touchmoveAliases.document;
+var touchendAliases = makeTypedEventAliases("touchend");
+var eventTouchend = touchendAliases.base;
+var eventTouchendDelegateLight = touchendAliases.delegateLight;
+var eventTouchendDelegateShadow = touchendAliases.delegateShadow;
+var eventTouchendDelegateAll = touchendAliases.delegateAll;
+var eventTouchendDelegate = touchendAliases.delegate;
+var eventTouchendMutationLight = touchendAliases.mutationLight;
+var eventTouchendMutationShadow = touchendAliases.mutationShadow;
+var eventTouchendMutationAll = touchendAliases.mutationAll;
+var eventTouchendMutation = touchendAliases.mutation;
+var eventTouchendLight = touchendAliases.light;
+var eventTouchendShadow = touchendAliases.shadow;
+var eventTouchendAll = touchendAliases.all;
+var eventTouchendThis = touchendAliases.this;
+var eventTouchendAppHost = touchendAliases.appHost;
+var eventTouchendWindow = touchendAliases.window;
+var eventTouchendDocument = touchendAliases.document;
+var touchcancelAliases = makeTypedEventAliases("touchcancel");
+var eventTouchcancel = touchcancelAliases.base;
+var eventTouchcancelDelegateLight = touchcancelAliases.delegateLight;
+var eventTouchcancelDelegateShadow = touchcancelAliases.delegateShadow;
+var eventTouchcancelDelegateAll = touchcancelAliases.delegateAll;
+var eventTouchcancelDelegate = touchcancelAliases.delegate;
+var eventTouchcancelMutationLight = touchcancelAliases.mutationLight;
+var eventTouchcancelMutationShadow = touchcancelAliases.mutationShadow;
+var eventTouchcancelMutationAll = touchcancelAliases.mutationAll;
+var eventTouchcancelMutation = touchcancelAliases.mutation;
+var eventTouchcancelLight = touchcancelAliases.light;
+var eventTouchcancelShadow = touchcancelAliases.shadow;
+var eventTouchcancelAll = touchcancelAliases.all;
+var eventTouchcancelThis = touchcancelAliases.this;
+var eventTouchcancelAppHost = touchcancelAliases.appHost;
+var eventTouchcancelWindow = touchcancelAliases.window;
+var eventTouchcancelDocument = touchcancelAliases.document;
+var pointerdownAliases = makeTypedEventAliases("pointerdown");
+var eventPointerdown = pointerdownAliases.base;
+var eventPointerdownDelegateLight = pointerdownAliases.delegateLight;
+var eventPointerdownDelegateShadow = pointerdownAliases.delegateShadow;
+var eventPointerdownDelegateAll = pointerdownAliases.delegateAll;
+var eventPointerdownDelegate = pointerdownAliases.delegate;
+var eventPointerdownMutationLight = pointerdownAliases.mutationLight;
+var eventPointerdownMutationShadow = pointerdownAliases.mutationShadow;
+var eventPointerdownMutationAll = pointerdownAliases.mutationAll;
+var eventPointerdownMutation = pointerdownAliases.mutation;
+var eventPointerdownLight = pointerdownAliases.light;
+var eventPointerdownShadow = pointerdownAliases.shadow;
+var eventPointerdownAll = pointerdownAliases.all;
+var eventPointerdownThis = pointerdownAliases.this;
+var eventPointerdownAppHost = pointerdownAliases.appHost;
+var eventPointerdownWindow = pointerdownAliases.window;
+var eventPointerdownDocument = pointerdownAliases.document;
+var pointerupAliases = makeTypedEventAliases("pointerup");
+var eventPointerup = pointerupAliases.base;
+var eventPointerupDelegateLight = pointerupAliases.delegateLight;
+var eventPointerupDelegateShadow = pointerupAliases.delegateShadow;
+var eventPointerupDelegateAll = pointerupAliases.delegateAll;
+var eventPointerupDelegate = pointerupAliases.delegate;
+var eventPointerupMutationLight = pointerupAliases.mutationLight;
+var eventPointerupMutationShadow = pointerupAliases.mutationShadow;
+var eventPointerupMutationAll = pointerupAliases.mutationAll;
+var eventPointerupMutation = pointerupAliases.mutation;
+var eventPointerupLight = pointerupAliases.light;
+var eventPointerupShadow = pointerupAliases.shadow;
+var eventPointerupAll = pointerupAliases.all;
+var eventPointerupThis = pointerupAliases.this;
+var eventPointerupAppHost = pointerupAliases.appHost;
+var eventPointerupWindow = pointerupAliases.window;
+var eventPointerupDocument = pointerupAliases.document;
+var pointermoveAliases = makeTypedEventAliases("pointermove");
+var eventPointermove = pointermoveAliases.base;
+var eventPointermoveDelegateLight = pointermoveAliases.delegateLight;
+var eventPointermoveDelegateShadow = pointermoveAliases.delegateShadow;
+var eventPointermoveDelegateAll = pointermoveAliases.delegateAll;
+var eventPointermoveDelegate = pointermoveAliases.delegate;
+var eventPointermoveMutationLight = pointermoveAliases.mutationLight;
+var eventPointermoveMutationShadow = pointermoveAliases.mutationShadow;
+var eventPointermoveMutationAll = pointermoveAliases.mutationAll;
+var eventPointermoveMutation = pointermoveAliases.mutation;
+var eventPointermoveLight = pointermoveAliases.light;
+var eventPointermoveShadow = pointermoveAliases.shadow;
+var eventPointermoveAll = pointermoveAliases.all;
+var eventPointermoveThis = pointermoveAliases.this;
+var eventPointermoveAppHost = pointermoveAliases.appHost;
+var eventPointermoveWindow = pointermoveAliases.window;
+var eventPointermoveDocument = pointermoveAliases.document;
+var pointeroverAliases = makeTypedEventAliases("pointerover");
+var eventPointerover = pointeroverAliases.base;
+var eventPointeroverDelegateLight = pointeroverAliases.delegateLight;
+var eventPointeroverDelegateShadow = pointeroverAliases.delegateShadow;
+var eventPointeroverDelegateAll = pointeroverAliases.delegateAll;
+var eventPointeroverDelegate = pointeroverAliases.delegate;
+var eventPointeroverMutationLight = pointeroverAliases.mutationLight;
+var eventPointeroverMutationShadow = pointeroverAliases.mutationShadow;
+var eventPointeroverMutationAll = pointeroverAliases.mutationAll;
+var eventPointeroverMutation = pointeroverAliases.mutation;
+var eventPointeroverLight = pointeroverAliases.light;
+var eventPointeroverShadow = pointeroverAliases.shadow;
+var eventPointeroverAll = pointeroverAliases.all;
+var eventPointeroverThis = pointeroverAliases.this;
+var eventPointeroverAppHost = pointeroverAliases.appHost;
+var eventPointeroverWindow = pointeroverAliases.window;
+var eventPointeroverDocument = pointeroverAliases.document;
+var pointeroutAliases = makeTypedEventAliases("pointerout");
+var eventPointerout = pointeroutAliases.base;
+var eventPointeroutDelegateLight = pointeroutAliases.delegateLight;
+var eventPointeroutDelegateShadow = pointeroutAliases.delegateShadow;
+var eventPointeroutDelegateAll = pointeroutAliases.delegateAll;
+var eventPointeroutDelegate = pointeroutAliases.delegate;
+var eventPointeroutMutationLight = pointeroutAliases.mutationLight;
+var eventPointeroutMutationShadow = pointeroutAliases.mutationShadow;
+var eventPointeroutMutationAll = pointeroutAliases.mutationAll;
+var eventPointeroutMutation = pointeroutAliases.mutation;
+var eventPointeroutLight = pointeroutAliases.light;
+var eventPointeroutShadow = pointeroutAliases.shadow;
+var eventPointeroutAll = pointeroutAliases.all;
+var eventPointeroutThis = pointeroutAliases.this;
+var eventPointeroutAppHost = pointeroutAliases.appHost;
+var eventPointeroutWindow = pointeroutAliases.window;
+var eventPointeroutDocument = pointeroutAliases.document;
+var pointerenterAliases = makeTypedEventAliases("pointerenter");
+var eventPointerenter = pointerenterAliases.base;
+var eventPointerenterDelegateLight = pointerenterAliases.delegateLight;
+var eventPointerenterDelegateShadow = pointerenterAliases.delegateShadow;
+var eventPointerenterDelegateAll = pointerenterAliases.delegateAll;
+var eventPointerenterDelegate = pointerenterAliases.delegate;
+var eventPointerenterMutationLight = pointerenterAliases.mutationLight;
+var eventPointerenterMutationShadow = pointerenterAliases.mutationShadow;
+var eventPointerenterMutationAll = pointerenterAliases.mutationAll;
+var eventPointerenterMutation = pointerenterAliases.mutation;
+var eventPointerenterLight = pointerenterAliases.light;
+var eventPointerenterShadow = pointerenterAliases.shadow;
+var eventPointerenterAll = pointerenterAliases.all;
+var eventPointerenterThis = pointerenterAliases.this;
+var eventPointerenterAppHost = pointerenterAliases.appHost;
+var eventPointerenterWindow = pointerenterAliases.window;
+var eventPointerenterDocument = pointerenterAliases.document;
+var pointerleaveAliases = makeTypedEventAliases("pointerleave");
+var eventPointerleave = pointerleaveAliases.base;
+var eventPointerleaveDelegateLight = pointerleaveAliases.delegateLight;
+var eventPointerleaveDelegateShadow = pointerleaveAliases.delegateShadow;
+var eventPointerleaveDelegateAll = pointerleaveAliases.delegateAll;
+var eventPointerleaveDelegate = pointerleaveAliases.delegate;
+var eventPointerleaveMutationLight = pointerleaveAliases.mutationLight;
+var eventPointerleaveMutationShadow = pointerleaveAliases.mutationShadow;
+var eventPointerleaveMutationAll = pointerleaveAliases.mutationAll;
+var eventPointerleaveMutation = pointerleaveAliases.mutation;
+var eventPointerleaveLight = pointerleaveAliases.light;
+var eventPointerleaveShadow = pointerleaveAliases.shadow;
+var eventPointerleaveAll = pointerleaveAliases.all;
+var eventPointerleaveThis = pointerleaveAliases.this;
+var eventPointerleaveAppHost = pointerleaveAliases.appHost;
+var eventPointerleaveWindow = pointerleaveAliases.window;
+var eventPointerleaveDocument = pointerleaveAliases.document;
+var pointercancelAliases = makeTypedEventAliases("pointercancel");
+var eventPointercancel = pointercancelAliases.base;
+var eventPointercancelDelegateLight = pointercancelAliases.delegateLight;
+var eventPointercancelDelegateShadow = pointercancelAliases.delegateShadow;
+var eventPointercancelDelegateAll = pointercancelAliases.delegateAll;
+var eventPointercancelDelegate = pointercancelAliases.delegate;
+var eventPointercancelMutationLight = pointercancelAliases.mutationLight;
+var eventPointercancelMutationShadow = pointercancelAliases.mutationShadow;
+var eventPointercancelMutationAll = pointercancelAliases.mutationAll;
+var eventPointercancelMutation = pointercancelAliases.mutation;
+var eventPointercancelLight = pointercancelAliases.light;
+var eventPointercancelShadow = pointercancelAliases.shadow;
+var eventPointercancelAll = pointercancelAliases.all;
+var eventPointercancelThis = pointercancelAliases.this;
+var eventPointercancelAppHost = pointercancelAliases.appHost;
+var eventPointercancelWindow = pointercancelAliases.window;
+var eventPointercancelDocument = pointercancelAliases.document;
+var copyAliases = makeTypedEventAliases("copy");
+var eventCopy = copyAliases.base;
+var eventCopyDelegateLight = copyAliases.delegateLight;
+var eventCopyDelegateShadow = copyAliases.delegateShadow;
+var eventCopyDelegateAll = copyAliases.delegateAll;
+var eventCopyDelegate = copyAliases.delegate;
+var eventCopyMutationLight = copyAliases.mutationLight;
+var eventCopyMutationShadow = copyAliases.mutationShadow;
+var eventCopyMutationAll = copyAliases.mutationAll;
+var eventCopyMutation = copyAliases.mutation;
+var eventCopyLight = copyAliases.light;
+var eventCopyShadow = copyAliases.shadow;
+var eventCopyAll = copyAliases.all;
+var eventCopyThis = copyAliases.this;
+var eventCopyAppHost = copyAliases.appHost;
+var eventCopyWindow = copyAliases.window;
+var eventCopyDocument = copyAliases.document;
+var cutAliases = makeTypedEventAliases("cut");
+var eventCut = cutAliases.base;
+var eventCutDelegateLight = cutAliases.delegateLight;
+var eventCutDelegateShadow = cutAliases.delegateShadow;
+var eventCutDelegateAll = cutAliases.delegateAll;
+var eventCutDelegate = cutAliases.delegate;
+var eventCutMutationLight = cutAliases.mutationLight;
+var eventCutMutationShadow = cutAliases.mutationShadow;
+var eventCutMutationAll = cutAliases.mutationAll;
+var eventCutMutation = cutAliases.mutation;
+var eventCutLight = cutAliases.light;
+var eventCutShadow = cutAliases.shadow;
+var eventCutAll = cutAliases.all;
+var eventCutThis = cutAliases.this;
+var eventCutAppHost = cutAliases.appHost;
+var eventCutWindow = cutAliases.window;
+var eventCutDocument = cutAliases.document;
+var pasteAliases = makeTypedEventAliases("paste");
+var eventPaste = pasteAliases.base;
+var eventPasteDelegateLight = pasteAliases.delegateLight;
+var eventPasteDelegateShadow = pasteAliases.delegateShadow;
+var eventPasteDelegateAll = pasteAliases.delegateAll;
+var eventPasteDelegate = pasteAliases.delegate;
+var eventPasteMutationLight = pasteAliases.mutationLight;
+var eventPasteMutationShadow = pasteAliases.mutationShadow;
+var eventPasteMutationAll = pasteAliases.mutationAll;
+var eventPasteMutation = pasteAliases.mutation;
+var eventPasteLight = pasteAliases.light;
+var eventPasteShadow = pasteAliases.shadow;
+var eventPasteAll = pasteAliases.all;
+var eventPasteThis = pasteAliases.this;
+var eventPasteAppHost = pasteAliases.appHost;
+var eventPasteWindow = pasteAliases.window;
+var eventPasteDocument = pasteAliases.document;
+var animationstartAliases = makeTypedEventAliases("animationstart");
+var eventAnimationstart = animationstartAliases.base;
+var eventAnimationstartDelegateLight = animationstartAliases.delegateLight;
+var eventAnimationstartDelegateShadow = animationstartAliases.delegateShadow;
+var eventAnimationstartDelegateAll = animationstartAliases.delegateAll;
+var eventAnimationstartDelegate = animationstartAliases.delegate;
+var eventAnimationstartMutationLight = animationstartAliases.mutationLight;
+var eventAnimationstartMutationShadow = animationstartAliases.mutationShadow;
+var eventAnimationstartMutationAll = animationstartAliases.mutationAll;
+var eventAnimationstartMutation = animationstartAliases.mutation;
+var eventAnimationstartLight = animationstartAliases.light;
+var eventAnimationstartShadow = animationstartAliases.shadow;
+var eventAnimationstartAll = animationstartAliases.all;
+var eventAnimationstartThis = animationstartAliases.this;
+var eventAnimationstartAppHost = animationstartAliases.appHost;
+var eventAnimationstartWindow = animationstartAliases.window;
+var eventAnimationstartDocument = animationstartAliases.document;
+var animationendAliases = makeTypedEventAliases("animationend");
+var eventAnimationend = animationendAliases.base;
+var eventAnimationendDelegateLight = animationendAliases.delegateLight;
+var eventAnimationendDelegateShadow = animationendAliases.delegateShadow;
+var eventAnimationendDelegateAll = animationendAliases.delegateAll;
+var eventAnimationendDelegate = animationendAliases.delegate;
+var eventAnimationendMutationLight = animationendAliases.mutationLight;
+var eventAnimationendMutationShadow = animationendAliases.mutationShadow;
+var eventAnimationendMutationAll = animationendAliases.mutationAll;
+var eventAnimationendMutation = animationendAliases.mutation;
+var eventAnimationendLight = animationendAliases.light;
+var eventAnimationendShadow = animationendAliases.shadow;
+var eventAnimationendAll = animationendAliases.all;
+var eventAnimationendThis = animationendAliases.this;
+var eventAnimationendAppHost = animationendAliases.appHost;
+var eventAnimationendWindow = animationendAliases.window;
+var eventAnimationendDocument = animationendAliases.document;
+var animationiterationAliases = makeTypedEventAliases("animationiteration");
+var eventAnimationiteration = animationiterationAliases.base;
+var eventAnimationiterationDelegateLight = animationiterationAliases.delegateLight;
+var eventAnimationiterationDelegateShadow = animationiterationAliases.delegateShadow;
+var eventAnimationiterationDelegateAll = animationiterationAliases.delegateAll;
+var eventAnimationiterationDelegate = animationiterationAliases.delegate;
+var eventAnimationiterationMutationLight = animationiterationAliases.mutationLight;
+var eventAnimationiterationMutationShadow = animationiterationAliases.mutationShadow;
+var eventAnimationiterationMutationAll = animationiterationAliases.mutationAll;
+var eventAnimationiterationMutation = animationiterationAliases.mutation;
+var eventAnimationiterationLight = animationiterationAliases.light;
+var eventAnimationiterationShadow = animationiterationAliases.shadow;
+var eventAnimationiterationAll = animationiterationAliases.all;
+var eventAnimationiterationThis = animationiterationAliases.this;
+var eventAnimationiterationAppHost = animationiterationAliases.appHost;
+var eventAnimationiterationWindow = animationiterationAliases.window;
+var eventAnimationiterationDocument = animationiterationAliases.document;
+var animationcancelAliases = makeTypedEventAliases("animationcancel");
+var eventAnimationcancel = animationcancelAliases.base;
+var eventAnimationcancelDelegateLight = animationcancelAliases.delegateLight;
+var eventAnimationcancelDelegateShadow = animationcancelAliases.delegateShadow;
+var eventAnimationcancelDelegateAll = animationcancelAliases.delegateAll;
+var eventAnimationcancelDelegate = animationcancelAliases.delegate;
+var eventAnimationcancelMutationLight = animationcancelAliases.mutationLight;
+var eventAnimationcancelMutationShadow = animationcancelAliases.mutationShadow;
+var eventAnimationcancelMutationAll = animationcancelAliases.mutationAll;
+var eventAnimationcancelMutation = animationcancelAliases.mutation;
+var eventAnimationcancelLight = animationcancelAliases.light;
+var eventAnimationcancelShadow = animationcancelAliases.shadow;
+var eventAnimationcancelAll = animationcancelAliases.all;
+var eventAnimationcancelThis = animationcancelAliases.this;
+var eventAnimationcancelAppHost = animationcancelAliases.appHost;
+var eventAnimationcancelWindow = animationcancelAliases.window;
+var eventAnimationcancelDocument = animationcancelAliases.document;
+var transitionstartAliases = makeTypedEventAliases("transitionstart");
+var eventTransitionstart = transitionstartAliases.base;
+var eventTransitionstartDelegateLight = transitionstartAliases.delegateLight;
+var eventTransitionstartDelegateShadow = transitionstartAliases.delegateShadow;
+var eventTransitionstartDelegateAll = transitionstartAliases.delegateAll;
+var eventTransitionstartDelegate = transitionstartAliases.delegate;
+var eventTransitionstartMutationLight = transitionstartAliases.mutationLight;
+var eventTransitionstartMutationShadow = transitionstartAliases.mutationShadow;
+var eventTransitionstartMutationAll = transitionstartAliases.mutationAll;
+var eventTransitionstartMutation = transitionstartAliases.mutation;
+var eventTransitionstartLight = transitionstartAliases.light;
+var eventTransitionstartShadow = transitionstartAliases.shadow;
+var eventTransitionstartAll = transitionstartAliases.all;
+var eventTransitionstartThis = transitionstartAliases.this;
+var eventTransitionstartAppHost = transitionstartAliases.appHost;
+var eventTransitionstartWindow = transitionstartAliases.window;
+var eventTransitionstartDocument = transitionstartAliases.document;
+var transitionendAliases = makeTypedEventAliases("transitionend");
+var eventTransitionend = transitionendAliases.base;
+var eventTransitionendDelegateLight = transitionendAliases.delegateLight;
+var eventTransitionendDelegateShadow = transitionendAliases.delegateShadow;
+var eventTransitionendDelegateAll = transitionendAliases.delegateAll;
+var eventTransitionendDelegate = transitionendAliases.delegate;
+var eventTransitionendMutationLight = transitionendAliases.mutationLight;
+var eventTransitionendMutationShadow = transitionendAliases.mutationShadow;
+var eventTransitionendMutationAll = transitionendAliases.mutationAll;
+var eventTransitionendMutation = transitionendAliases.mutation;
+var eventTransitionendLight = transitionendAliases.light;
+var eventTransitionendShadow = transitionendAliases.shadow;
+var eventTransitionendAll = transitionendAliases.all;
+var eventTransitionendThis = transitionendAliases.this;
+var eventTransitionendAppHost = transitionendAliases.appHost;
+var eventTransitionendWindow = transitionendAliases.window;
+var eventTransitionendDocument = transitionendAliases.document;
+var transitioncancelAliases = makeTypedEventAliases("transitioncancel");
+var eventTransitioncancel = transitioncancelAliases.base;
+var eventTransitioncancelDelegateLight = transitioncancelAliases.delegateLight;
+var eventTransitioncancelDelegateShadow = transitioncancelAliases.delegateShadow;
+var eventTransitioncancelDelegateAll = transitioncancelAliases.delegateAll;
+var eventTransitioncancelDelegate = transitioncancelAliases.delegate;
+var eventTransitioncancelMutationLight = transitioncancelAliases.mutationLight;
+var eventTransitioncancelMutationShadow = transitioncancelAliases.mutationShadow;
+var eventTransitioncancelMutationAll = transitioncancelAliases.mutationAll;
+var eventTransitioncancelMutation = transitioncancelAliases.mutation;
+var eventTransitioncancelLight = transitioncancelAliases.light;
+var eventTransitioncancelShadow = transitioncancelAliases.shadow;
+var eventTransitioncancelAll = transitioncancelAliases.all;
+var eventTransitioncancelThis = transitioncancelAliases.this;
+var eventTransitioncancelAppHost = transitioncancelAliases.appHost;
+var eventTransitioncancelWindow = transitioncancelAliases.window;
+var eventTransitioncancelDocument = transitioncancelAliases.document;
+var transitionrunAliases = makeTypedEventAliases("transitionrun");
+var eventTransitionrun = transitionrunAliases.base;
+var eventTransitionrunDelegateLight = transitionrunAliases.delegateLight;
+var eventTransitionrunDelegateShadow = transitionrunAliases.delegateShadow;
+var eventTransitionrunDelegateAll = transitionrunAliases.delegateAll;
+var eventTransitionrunDelegate = transitionrunAliases.delegate;
+var eventTransitionrunMutationLight = transitionrunAliases.mutationLight;
+var eventTransitionrunMutationShadow = transitionrunAliases.mutationShadow;
+var eventTransitionrunMutationAll = transitionrunAliases.mutationAll;
+var eventTransitionrunMutation = transitionrunAliases.mutation;
+var eventTransitionrunLight = transitionrunAliases.light;
+var eventTransitionrunShadow = transitionrunAliases.shadow;
+var eventTransitionrunAll = transitionrunAliases.all;
+var eventTransitionrunThis = transitionrunAliases.this;
+var eventTransitionrunAppHost = transitionrunAliases.appHost;
+var eventTransitionrunWindow = transitionrunAliases.window;
+var eventTransitionrunDocument = transitionrunAliases.document;
+var scrollAliases = makeTypedEventAliases("scroll");
+var eventScroll = scrollAliases.base;
+var eventScrollDelegateLight = scrollAliases.delegateLight;
+var eventScrollDelegateShadow = scrollAliases.delegateShadow;
+var eventScrollDelegateAll = scrollAliases.delegateAll;
+var eventScrollDelegate = scrollAliases.delegate;
+var eventScrollMutationLight = scrollAliases.mutationLight;
+var eventScrollMutationShadow = scrollAliases.mutationShadow;
+var eventScrollMutationAll = scrollAliases.mutationAll;
+var eventScrollMutation = scrollAliases.mutation;
+var eventScrollLight = scrollAliases.light;
+var eventScrollShadow = scrollAliases.shadow;
+var eventScrollAll = scrollAliases.all;
+var eventScrollThis = scrollAliases.this;
+var eventScrollAppHost = scrollAliases.appHost;
+var eventScrollWindow = scrollAliases.window;
+var eventScrollDocument = scrollAliases.document;
+var resizeAliases = makeTypedEventAliases("resize");
+var eventResize = resizeAliases.base;
+var eventResizeDelegateLight = resizeAliases.delegateLight;
+var eventResizeDelegateShadow = resizeAliases.delegateShadow;
+var eventResizeDelegateAll = resizeAliases.delegateAll;
+var eventResizeDelegate = resizeAliases.delegate;
+var eventResizeMutationLight = resizeAliases.mutationLight;
+var eventResizeMutationShadow = resizeAliases.mutationShadow;
+var eventResizeMutationAll = resizeAliases.mutationAll;
+var eventResizeMutation = resizeAliases.mutation;
+var eventResizeLight = resizeAliases.light;
+var eventResizeShadow = resizeAliases.shadow;
+var eventResizeAll = resizeAliases.all;
+var eventResizeThis = resizeAliases.this;
+var eventResizeAppHost = resizeAliases.appHost;
+var eventResizeWindow = resizeAliases.window;
+var eventResizeDocument = resizeAliases.document;
+var loadAliases = makeTypedEventAliases("load");
+var eventLoad = loadAliases.base;
+var eventLoadDelegateLight = loadAliases.delegateLight;
+var eventLoadDelegateShadow = loadAliases.delegateShadow;
+var eventLoadDelegateAll = loadAliases.delegateAll;
+var eventLoadDelegate = loadAliases.delegate;
+var eventLoadMutationLight = loadAliases.mutationLight;
+var eventLoadMutationShadow = loadAliases.mutationShadow;
+var eventLoadMutationAll = loadAliases.mutationAll;
+var eventLoadMutation = loadAliases.mutation;
+var eventLoadLight = loadAliases.light;
+var eventLoadShadow = loadAliases.shadow;
+var eventLoadAll = loadAliases.all;
+var eventLoadThis = loadAliases.this;
+var eventLoadAppHost = loadAliases.appHost;
+var eventLoadWindow = loadAliases.window;
+var eventLoadDocument = loadAliases.document;
+var errorAliases = makeTypedEventAliases("error");
+var eventError = errorAliases.base;
+var eventErrorDelegateLight = errorAliases.delegateLight;
+var eventErrorDelegateShadow = errorAliases.delegateShadow;
+var eventErrorDelegateAll = errorAliases.delegateAll;
+var eventErrorDelegate = errorAliases.delegate;
+var eventErrorMutationLight = errorAliases.mutationLight;
+var eventErrorMutationShadow = errorAliases.mutationShadow;
+var eventErrorMutationAll = errorAliases.mutationAll;
+var eventErrorMutation = errorAliases.mutation;
+var eventErrorLight = errorAliases.light;
+var eventErrorShadow = errorAliases.shadow;
+var eventErrorAll = errorAliases.all;
+var eventErrorThis = errorAliases.this;
+var eventErrorAppHost = errorAliases.appHost;
+var eventErrorWindow = errorAliases.window;
+var eventErrorDocument = errorAliases.document;
+var toggleAliases = makeTypedEventAliases("toggle");
+var eventToggle = toggleAliases.base;
+var eventToggleDelegateLight = toggleAliases.delegateLight;
+var eventToggleDelegateShadow = toggleAliases.delegateShadow;
+var eventToggleDelegateAll = toggleAliases.delegateAll;
+var eventToggleDelegate = toggleAliases.delegate;
+var eventToggleMutationLight = toggleAliases.mutationLight;
+var eventToggleMutationShadow = toggleAliases.mutationShadow;
+var eventToggleMutationAll = toggleAliases.mutationAll;
+var eventToggleMutation = toggleAliases.mutation;
+var eventToggleLight = toggleAliases.light;
+var eventToggleShadow = toggleAliases.shadow;
+var eventToggleAll = toggleAliases.all;
+var eventToggleThis = toggleAliases.this;
+var eventToggleAppHost = toggleAliases.appHost;
+var eventToggleWindow = toggleAliases.window;
+var eventToggleDocument = toggleAliases.document;
 var getAddEventListenerMetadata = (target) => {
   const constructor = target instanceof Function ? target : target.constructor;
   return ReflectUtils.getMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor);
@@ -13767,9 +14769,9 @@ var EventListenerLifeCycler = class {
    * target 에 meta 이벤트를 직접 바인딩한다.
    * delegate:'mutation' 초기/동적 바인딩에서 호출된다.
    */
-  bindDirect(helperHostSet, target, meta) {
-    const inst = helperHostSet.$this;
-    const currentWin = helperHostSet.$w;
+  bindDirect(helperHostSet2, target, meta) {
+    const inst = helperHostSet2.$this;
+    const currentWin = helperHostSet2.$w;
     const { type, options } = meta;
     const opts = { capture: options.capture, once: options.once, passive: options.passive };
     const handler = async (event2) => {
@@ -13781,7 +14783,17 @@ var EventListenerLifeCycler = class {
       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 args = buildSwcParameterArgs(inst, meta.propertyKey, {
+        event: event2,
+        matched: event2.currentTarget,
+        hostSet: currentHostSet,
+        helperHostSet: currentHelperHostSet,
+        helperSet: currentHelperSet
+      }, legacyArgs);
+      await inst[meta.propertyKey](...args);
     };
     const eventSubject = new Subject();
     let eventStream = eventSubject;
@@ -13802,8 +14814,8 @@ var EventListenerLifeCycler = class {
     this.getBoundListeners(inst).push({ target, type, handler: wrappedHandler, options: opts, subscription, onRemoves, meta });
   }
   /** target + meta 조합 리스너를 제거한다. MutationObserver 추적 요소 제거 시 호출. */
-  unbindDirect(helperHostSet, target, meta) {
-    const inst = helperHostSet.$this;
+  unbindDirect(helperHostSet2, target, meta) {
+    const inst = helperHostSet2.$this;
     const list = this.getBoundListeners(inst);
     for (let i = list.length - 1; i >= 0; i--) {
       const l = list[i];
@@ -13859,9 +14871,9 @@ var EventListenerLifeCycler = class {
     return { delegateListeners, mutationDelegateListeners, nonDelegateListeners };
   }
   // ── ElementDefineLifeCycler 구현 ──
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const currentWin = helperHostSet.$w;
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    const currentWin = helperHostSet2.$w;
     this.boundListenersMap.delete(inst);
     this.eventBoundSetsMap.delete(inst);
     const allMeta = getAddEventListenerMetadata(inst) ?? [];
@@ -13888,9 +14900,8 @@ var EventListenerLifeCycler = class {
       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)) {
               if (m.options.filter) {
                 const helper = SwcUtils.getHelperAndHostSet(currentWin, matchedEl);
@@ -13900,15 +14911,22 @@ var EventListenerLifeCycler = class {
               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 args = buildSwcParameterArgs(inst, m.propertyKey, {
+                event: event2,
+                matched: matchedEl,
+                hostSet: hs,
+                helperHostSet: helperHostSetForMatch,
+                helperSet: helperSetForMatch
+              }, legacyArgs);
+              await inst[m.propertyKey](...args);
               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 });
       }
@@ -13919,7 +14937,7 @@ var EventListenerLifeCycler = class {
       const bindTargets = [];
       let resolvedSel = null;
       if (typeof selector === "function") {
-        const result = selector(inst, helperHostSet);
+        const result = selector(inst, helperHostSet2);
         if (typeof result === "string") resolvedSel = result;
         else if (result instanceof currentWin.Element) bindTargets.push(result);
         else if (result instanceof currentWin.NodeList) bindTargets.push(...Array.from(result));
@@ -13938,15 +14956,15 @@ var EventListenerLifeCycler = class {
       if (resolvedSel) {
         if (resolvedSel === "$window") bindTargets.push(currentWin);
         else if (resolvedSel === "$document") bindTargets.push(currentWin.document);
-        else if (resolvedSel === "$host") applyRoot(helperHostSet.$host);
-        else if (resolvedSel === "$parentHost") applyRoot(helperHostSet.$parentHost);
-        else if (resolvedSel === "$appHost") applyRoot(helperHostSet.$appHost);
-        else if (resolvedSel === "$firstHost") applyRoot(helperHostSet.$firstHost);
-        else if (resolvedSel === "$lastHost") applyRoot(helperHostSet.$lastHost);
-        else if (resolvedSel === "$firstAppHost") applyRoot(helperHostSet.$firstAppHost);
-        else if (resolvedSel === "$lastAppHost") applyRoot(helperHostSet.$lastAppHost);
-        else if (resolvedSel === "$hosts") helperHostSet.$hosts.forEach(applyRoot);
-        else if (resolvedSel === "$appHosts") helperHostSet.$appHosts.forEach(applyRoot);
+        else if (resolvedSel === "$host") applyRoot(helperHostSet2.$host);
+        else if (resolvedSel === "$parentHost") applyRoot(helperHostSet2.$parentHost);
+        else if (resolvedSel === "$appHost") applyRoot(helperHostSet2.$appHost);
+        else if (resolvedSel === "$firstHost") applyRoot(helperHostSet2.$firstHost);
+        else if (resolvedSel === "$lastHost") applyRoot(helperHostSet2.$lastHost);
+        else if (resolvedSel === "$firstAppHost") applyRoot(helperHostSet2.$firstAppHost);
+        else if (resolvedSel === "$lastAppHost") applyRoot(helperHostSet2.$lastAppHost);
+        else if (resolvedSel === "$hosts") helperHostSet2.$hosts.forEach(applyRoot);
+        else if (resolvedSel === "$appHosts") helperHostSet2.$appHosts.forEach(applyRoot);
         else if (resolvedSel === "$this" || !resolvedSel) applyRoot(inst);
         else {
           const searchRoots = [];
@@ -13960,7 +14978,7 @@ var EventListenerLifeCycler = class {
           for (const sr of searchRoots) sr.querySelectorAll(resolvedSel).forEach((el) => bindTargets.push(el));
         }
       }
-      for (const t of bindTargets) this.bindDirect(helperHostSet, t, meta);
+      for (const t of bindTargets) this.bindDirect(helperHostSet2, t, meta);
     }
     if (mutationDelegateListeners.length > 0) {
       const shadowEventDelegates = mutationDelegateListeners.filter((m) => {
@@ -13989,13 +15007,13 @@ var EventListenerLifeCycler = class {
             };
             const bindEl = (el) => {
               if (!boundSet.has(el)) {
-                this.bindDirect(helperHostSet, el, m);
+                this.bindDirect(helperHostSet2, el, m);
                 boundSet.add(el);
               }
             };
             const unbindEl = (el) => {
               if (boundSet.has(el)) {
-                this.unbindDirect(helperHostSet, el, m);
+                this.unbindDirect(helperHostSet2, el, m);
                 boundSet.delete(el);
               }
             };
@@ -14022,12 +15040,12 @@ var EventListenerLifeCycler = class {
           }
           if (typeof m.selector !== "string") continue;
           if (m.selector === "$this" || m.selector === "") {
-            this.bindDirect(helperHostSet, root, m);
+            this.bindDirect(helperHostSet2, root, m);
             boundSet.add(root);
           } else {
             root.querySelectorAll(m.selector).forEach((el) => {
               if (!boundSet.has(el)) {
-                this.bindDirect(helperHostSet, el, m);
+                this.bindDirect(helperHostSet2, el, m);
                 boundSet.add(el);
               }
             });
@@ -14042,8 +15060,8 @@ var EventListenerLifeCycler = class {
     }
     return void 0;
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
     const list = this.boundListenersMap.get(inst) ?? [];
     for (const l of list) {
       try {
@@ -14067,70 +15085,61 @@ var EventListenerLifeCycler = class {
 
 // src/decorators/mutationObserver.ts
 var MUTATION_OBSERVER_METADATA_KEY = Symbol.for("simple-web-component:mutation-observer");
-function mutationObserver(selectorOrOptions, maybeOptions) {
-  return (targetObj, propertyKey, descriptor) => {
-    let selector = "$this";
-    let options = {};
-    if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-      selector = selectorOrOptions;
-      options = maybeOptions ?? {};
-    } else {
-      selector = "$this";
-      options = selectorOrOptions ?? {};
-    }
-    const constructor = targetObj.constructor;
-    let observers = ReflectUtils.getMetadata(MUTATION_OBSERVER_METADATA_KEY, constructor);
-    if (!observers) {
-      observers = [];
-      ReflectUtils.defineMetadata(MUTATION_OBSERVER_METADATA_KEY, observers, constructor);
-    }
-    observers.push({ propertyKey, selector, options });
+var applyMutationObserver = (selector, options, targetObj, propertyKey) => {
+  const constructor = targetObj.constructor;
+  let observers = ReflectUtils.getMetadata(MUTATION_OBSERVER_METADATA_KEY, constructor);
+  if (!observers) {
+    observers = [];
+    ReflectUtils.defineMetadata(MUTATION_OBSERVER_METADATA_KEY, observers, constructor);
+  }
+  observers.push({ propertyKey, selector, options });
+};
+var resolveMutationObserverArgs = (selectorOrOptions, maybeOptions, extra) => {
+  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
+    return { selector: selectorOrOptions, options: { ...maybeOptions ?? {}, ...extra } };
+  }
+  return { selector: "$this", options: { ...selectorOrOptions ?? {}, ...extra } };
+};
+var dispatchMutationObserver = (selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, extra) => {
+  if ((typeof maybeOptionsOrPropertyKey === "string" || typeof maybeOptionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    applyMutationObserver("$this", { ...extra }, selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey);
+    return;
+  }
+  const { selector, options } = resolveMutationObserverArgs(
+    selectorOrOptionsOrTarget,
+    maybeOptionsOrPropertyKey,
+    extra
+  );
+  return (targetObj, propertyKey) => {
+    applyMutationObserver(selector, options, targetObj, propertyKey);
   };
+};
+function mutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, {});
 }
-function mutationObserverThis(options) {
-  return mutationObserver("$this", options);
+function mutationObserverThis(optionsOrTarget, propertyKey, descriptor) {
+  return dispatchMutationObserver(optionsOrTarget, propertyKey, descriptor, {});
 }
-function mutationObserverDelegateLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light", delegate: true });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "light", delegate: true });
+function mutationObserverDelegateLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light", delegate: true });
 }
-function mutationObserverDelegateShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow", delegate: true });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "shadow", delegate: true });
+function mutationObserverDelegateShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow", delegate: true });
 }
-function mutationObserverDelegateAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all", delegate: true });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "all", delegate: true });
+function mutationObserverDelegateAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all", delegate: true });
 }
-function mutationObserverDelegate(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "auto", delegate: true });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "auto", delegate: true });
+function mutationObserverDelegate(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "auto", delegate: true });
 }
-function mutationObserverLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light" });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "light" });
+function mutationObserverLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light" });
 }
-function mutationObserverShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow" });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "shadow" });
+function mutationObserverShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow" });
 }
-function mutationObserverAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return mutationObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all" });
-  }
-  return mutationObserver({ ...selectorOrOptions ?? {}, root: "all" });
+function mutationObserverAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchMutationObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all" });
 }
 function getMutationObserverMetadata(target) {
   const constructor = target instanceof Function ? target : target.constructor;
@@ -14140,9 +15149,9 @@ var MutationObserverLifeCycler = class {
   constructor() {
     __publicField(this, "removeObserverCallbacksMap", /* @__PURE__ */ new WeakMap());
   }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const currentWin = helperHostSet.$w;
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    const currentWin = helperHostSet2.$w;
     const removeObserverCallbacks = [];
     this.removeObserverCallbacksMap.set(inst, removeObserverCallbacks);
     const allMeta = getMutationObserverMetadata(inst) ?? [];
@@ -14213,10 +15222,10 @@ var MutationObserverLifeCycler = class {
           }
           if (matchedEls.length === 0) continue;
           if (options.filter) {
-            if (!options.filter(matchedEls, { currentThis: inst, helper: helperHostSet })) continue;
+            if (!options.filter(matchedEls, { currentThis: inst, helper: helperHostSet2 })) continue;
           }
-          const hostSet = SwcUtils.getHostSet(inst);
-          inst[meta.propertyKey](matchedEls, mutations, obs, { ...hostSet, $root: root });
+          const hostSet2 = SwcUtils.getHostSet(inst);
+          inst[meta.propertyKey](matchedEls, mutations, obs, { ...hostSet2, $root: root });
         }
       };
       const observeTargets = [];
@@ -14233,7 +15242,7 @@ var MutationObserverLifeCycler = class {
             root.querySelectorAll(selector).forEach((el) => observeTargets.push({ target: el, options: mInit }));
           }
         } else if (typeof selector === "function") {
-          const res = selector(inst, helperHostSet);
+          const res = selector(inst, helperHostSet2);
           let targets = [];
           if (res instanceof currentWin.HTMLElement) targets = [res];
           else if (res instanceof currentWin.NodeList) targets = Array.from(res).filter((e) => e instanceof currentWin.HTMLElement);
@@ -14260,8 +15269,8 @@ var MutationObserverLifeCycler = class {
     if (mutationObserverSet.length === 0) return;
     return { mutationObserverSet };
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
     for (const cb of this.removeObserverCallbacksMap.get(inst) ?? []) {
       try {
         cb.fn(cb.target, cb.opts);
@@ -14275,70 +15284,61 @@ var MutationObserverLifeCycler = class {
 
 // src/decorators/resizeObserver.ts
 var RESIZE_OBSERVER_METADATA_KEY = Symbol.for("simple-web-component:resize-observer");
-function resizeObserver(selectorOrOptions, maybeOptions) {
-  return (targetObj, propertyKey, descriptor) => {
-    let selector = "$this";
-    let options = {};
-    if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-      selector = selectorOrOptions;
-      options = maybeOptions ?? {};
-    } else {
-      selector = "$this";
-      options = selectorOrOptions ?? {};
-    }
-    const constructor = targetObj.constructor;
-    let observers = ReflectUtils.getMetadata(RESIZE_OBSERVER_METADATA_KEY, constructor);
-    if (!observers) {
-      observers = [];
-      ReflectUtils.defineMetadata(RESIZE_OBSERVER_METADATA_KEY, observers, constructor);
-    }
-    observers.push({ propertyKey, selector, options });
+var applyResizeObserver = (selector, options, targetObj, propertyKey) => {
+  const constructor = targetObj.constructor;
+  let observers = ReflectUtils.getMetadata(RESIZE_OBSERVER_METADATA_KEY, constructor);
+  if (!observers) {
+    observers = [];
+    ReflectUtils.defineMetadata(RESIZE_OBSERVER_METADATA_KEY, observers, constructor);
+  }
+  observers.push({ propertyKey, selector, options });
+};
+var resolveResizeObserverArgs = (selectorOrOptions, maybeOptions, extra) => {
+  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
+    return { selector: selectorOrOptions, options: { ...maybeOptions ?? {}, ...extra } };
+  }
+  return { selector: "$this", options: { ...selectorOrOptions ?? {}, ...extra } };
+};
+var dispatchResizeObserver = (selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, extra) => {
+  if ((typeof maybeOptionsOrPropertyKey === "string" || typeof maybeOptionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    applyResizeObserver("$this", { ...extra }, selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey);
+    return;
+  }
+  const { selector, options } = resolveResizeObserverArgs(
+    selectorOrOptionsOrTarget,
+    maybeOptionsOrPropertyKey,
+    extra
+  );
+  return (targetObj, propertyKey) => {
+    applyResizeObserver(selector, options, targetObj, propertyKey);
   };
+};
+function resizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, {});
 }
-function resizeObserverThis(options) {
-  return resizeObserver("$this", options);
+function resizeObserverThis(optionsOrTarget, propertyKey, descriptor) {
+  return dispatchResizeObserver(optionsOrTarget, propertyKey, descriptor, {});
 }
-function resizeObserverDelegateLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light", delegate: true });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "light", delegate: true });
+function resizeObserverDelegateLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light", delegate: true });
 }
-function resizeObserverDelegateShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow", delegate: true });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "shadow", delegate: true });
+function resizeObserverDelegateShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow", delegate: true });
 }
-function resizeObserverDelegateAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all", delegate: true });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "all", delegate: true });
+function resizeObserverDelegateAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all", delegate: true });
 }
-function resizeObserverDelegate(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "auto", delegate: true });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "auto", delegate: true });
+function resizeObserverDelegate(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "auto", delegate: true });
 }
-function resizeObserverLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light" });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "light" });
+function resizeObserverLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light" });
 }
-function resizeObserverShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow" });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "shadow" });
+function resizeObserverShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow" });
 }
-function resizeObserverAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return resizeObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all" });
-  }
-  return resizeObserver({ ...selectorOrOptions ?? {}, root: "all" });
+function resizeObserverAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchResizeObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all" });
 }
 function getResizeObserverMetadata(target) {
   const constructor = target instanceof Function ? target : target.constructor;
@@ -14348,9 +15348,9 @@ var ResizeObserverLifeCycler = class {
   constructor() {
     __publicField(this, "removeObserverCallbacksMap", /* @__PURE__ */ new WeakMap());
   }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const currentWin = helperHostSet.$w;
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    const currentWin = helperHostSet2.$w;
     const removeObserverCallbacks = [];
     this.removeObserverCallbacksMap.set(inst, removeObserverCallbacks);
     const allMeta = getResizeObserverMetadata(inst) ?? [];
@@ -14374,10 +15374,10 @@ var ResizeObserverLifeCycler = class {
         }
         if (matchedEls.length === 0) continue;
         if (m.options.filter) {
-          if (!m.options.filter(matchedEls, { currentThis: inst, helper: helperHostSet })) continue;
+          if (!m.options.filter(matchedEls, { currentThis: inst, helper: helperHostSet2 })) continue;
         }
-        const hostSet = SwcUtils.getHostSet(inst);
-        inst[m.propertyKey](matchedEls, entries, obs, { ...hostSet, $root: root });
+        const hostSet2 = SwcUtils.getHostSet(inst);
+        inst[m.propertyKey](matchedEls, entries, obs, { ...hostSet2, $root: root });
       }
     };
     const resizeObserverSet = [];
@@ -14388,7 +15388,7 @@ var ResizeObserverLifeCycler = class {
       }
       let targets = [];
       if (typeof m.selector === "function") {
-        const res = m.selector(inst, helperHostSet);
+        const res = m.selector(inst, helperHostSet2);
         if (res instanceof currentWin.HTMLElement) targets = [res];
         else if (res instanceof currentWin.NodeList) targets = Array.from(res).filter((e) => e instanceof currentWin.HTMLElement);
         else if (Array.isArray(res)) targets = res.filter((e) => e instanceof currentWin.HTMLElement);
@@ -14415,8 +15415,8 @@ var ResizeObserverLifeCycler = class {
     }
     return { resizeObserverSet };
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
     for (const cb of this.removeObserverCallbacksMap.get(inst) ?? []) {
       try {
         cb.fn(cb.target, cb.opts);
@@ -14430,70 +15430,61 @@ var ResizeObserverLifeCycler = class {
 
 // src/decorators/intersectionObserver.ts
 var INTERSECTION_OBSERVER_METADATA_KEY = Symbol.for("simple-web-component:intersection-observer");
-function intersectionObserver(selectorOrOptions, maybeOptions) {
-  return (targetObj, propertyKey, descriptor) => {
-    let selector = "$this";
-    let options = {};
-    if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-      selector = selectorOrOptions;
-      options = maybeOptions ?? {};
-    } else {
-      selector = "$this";
-      options = selectorOrOptions ?? {};
-    }
-    const constructor = targetObj.constructor;
-    let observers = ReflectUtils.getMetadata(INTERSECTION_OBSERVER_METADATA_KEY, constructor);
-    if (!observers) {
-      observers = [];
-      ReflectUtils.defineMetadata(INTERSECTION_OBSERVER_METADATA_KEY, observers, constructor);
-    }
-    observers.push({ propertyKey, selector, options });
+var applyIntersectionObserver = (selector, options, targetObj, propertyKey) => {
+  const constructor = targetObj.constructor;
+  let observers = ReflectUtils.getMetadata(INTERSECTION_OBSERVER_METADATA_KEY, constructor);
+  if (!observers) {
+    observers = [];
+    ReflectUtils.defineMetadata(INTERSECTION_OBSERVER_METADATA_KEY, observers, constructor);
+  }
+  observers.push({ propertyKey, selector, options });
+};
+var resolveIntersectionObserverArgs = (selectorOrOptions, maybeOptions, extra) => {
+  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
+    return { selector: selectorOrOptions, options: { ...maybeOptions ?? {}, ...extra } };
+  }
+  return { selector: "$this", options: { ...selectorOrOptions ?? {}, ...extra } };
+};
+var dispatchIntersectionObserver = (selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, extra) => {
+  if ((typeof maybeOptionsOrPropertyKey === "string" || typeof maybeOptionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    applyIntersectionObserver("$this", { ...extra }, selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey);
+    return;
+  }
+  const { selector, options } = resolveIntersectionObserverArgs(
+    selectorOrOptionsOrTarget,
+    maybeOptionsOrPropertyKey,
+    extra
+  );
+  return (targetObj, propertyKey) => {
+    applyIntersectionObserver(selector, options, targetObj, propertyKey);
   };
+};
+function intersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, {});
 }
-function intersectionObserverThis(options) {
-  return intersectionObserver("$this", options);
+function intersectionObserverThis(optionsOrTarget, propertyKey, descriptor) {
+  return dispatchIntersectionObserver(optionsOrTarget, propertyKey, descriptor, {});
 }
-function intersectionObserverDelegateLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light", delegate: true });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "light", delegate: true });
+function intersectionObserverDelegateLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light", delegate: true });
 }
-function intersectionObserverDelegateShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow", delegate: true });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "shadow", delegate: true });
+function intersectionObserverDelegateShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow", delegate: true });
 }
-function intersectionObserverDelegateAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all", delegate: true });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "all", delegate: true });
+function intersectionObserverDelegateAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all", delegate: true });
 }
-function intersectionObserverDelegate(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "auto", delegate: true });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "auto", delegate: true });
+function intersectionObserverDelegate(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "auto", delegate: true });
 }
-function intersectionObserverLight(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "light" });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "light" });
+function intersectionObserverLight(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "light" });
 }
-function intersectionObserverShadow(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "shadow" });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "shadow" });
+function intersectionObserverShadow(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "shadow" });
 }
-function intersectionObserverAll(selectorOrOptions, maybeOptions) {
-  if (typeof selectorOrOptions === "string" || typeof selectorOrOptions === "function") {
-    return intersectionObserver(selectorOrOptions, { ...maybeOptions ?? {}, root: "all" });
-  }
-  return intersectionObserver({ ...selectorOrOptions ?? {}, root: "all" });
+function intersectionObserverAll(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor) {
+  return dispatchIntersectionObserver(selectorOrOptionsOrTarget, maybeOptionsOrPropertyKey, descriptor, { root: "all" });
 }
 function getIntersectionObserverMetadata(target) {
   const constructor = target instanceof Function ? target : target.constructor;
@@ -14503,9 +15494,9 @@ var IntersectionObserverLifeCycler = class {
   constructor() {
     __publicField(this, "removeObserverCallbacksMap", /* @__PURE__ */ new WeakMap());
   }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const currentWin = helperHostSet.$w;
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    const currentWin = helperHostSet2.$w;
     const removeObserverCallbacks = [];
     this.removeObserverCallbacksMap.set(inst, removeObserverCallbacks);
     const allMeta = getIntersectionObserverMetadata(inst) ?? [];
@@ -14530,10 +15521,10 @@ var IntersectionObserverLifeCycler = class {
           }
           if (matchedEls.length === 0) continue;
           if (m.options.filter) {
-            if (!m.options.filter(matchedEls, { currentThis: inst, helper: helperHostSet })) continue;
+            if (!m.options.filter(matchedEls, { currentThis: inst, helper: helperHostSet2 })) continue;
           }
-          const hostSet = SwcUtils.getHostSet(inst);
-          inst[m.propertyKey](matchedEls, entries, obs, { ...hostSet, $root: root });
+          const hostSet2 = SwcUtils.getHostSet(inst);
+          inst[m.propertyKey](matchedEls, entries, obs, { ...hostSet2, $root: root });
         }
       };
     };
@@ -14559,7 +15550,7 @@ var IntersectionObserverLifeCycler = class {
         }
         let targets = [];
         if (typeof m.selector === "function") {
-          const res = m.selector(inst, helperHostSet);
+          const res = m.selector(inst, helperHostSet2);
           if (res instanceof currentWin.HTMLElement) targets = [res];
           else if (res instanceof currentWin.NodeList) targets = Array.from(res).filter((e) => e instanceof currentWin.HTMLElement);
           else if (Array.isArray(res)) targets = res.filter((e) => e instanceof currentWin.HTMLElement);
@@ -14588,8 +15579,8 @@ var IntersectionObserverLifeCycler = class {
     }
     return { intersectionObserverSet };
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
     for (const cb of this.removeObserverCallbacksMap.get(inst) ?? []) {
       try {
         cb.fn(cb.target, cb.opts);
@@ -14793,11 +15784,11 @@ function createEmitDecorator(selector, type, options) {
         });
         const conf = getElementConfig(this);
         const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
-        const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+        const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, this);
         const eventTargets = [];
         let resolvedSelector = selector;
         if (typeof selector === "function") {
-          resolvedSelector = selector(this, hostSet);
+          resolvedSelector = selector(this, hostSet2);
         }
         if (resolvedSelector instanceof currentWin.Element) {
           eventTargets.push(resolvedSelector);
@@ -14813,30 +15804,30 @@ function createEmitDecorator(selector, type, options) {
           else if (stringSelector === "$document")
             eventTargets.push(currentWin.document);
           else if (stringSelector === "$host") {
-            if (hostSet.$host)
-              eventTargets.push(hostSet.$host);
+            if (hostSet2.$host)
+              eventTargets.push(hostSet2.$host);
           } else if (stringSelector === "$parentHost") {
-            if (hostSet.$parentHost)
-              eventTargets.push(hostSet.$parentHost);
+            if (hostSet2.$parentHost)
+              eventTargets.push(hostSet2.$parentHost);
           } else if (stringSelector === "$appHost") {
-            if (hostSet.$appHost)
-              eventTargets.push(hostSet.$appHost);
+            if (hostSet2.$appHost)
+              eventTargets.push(hostSet2.$appHost);
           } else if (stringSelector === "$firstHost") {
-            if (hostSet.$firstHost)
-              eventTargets.push(hostSet.$firstHost);
+            if (hostSet2.$firstHost)
+              eventTargets.push(hostSet2.$firstHost);
           } else if (stringSelector === "$lastHost") {
-            if (hostSet.$lastHost)
-              eventTargets.push(hostSet.$lastHost);
+            if (hostSet2.$lastHost)
+              eventTargets.push(hostSet2.$lastHost);
           } else if (stringSelector === "$firstAppHost") {
-            if (hostSet.$firstAppHost)
-              eventTargets.push(hostSet.$firstAppHost);
+            if (hostSet2.$firstAppHost)
+              eventTargets.push(hostSet2.$firstAppHost);
           } else if (stringSelector === "$lastAppHost") {
-            if (hostSet.$lastAppHost)
-              eventTargets.push(hostSet.$lastAppHost);
+            if (hostSet2.$lastAppHost)
+              eventTargets.push(hostSet2.$lastAppHost);
           } else if (stringSelector === "$hosts") {
-            hostSet.$hosts.forEach((h) => eventTargets.push(h));
+            hostSet2.$hosts.forEach((h) => eventTargets.push(h));
           } else if (stringSelector === "$appHosts") {
-            hostSet.$appHosts.forEach((h) => eventTargets.push(h));
+            hostSet2.$appHosts.forEach((h) => eventTargets.push(h));
           } else if (stringSelector === "$this" || !stringSelector) {
             eventTargets.push(this);
           } else {
@@ -14859,7 +15850,7 @@ function createEmitDecorator(selector, type, options) {
           }
         }
         eventTargets.forEach((t) => {
-          if (fullOptions.filter && !fullOptions.filter(t, detail, { currentThis: this, helper: hostSet })) {
+          if (fullOptions.filter && !fullOptions.filter(t, detail, { currentThis: this, helper: hostSet2 })) {
             return;
           }
           t.dispatchEvent(event2);
@@ -14918,8 +15909,8 @@ var EmitCustomEventLifeCycler = class {
   onConnected(_helperHostSet) {
   }
   /** attributeChangedCallback 에서 elementDefine 이 직접 호출 */
-  onAttributeChanged(helperHostSet, name, _old, newVal) {
-    const inst = helperHostSet.$this;
+  onAttributeChanged(helperHostSet2, name, _old, newVal) {
+    const inst = helperHostSet2.$this;
     const matched = this.getHostEmitMeta(inst).find((m) => m.options.attributeName === name);
     if (matched && newVal !== null) {
       inst._bindAttributeEvent?.(inst, name, newVal, matched.type);
@@ -14935,20 +15926,29 @@ var convertValue = (val, type) => {
   if (type === Boolean) return val === "false" || val === "0" ? false : true;
   return val;
 };
-function changedAttribute(attributeName, options = {}) {
+var applyChangedAttribute = (attributeName, options, target, propertyKey) => {
+  const constructor = target.constructor;
+  let metaList = ReflectUtils.getOwnMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, constructor);
+  if (!metaList) {
+    metaList = [];
+    ReflectUtils.defineMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, metaList, constructor);
+  }
+  const name = attributeName || String(propertyKey);
+  metaList.push({
+    attributeName: name,
+    propertyKey,
+    options
+  });
+};
+function changedAttribute(attributeNameOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    applyChangedAttribute(void 0, {}, attributeNameOrTarget, optionsOrPropertyKey);
+    return;
+  }
+  const attributeName = attributeNameOrTarget;
+  const options = optionsOrPropertyKey ?? {};
   return (target, propertyKey) => {
-    const constructor = target.constructor;
-    let metaList = ReflectUtils.getOwnMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, constructor);
-    if (!metaList) {
-      metaList = [];
-      ReflectUtils.defineMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, metaList, constructor);
-    }
-    const name = attributeName || String(propertyKey);
-    metaList.push({
-      attributeName: name,
-      propertyKey,
-      options
-    });
+    applyChangedAttribute(attributeName, options, target, propertyKey);
   };
 }
 var getChangedAttributeMetadata = (target) => {
@@ -14985,25 +15985,25 @@ var ChangedAttributeLifeCycler = class {
   getObservedAttributeNames(inst) {
     return Array.from(this.getAttrChangeMap(inst).keys());
   }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
     for (const [name, metaList] of this.getAttrChangeMap(inst)) {
       for (const meta of metaList) {
         if (meta.options.while === "connected") {
           const val = getAttributeValue(inst, name, { type: meta.options.type });
-          if (val !== null) inst[meta.propertyKey](val, null, name, helperHostSet);
+          if (val !== null) inst[meta.propertyKey](val, null, name, helperHostSet2);
         }
       }
     }
   }
   /** attributeChangedCallback 에서 elementDefine 이 직접 호출 */
-  onAttributeChanged(helperHostSet, name, old, newVal) {
-    const inst = helperHostSet.$this;
+  onAttributeChanged(helperHostSet2, name, old, newVal) {
+    const inst = helperHostSet2.$this;
     const metaList = this.getAttrChangeMap(inst).get(name);
     if (!metaList) return;
     for (const meta of metaList) {
       if (meta.options.while === "connected" && !inst.__swc_connected) continue;
-      inst[meta.propertyKey](convertAttributeValue(newVal, meta.options.type), old, name, helperHostSet);
+      inst[meta.propertyKey](convertAttributeValue(newVal, meta.options.type), old, name, helperHostSet2);
     }
   }
 };
@@ -15011,10 +16011,10 @@ var ChangedAttributeLifeCycler = class {
 // src/decorators/query.ts
 var QUERY_METADATA_KEY = Symbol.for("simple-web-component:query");
 var resolveQueryElements = (inst, selector, options, win) => {
-  const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
+  const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
   let all = [];
   if (typeof selector === "function") {
-    const result = selector(inst, hostSet);
+    const result = selector(inst, hostSet2);
     if (result instanceof win.NodeList)
       all = Array.from(result).filter((e) => e instanceof win.HTMLElement);
     else if (Array.isArray(result))
@@ -15026,23 +16026,23 @@ var resolveQueryElements = (inst, selector, options, win) => {
     if (selector === "$this")
       all = [inst];
     else if (selector === "$host")
-      all = hostSet.$host ? [hostSet.$host] : [];
+      all = hostSet2.$host ? [hostSet2.$host] : [];
     else if (selector === "$parentHost")
-      all = hostSet.$parentHost ? [hostSet.$parentHost] : [];
+      all = hostSet2.$parentHost ? [hostSet2.$parentHost] : [];
     else if (selector === "$appHost")
-      all = hostSet.$appHost ? [hostSet.$appHost] : [];
+      all = hostSet2.$appHost ? [hostSet2.$appHost] : [];
     else if (selector === "$firstHost")
-      all = hostSet.$firstHost ? [hostSet.$firstHost] : [];
+      all = hostSet2.$firstHost ? [hostSet2.$firstHost] : [];
     else if (selector === "$lastHost")
-      all = hostSet.$lastHost ? [hostSet.$lastHost] : [];
+      all = hostSet2.$lastHost ? [hostSet2.$lastHost] : [];
     else if (selector === "$firstAppHost")
-      all = hostSet.$firstAppHost ? [hostSet.$firstAppHost] : [];
+      all = hostSet2.$firstAppHost ? [hostSet2.$firstAppHost] : [];
     else if (selector === "$lastAppHost")
-      all = hostSet.$lastAppHost ? [hostSet.$lastAppHost] : [];
+      all = hostSet2.$lastAppHost ? [hostSet2.$lastAppHost] : [];
     else if (selector === "$hosts")
-      all = hostSet.$hosts.filter(Boolean);
+      all = hostSet2.$hosts.filter(Boolean);
     else if (selector === "$appHosts")
-      all = hostSet.$appHosts.filter(Boolean);
+      all = hostSet2.$appHosts.filter(Boolean);
     else {
       const scopes = [];
       if (r === "auto")
@@ -15064,7 +16064,7 @@ var resolveQueryElements = (inst, selector, options, win) => {
     }
   }
   if (options?.filter) {
-    all = all.filter((el) => options.filter(el, { currentThis: inst, helper: hostSet }));
+    all = all.filter((el) => options.filter(el, { currentThis: inst, helper: hostSet2 }));
   }
   return all;
 };
@@ -15336,8 +16336,8 @@ function state(nameOrTarget, propertyKey) {
         storage = nv;
         const config = getElementConfig(this);
         const ea = new ElementApply(this, { id: this._swcId });
-        const helperHostSet = SwcUtils.getHelperAndHostSet(config.window, this);
-        const stateContext = { ...helperHostSet };
+        const helperHostSet2 = SwcUtils.getHelperAndHostSet(config.window, this);
+        const stateContext = { ...helperHostSet2 };
         findAllStateMetadata(this).forEach((it) => {
           stateContext[it.name] = this[it.propertyKey];
         });
@@ -15391,8 +16391,8 @@ var resolvePropertyTargets = (inst, selector, options) => {
   const results = [];
   let resolvedSelector = selector;
   if (typeof selector === "function") {
-    const hostSet = SwcUtils.getHelperAndHostSet(currentWin, inst);
-    resolvedSelector = selector(inst, hostSet);
+    const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, inst);
+    resolvedSelector = selector(inst, hostSet2);
   }
   if (resolvedSelector instanceof currentWin.Element) {
     results.push(resolvedSelector);
@@ -15426,16 +16426,16 @@ var resolvePropertyTargets = (inst, selector, options) => {
   } else if (stringSelector === "$document") {
     results.push(currentWin.document);
   } else {
-    const hostSet = SwcUtils.getHostSet(inst);
-    if (stringSelector === "$host") applyRoot(hostSet.$host);
-    else if (stringSelector === "$parentHost") applyRoot(hostSet.$parentHost);
-    else if (stringSelector === "$appHost") applyRoot(hostSet.$appHost);
-    else if (stringSelector === "$firstHost") applyRoot(hostSet.$firstHost);
-    else if (stringSelector === "$lastHost") applyRoot(hostSet.$lastHost);
-    else if (stringSelector === "$firstAppHost") applyRoot(hostSet.$firstAppHost);
-    else if (stringSelector === "$lastAppHost") applyRoot(hostSet.$lastAppHost);
-    else if (stringSelector === "$hosts") hostSet.$hosts.forEach(applyRoot);
-    else if (stringSelector === "$appHosts") hostSet.$appHosts.forEach(applyRoot);
+    const hostSet2 = SwcUtils.getHostSet(inst);
+    if (stringSelector === "$host") applyRoot(hostSet2.$host);
+    else if (stringSelector === "$parentHost") applyRoot(hostSet2.$parentHost);
+    else if (stringSelector === "$appHost") applyRoot(hostSet2.$appHost);
+    else if (stringSelector === "$firstHost") applyRoot(hostSet2.$firstHost);
+    else if (stringSelector === "$lastHost") applyRoot(hostSet2.$lastHost);
+    else if (stringSelector === "$firstAppHost") applyRoot(hostSet2.$firstAppHost);
+    else if (stringSelector === "$lastAppHost") applyRoot(hostSet2.$lastAppHost);
+    else if (stringSelector === "$hosts") hostSet2.$hosts.forEach(applyRoot);
+    else if (stringSelector === "$appHosts") hostSet2.$appHosts.forEach(applyRoot);
     else {
       if (r === "shadow") {
         const found = inst.shadowRoot?.querySelectorAll(stringSelector);
@@ -15488,12 +16488,12 @@ function applyProperty(selector, targetPropertyKeyOrOptions, options) {
       const targetEls = resolvePropertyTargets(inst, selector, finalOptions);
       const conf = getElementConfig(inst);
       const currentWin = conf.window;
-      const hostSet = SwcUtils.getHelperAndHostSet(currentWin, inst);
+      const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, inst);
       targetEls.forEach((targetEl) => {
-        if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: inst, helper: hostSet })) {
+        if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: inst, helper: hostSet2 })) {
           return;
         }
-        const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet) : resolvedValue;
+        const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet2) : resolvedValue;
         if (finalOptions.setType === "call") {
           if (typeof targetEl[targetPropertyKey] !== "function") return;
           if (Array.isArray(resolvedRes)) targetEl[targetPropertyKey].apply(targetEl, resolvedRes);
@@ -15537,9 +16537,9 @@ function applyProperty(selector, targetPropertyKeyOrOptions, options) {
         const targetEls = resolvePropertyTargets(this, selector, finalOptions);
         const conf = getElementConfig(this);
         const currentWin = conf.window;
-        const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+        const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, this);
         const filtered = targetEls.filter((el) => {
-          if (finalOptions.filter && !finalOptions.filter(el, el[targetPropertyKey], { currentThis: this, helper: hostSet })) {
+          if (finalOptions.filter && !finalOptions.filter(el, el[targetPropertyKey], { currentThis: this, helper: hostSet2 })) {
             return false;
           }
           return true;
@@ -15615,17 +16615,23 @@ var findAllPropertyApplyMetadata = (target) => {
   return result;
 };
 var prop = applyProperty;
-function propThis(targetPropertyKey, options) {
-  return applyProperty("$this", targetPropertyKey, options);
+var dispatchPropConvenience = (selector, targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor) => {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyProperty(selector, void 0, {})(targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyProperty(selector, targetPropertyKeyOrTarget, optionsOrPropertyKey);
+};
+function propThis(targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor) {
+  return dispatchPropConvenience("$this", targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor);
 }
-function propAppHost(targetPropertyKey, options) {
-  return applyProperty("$appHost", targetPropertyKey, options);
+function propAppHost(targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor) {
+  return dispatchPropConvenience("$appHost", targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor);
 }
-function propWindow(targetPropertyKey, options) {
-  return applyProperty("$window", targetPropertyKey, options);
+function propWindow(targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor) {
+  return dispatchPropConvenience("$window", targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor);
 }
-function propDocument(targetPropertyKey, options) {
-  return applyProperty("$document", targetPropertyKey, options);
+function propDocument(targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor) {
+  return dispatchPropConvenience("$document", targetPropertyKeyOrTarget, optionsOrPropertyKey, descriptor);
 }
 function propLight(selector, targetPropertyKey, options) {
   return applyProperty(selector, targetPropertyKey, { ...options ?? {}, root: "light" });
@@ -15697,8 +16703,8 @@ var MessageSubscribeLifeCycler = class {
   onConnected(_helperHostSet) {
   }
   /** SwcAppMixin 이 구독 대상 메타를 꺼낼 때 사용 */
-  getMetadata(helperHostSet) {
-    return getSubscribeSwcAppMessageWhileConnectedMetadata(helperHostSet.$this);
+  getMetadata(helperHostSet2) {
+    return getSubscribeSwcAppMessageWhileConnectedMetadata(helperHostSet2.$this);
   }
 };
 
@@ -15749,22 +16755,57 @@ var RouteSubscribeLifeCycler = class {
   onConnected(_helperHostSet) {
   }
   /** SwcAppMixin 이 구독 대상 메타를 꺼낼 때 사용 */
-  getMetadata(helperHostSet) {
-    return getSubscribeSwcAppRouteChangeWhileConnectedMetadata(helperHostSet.$this);
+  getMetadata(helperHostSet2) {
+    return getSubscribeSwcAppRouteChangeWhileConnectedMetadata(helperHostSet2.$this);
   }
 };
 
 // src/decorators/setInterval.ts
 var SET_INTERVAL_METADATA_KEY = Symbol.for("simple-web-component:set-interval");
+var activeMap = /* @__PURE__ */ new WeakMap();
+var getActiveEntries = (inst) => {
+  let entries = activeMap.get(inst);
+  if (!entries) {
+    entries = [];
+    activeMap.set(inst, entries);
+  }
+  return entries;
+};
 function setInterval2(interval2, options = {}) {
-  return (target, propertyKey) => {
+  return (target, propertyKey, descriptor) => {
     const constructor = target.constructor;
+    const normalizedOptions = { ...options, type: options.type ?? "returnValue" };
     let metaList = ReflectUtils.getOwnMetadata(SET_INTERVAL_METADATA_KEY, constructor);
     if (!metaList) {
       metaList = [];
       ReflectUtils.defineMetadata(SET_INTERVAL_METADATA_KEY, metaList, constructor);
     }
-    metaList.push({ propertyKey, interval: interval2, options });
+    metaList.push({ propertyKey, interval: interval2, options: normalizedOptions });
+    if (normalizedOptions.type === "onConnected" || !descriptor) {
+      return;
+    }
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      const res = original.apply(this, args);
+      const vk = normalizedOptions.valueKey ?? SET_INTERVAL_METADATA_KEY;
+      const tickFn = typeof res === "function" ? res : res && typeof res === "object" && typeof res[vk] === "function" ? res[vk] : void 0;
+      if (tickFn) {
+        ensureInit(this);
+        const conf = getElementConfig(this);
+        const win = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+        const id = win.setInterval(() => {
+          try {
+            tickFn(id);
+          } catch (e) {
+            console.error("[SWC] setInterval tick error:", e);
+          }
+        }, interval2);
+        normalizedOptions.created?.(SwcUtils.getHelperAndHostSet(win, this), id);
+        getActiveEntries(this).push(id);
+      }
+      return res;
+    };
+    return descriptor;
   };
 }
 var findAllSetIntervalMetadata = (target) => {
@@ -15772,54 +16813,89 @@ var findAllSetIntervalMetadata = (target) => {
   return (ReflectUtils.findAllMetadata(SET_INTERVAL_METADATA_KEY, constructor) || []).flat();
 };
 var SetIntervalLifeCycler = class {
-  constructor() {
-    __publicField(this, "activeMap", /* @__PURE__ */ new WeakMap());
-  }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const ids = [];
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    activeMap.delete(inst);
     for (const meta of findAllSetIntervalMetadata(inst)) {
-      const id = helperHostSet.$w.setInterval(() => {
-        const args = meta.options.parameter?.(helperHostSet) ?? [];
+      if (meta.options.type !== "onConnected") continue;
+      const id = helperHostSet2.$w.setInterval(() => {
+        const args = meta.options.parameter?.(helperHostSet2) ?? [];
         try {
           const res = inst[meta.propertyKey](...args);
-          const vk = meta.options.valueKey;
-          if (vk && res && typeof res === "object" && typeof res[vk] === "function") {
+          const vk = meta.options.valueKey ?? SET_INTERVAL_METADATA_KEY;
+          if (res && typeof res === "object" && typeof res[vk] === "function") {
             res[vk](id);
           }
         } catch (e) {
           console.error("[SWC] setInterval tick error:", e);
         }
       }, meta.interval);
-      meta.options.created?.(helperHostSet, id);
-      ids.push(id);
+      meta.options.created?.(helperHostSet2, id);
+      getActiveEntries(inst).push(id);
     }
-    this.activeMap.set(inst, ids);
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    for (const id of this.activeMap.get(inst) ?? []) {
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    for (const id of activeMap.get(inst) ?? []) {
       try {
-        helperHostSet.$w.clearInterval(id);
+        helperHostSet2.$w.clearInterval(id);
       } catch (e) {
         console.error("[SWC] clearInterval error:", e);
       }
     }
-    this.activeMap.delete(inst);
+    activeMap.delete(inst);
   }
 };
 
 // src/decorators/setTimeout.ts
 var SET_TIMEOUT_METADATA_KEY = Symbol.for("simple-web-component:set-timeout");
+var activeMap2 = /* @__PURE__ */ new WeakMap();
+var getActiveEntries2 = (inst) => {
+  let entries = activeMap2.get(inst);
+  if (!entries) {
+    entries = [];
+    activeMap2.set(inst, entries);
+  }
+  return entries;
+};
 function setTimeout2(delay, options = {}) {
-  return (target, propertyKey) => {
+  return (target, propertyKey, descriptor) => {
     const constructor = target.constructor;
+    const normalizedOptions = { ...options, type: options.type ?? "returnValue" };
     let metaList = ReflectUtils.getOwnMetadata(SET_TIMEOUT_METADATA_KEY, constructor);
     if (!metaList) {
       metaList = [];
       ReflectUtils.defineMetadata(SET_TIMEOUT_METADATA_KEY, metaList, constructor);
     }
-    metaList.push({ propertyKey, delay, options });
+    metaList.push({ propertyKey, delay, options: normalizedOptions });
+    if (normalizedOptions.type === "onConnected" || !descriptor) {
+      return;
+    }
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      const res = original.apply(this, args);
+      const vk = normalizedOptions.valueKey ?? SET_TIMEOUT_METADATA_KEY;
+      const tickFn = typeof res === "function" ? res : res && typeof res === "object" && typeof res[vk] === "function" ? res[vk] : void 0;
+      if (tickFn) {
+        ensureInit(this);
+        const conf = getElementConfig(this);
+        const win = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+        const id = win.setTimeout(() => {
+          const entries = getActiveEntries2(this);
+          const idx = entries.indexOf(id);
+          if (idx >= 0) entries.splice(idx, 1);
+          try {
+            tickFn(id);
+          } catch (e) {
+            console.error("[SWC] setTimeout fire error:", e);
+          }
+        }, delay);
+        normalizedOptions.created?.(SwcUtils.getHelperAndHostSet(win, this), id);
+        getActiveEntries2(this).push(id);
+      }
+      return res;
+    };
+    return descriptor;
   };
 }
 var findAllSetTimeoutMetadata = (target) => {
@@ -15827,40 +16903,190 @@ var findAllSetTimeoutMetadata = (target) => {
   return (ReflectUtils.findAllMetadata(SET_TIMEOUT_METADATA_KEY, constructor) || []).flat();
 };
 var SetTimeoutLifeCycler = class {
-  constructor() {
-    __publicField(this, "activeMap", /* @__PURE__ */ new WeakMap());
-  }
-  onConnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    const ids = [];
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    activeMap2.delete(inst);
     for (const meta of findAllSetTimeoutMetadata(inst)) {
-      const id = helperHostSet.$w.setTimeout(() => {
-        const args = meta.options.parameter?.(helperHostSet) ?? [];
+      if (meta.options.type !== "onConnected") continue;
+      const id = helperHostSet2.$w.setTimeout(() => {
+        const args = meta.options.parameter?.(helperHostSet2) ?? [];
         try {
           const res = inst[meta.propertyKey](...args);
-          const vk = meta.options.valueKey;
-          if (vk && res && typeof res === "object" && typeof res[vk] === "function") {
+          const vk = meta.options.valueKey ?? SET_TIMEOUT_METADATA_KEY;
+          if (res && typeof res === "object" && typeof res[vk] === "function") {
             res[vk](id);
           }
         } catch (e) {
           console.error("[SWC] setTimeout fire error:", e);
         }
       }, meta.delay);
-      meta.options.created?.(helperHostSet, id);
-      ids.push(id);
+      meta.options.created?.(helperHostSet2, id);
+      getActiveEntries2(inst).push(id);
     }
-    this.activeMap.set(inst, ids);
   }
-  onDisconnected(helperHostSet) {
-    const inst = helperHostSet.$this;
-    for (const id of this.activeMap.get(inst) ?? []) {
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    for (const id of activeMap2.get(inst) ?? []) {
       try {
-        helperHostSet.$w.clearTimeout(id);
+        helperHostSet2.$w.clearTimeout(id);
       } catch (e) {
         console.error("[SWC] clearTimeout error:", e);
       }
     }
-    this.activeMap.delete(inst);
+    activeMap2.delete(inst);
+  }
+};
+
+// src/decorators/requestAnimationFrame.ts
+var REQUEST_ANIMATION_FRAME_METADATA_KEY = Symbol.for("simple-web-component:request-animation-frame");
+var activeMap3 = /* @__PURE__ */ new WeakMap();
+var getActiveEntries3 = (inst) => {
+  let entries = activeMap3.get(inst);
+  if (!entries) {
+    entries = [];
+    activeMap3.set(inst, entries);
+  }
+  return entries;
+};
+var startFrameLoop = (win, entries, frameFn) => {
+  let currentId = 0;
+  const step = (timestamp, prevValue) => {
+    const idx = entries.indexOf(currentId);
+    if (idx >= 0) entries.splice(idx, 1);
+    let result;
+    try {
+      result = frameFn(timestamp, prevValue);
+    } catch (e) {
+      console.error("[SWC] requestAnimationFrame callback error:", e);
+      return;
+    }
+    if (result === void 0 || result === null) return;
+    currentId = win.requestAnimationFrame((ts) => step(ts, result));
+    entries.push(currentId);
+  };
+  currentId = win.requestAnimationFrame((ts) => step(ts, void 0));
+  entries.push(currentId);
+  return currentId;
+};
+var applyRequestAnimationFrame = (options, target, propertyKey, descriptor) => {
+  const constructor = target.constructor;
+  const normalizedOptions = { ...options, type: options.type ?? "returnValue" };
+  let metaList = ReflectUtils.getOwnMetadata(REQUEST_ANIMATION_FRAME_METADATA_KEY, constructor);
+  if (!metaList) {
+    metaList = [];
+    ReflectUtils.defineMetadata(REQUEST_ANIMATION_FRAME_METADATA_KEY, metaList, constructor);
+  }
+  metaList.push({ propertyKey, options: normalizedOptions });
+  if (normalizedOptions.type === "onConnected" || !descriptor) {
+    return;
+  }
+  const original = descriptor.value;
+  descriptor.value = function(...args) {
+    const res = original.apply(this, args);
+    const vk = normalizedOptions.valueKey ?? REQUEST_ANIMATION_FRAME_METADATA_KEY;
+    const frameFn = typeof res === "function" ? res : res && typeof res === "object" && typeof res[vk] === "function" ? res[vk] : void 0;
+    if (frameFn) {
+      ensureInit(this);
+      const conf = getElementConfig(this);
+      const win = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
+      const id = startFrameLoop(win, getActiveEntries3(this), frameFn);
+      normalizedOptions.created?.(SwcUtils.getHelperAndHostSet(win, this), id);
+    }
+    return res;
+  };
+  return descriptor;
+};
+function requestAnimationFrame(optionsOrTarget, propertyKey, descriptor) {
+  if (propertyKey !== void 0) {
+    applyRequestAnimationFrame({}, optionsOrTarget, propertyKey, descriptor);
+    return;
+  }
+  return (target, propertyKey2, descriptor2) => {
+    return applyRequestAnimationFrame(optionsOrTarget ?? {}, target, propertyKey2, descriptor2);
+  };
+}
+var findAllRequestAnimationFrameMetadata = (target) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return (ReflectUtils.findAllMetadata(REQUEST_ANIMATION_FRAME_METADATA_KEY, constructor) || []).flat();
+};
+var RequestAnimationFrameLifeCycler = class {
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    activeMap3.delete(inst);
+    const entries = getActiveEntries3(inst);
+    for (const meta of findAllRequestAnimationFrameMetadata(inst)) {
+      if (meta.options.type !== "onConnected") continue;
+      const frameFn = (timestamp, prevValue) => inst[meta.propertyKey](timestamp, prevValue);
+      const id = startFrameLoop(helperHostSet2.$w, entries, frameFn);
+      meta.options.created?.(helperHostSet2, id);
+    }
+  }
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    for (const id of activeMap3.get(inst) ?? []) {
+      try {
+        helperHostSet2.$w.cancelAnimationFrame(id);
+      } catch (e) {
+        console.error("[SWC] cancelAnimationFrame error:", e);
+      }
+    }
+    activeMap3.delete(inst);
+  }
+};
+
+// src/decorators/eventMedia.ts
+var EVENT_MEDIA_METADATA_KEY = Symbol.for("simple-web-component:event-media");
+function eventMedia(query2, eventType) {
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    let metaList = ReflectUtils.getOwnMetadata(EVENT_MEDIA_METADATA_KEY, constructor);
+    if (!metaList) {
+      metaList = [];
+      ReflectUtils.defineMetadata(EVENT_MEDIA_METADATA_KEY, metaList, constructor);
+    }
+    metaList.push({ propertyKey, query: query2, eventType });
+  };
+}
+function eventMediaChange(query2) {
+  return eventMedia(query2, "change");
+}
+var findAllEventMediaMetadata = (target) => {
+  const constructor = target instanceof Function ? target : target.constructor;
+  return (ReflectUtils.findAllMetadata(EVENT_MEDIA_METADATA_KEY, constructor) || []).flat();
+};
+var EventMediaLifeCycler = class {
+  constructor() {
+    __publicField(this, "entriesMap", /* @__PURE__ */ new WeakMap());
+  }
+  onConnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    const metaList = findAllEventMediaMetadata(inst);
+    if (metaList.length === 0) return;
+    const entries = [];
+    for (const meta of metaList) {
+      const mql = helperHostSet2.$w.matchMedia(meta.query);
+      const handler = (e) => {
+        try {
+          inst[meta.propertyKey](e, helperHostSet2);
+        } catch (err) {
+          console.error("[SWC] eventMedia handler error:", err);
+        }
+      };
+      mql.addEventListener(meta.eventType, handler);
+      entries.push({ mql, eventType: meta.eventType, handler });
+    }
+    this.entriesMap.set(inst, entries);
+  }
+  onDisconnected(helperHostSet2) {
+    const inst = helperHostSet2.$this;
+    for (const { mql, eventType, handler } of this.entriesMap.get(inst) ?? []) {
+      try {
+        mql.removeEventListener(eventType, handler);
+      } catch (e) {
+        console.error("[SWC] eventMedia cleanup error:", e);
+      }
+    }
+    this.entriesMap.delete(inst);
   }
 };
 
@@ -15908,11 +17134,11 @@ var ensureInit = (inst) => {
         inst[meta.propertyKey] = initUserData;
       });
     }
-    const hostSet = SwcUtils.getHostSet(inst);
+    const hostSet2 = SwcUtils.getHostSet(inst);
     const appHosts = SwcUtils.findAllAppHostsIncludingSelfDirect(inst);
-    inst._executeSwcScript?.("swc-on-constructor", hostSet);
+    inst._executeSwcScript?.("swc-on-constructor", hostSet2);
     const cMethods = findAllLifecycleMetadata(inst, ON_INITIALIZE_METADATA_KEY);
-    for (const m of cMethods) inst._invokeLifecycleMethod(m.propertyKey, hostSet);
+    for (const m of cMethods) inst._invokeLifecycleMethod(m.propertyKey, hostSet2);
   }
 };
 var globalDelegatedRoots = /* @__PURE__ */ new WeakSet();
@@ -15951,7 +17177,7 @@ var getHandlers = (inst) => {
 var setupPrototype = (proto, win) => {
   if (proto.__swc_proto_setup) return;
   proto.__swc_proto_setup = true;
-  proto._executeSwcScript = function(attrName, hostSet, extraArgs = {}) {
+  proto._executeSwcScript = function(attrName, hostSet2, extraArgs = {}) {
     ensureInit(this);
     const script = this.getAttribute(attrName);
     if (script) {
@@ -15959,7 +17185,7 @@ var setupPrototype = (proto, win) => {
         const conf = getElementConfig(this);
         const currentWin = this._resolveWindow(conf);
         const helpers = SwcUtils.getHelperSet(currentWin);
-        const args = { ...hostSet, ...helpers, ...extraArgs, $el: this, $root: this.getRootNode() };
+        const args = { ...hostSet2, ...helpers, ...extraArgs, $el: this, $root: this.getRootNode() };
         FunctionUtils.execute({ script, context: this, args });
       } catch (e) {
         console.error(`[SWC] Failed to execute ${attrName}:`, e);
@@ -15976,11 +17202,14 @@ var setupPrototype = (proto, win) => {
     }
     return getElementConfig(this).window ?? (typeof window !== "undefined" ? window : void 0);
   };
-  proto._invokeLifecycleMethod = function(methodName, hostSet, extraArgs = []) {
+  proto._invokeLifecycleMethod = function(methodName, hostSet2, extraArgs = []) {
     ensureInit(this);
     if (typeof this[methodName] !== "function") return;
-    const useHostSet = hostSet ?? SwcUtils.getHelperAndHostSet(win, this);
+    const useHostSet = hostSet2 ?? SwcUtils.getHelperAndHostSet(win, this);
     const app = useHostSet?.$appHost?.simpleApplication;
+    const helperSetValue = SwcUtils.getHelperSet(win);
+    const helperHostSetValue = { ...helperSetValue, ...useHostSet, $this: this };
+    const kindValues = { hostSet: useHostSet, helperHostSet: helperHostSetValue, helperSet: helperSetValue };
     if (app) {
       const otherStorage = /* @__PURE__ */ new Map();
       const situations = new SituationTypeContainers([new SituationTypeContainer({ situationType: "SIMPLE_WEB_COMPONENT://HOSTSET" /* HOST_SET */, data: useHostSet }), new SituationTypeContainer({ situationType: "SIMPLE_WEB_COMPONENT://APPHOST" /* APP_HOST */, data: useHostSet.$appHost }), new SituationTypeContainer({ situationType: "SIMPLE_WEB_COMPONENT://APPHOSTS" /* APP_HOSTS */, data: useHostSet.$appHosts }), new SituationTypeContainer({
@@ -15991,16 +17220,23 @@ var setupPrototype = (proto, win) => {
         data: useHostSet.$firstAppHost
       }), new SituationTypeContainer({ situationType: "SIMPLE_WEB_COMPONENT://LASTAPPHOST" /* LAST_APP_HOST */, data: useHostSet.$lastAppHost })]);
       otherStorage.set(SituationTypeContainers, situations);
+      const firstCheckMaker = ({ target, targetKey }, token, idx) => {
+        const saves = getParameterMetadata(target, targetKey);
+        const found = saves.find((s) => s.index === idx);
+        return found ? kindValues[found.kind] : void 0;
+      };
       return app.simstanceManager.executeBindParameterSim(
         {
           target: this,
           targetKey: methodName,
-          inputParameters: extraArgs
+          inputParameters: extraArgs,
+          firstCheckMaker: [firstCheckMaker]
         },
         otherStorage
       );
     } else {
-      return this[methodName](...extraArgs);
+      const args = buildSwcParameterArgs(this, methodName, kindValues, extraArgs);
+      return this[methodName](...args);
     }
   };
   proto._bindAttributeEvent = function(el, attrName, script, eventName) {
@@ -16018,14 +17254,14 @@ var setupPrototype = (proto, win) => {
     const oldHandler = handlers.get(attrName);
     if (oldHandler) el.removeEventListener(eventName, oldHandler);
     const handler = async (event2) => {
-      const hostSet = SwcUtils.getHostSet(el);
+      const hostSet2 = SwcUtils.getHostSet(el);
       const conf = getElementConfig(this);
       const currentWin = this._resolveWindow(conf);
       const helpers = SwcUtils.getHelperSet(currentWin);
       const args = {
         event: event2,
         $data: event2.detail,
-        ...hostSet,
+        ...hostSet2,
         ...helpers,
         $el: el,
         $root: this.getRootNode()
@@ -16037,7 +17273,7 @@ var setupPrototype = (proto, win) => {
   };
   proto.__swc_executeAttributeEvent = async function(el, attrName, script, event2) {
     ensureInit(this);
-    const hostSet = SwcUtils.getHostSet(el);
+    const hostSet2 = SwcUtils.getHostSet(el);
     const conf = getElementConfig(this);
     const currentWin = this._resolveWindow(conf);
     const currentHelpers = SwcUtils.getHelperSet(currentWin);
@@ -16047,7 +17283,7 @@ var setupPrototype = (proto, win) => {
       $event: event2,
       $data: detail,
       $detail: detail,
-      ...hostSet,
+      ...hostSet2,
       ...currentHelpers,
       $el: el,
       $root: this.getRootNode()
@@ -16081,7 +17317,7 @@ var elementDefine = (name, config = {}) => (constructor) => {
   const originalStaticObservedAttributes = constructor.observedAttributes ?? [];
   const proto = constructor.prototype;
   setupPrototype(proto, win);
-  let helperHostSet = null;
+  let helperHostSet2 = null;
   const eventCycler = new EventListenerLifeCycler();
   const cyclers = [
     eventCycler,
@@ -16093,12 +17329,14 @@ var elementDefine = (name, config = {}) => (constructor) => {
     new MessageSubscribeLifeCycler(),
     new RouteSubscribeLifeCycler(),
     new SetIntervalLifeCycler(),
-    new SetTimeoutLifeCycler()
+    new SetTimeoutLifeCycler(),
+    new RequestAnimationFrameLifeCycler(),
+    new EventMediaLifeCycler()
   ];
   const cyclerObservedAttributes = cyclers.flatMap((c) => c.getObservedAttributeNames?.(constructor) ?? []);
   const mergedObservedAttributes = [.../* @__PURE__ */ new Set([...metadata.observedAttributes ?? [], ...originalStaticObservedAttributes, ...cyclerObservedAttributes, ...attributeApplyNames, ...hostAttributes, ...swcLifecycleAttributes, ...swcOnEvents])];
-  const buildObservers = async (helperHostSet2) => {
-    const inst = helperHostSet2.$this;
+  const buildObservers = async (helperHostSet3) => {
+    const inst = helperHostSet3.$this;
     const observers = [];
     let resizeObserverSet = [];
     let mutationObserverSet = [];
@@ -16116,7 +17354,7 @@ var elementDefine = (name, config = {}) => (constructor) => {
       return roots;
     };
     for (const c of cyclers) {
-      const result = await c.onConnected?.(helperHostSet2, resizeObserverSet);
+      const result = await c.onConnected?.(helperHostSet3, resizeObserverSet);
       if (!result) continue;
       if (result.resizeObserverSet?.length) resizeObserverSet = [...resizeObserverSet, ...result.resizeObserverSet];
       if (result.mutationObserverSet?.length) mutationObserverSet = [...mutationObserverSet, ...result.mutationObserverSet];
@@ -16298,8 +17536,8 @@ var elementDefine = (name, config = {}) => (constructor) => {
   const originalConnected = proto.connectedCallback;
   proto.connectedCallback = async function() {
     ensureInit(this);
-    helperHostSet = SwcUtils.getHelperAndHostSet(win, this);
-    const appHost = helperHostSet.$appHost;
+    helperHostSet2 = SwcUtils.getHelperAndHostSet(win, this);
+    const appHost = helperHostSet2.$appHost;
     const useSsr = isSSR(this);
     try {
       if (appHost && typeof appHost._connected === "function") {
@@ -16310,15 +17548,15 @@ var elementDefine = (name, config = {}) => (constructor) => {
       }
       const conf = getElementConfig(this);
       const currentWin = this._resolveWindow(conf);
-      for (const m of findAllOnConnectedBeforeMetadata(this)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
-      this._executeSwcScript("swc-on-before-connected", helperHostSet);
+      for (const m of findAllOnConnectedBeforeMetadata(this)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet2);
+      this._executeSwcScript("swc-on-before-connected", helperHostSet2);
       const targetConnectedList = useSsr ? [] : findAllOnConnectedMetadata(constructor);
       const shadowMode = conf?.useShadow || targetConnectedList.find((it) => it.options.useShadow)?.options.useShadow;
       if (shadowMode && !this.shadowRoot) {
         const mode = shadowMode === true ? "open" : shadowMode;
         this.attachShadow({ mode });
       }
-      const stateContext = { ...helperHostSet };
+      const stateContext = { ...helperHostSet2 };
       findAllStateMetadata(this).forEach((it) => {
         stateContext[it.name] = this[it.propertyKey];
       });
@@ -16326,7 +17564,7 @@ var elementDefine = (name, config = {}) => (constructor) => {
       const lightChildren = [];
       if (targetConnectedList.length > 0) {
         for (const meta of targetConnectedList) {
-          let res = await this._invokeLifecycleMethod(meta.propertyKey, helperHostSet);
+          let res = await this._invokeLifecycleMethod(meta.propertyKey, helperHostSet2);
           if (typeof res === "string") {
             const htmlTemplateElement = doc.createElement("template");
             htmlTemplateElement.innerHTML = res;
@@ -16366,12 +17604,12 @@ var elementDefine = (name, config = {}) => (constructor) => {
       }
       await buildObservers(SwcUtils.getHelperAndHostSet(win, this));
       if (originalConnected) await originalConnected.apply(this);
-      for (const m of findAllOnConnectedAfterMetadata(this)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
-      this._executeSwcScript("swc-on-connected", helperHostSet);
-      this._executeSwcScript("swc-on-after-connected", helperHostSet);
+      for (const m of findAllOnConnectedAfterMetadata(this)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet2);
+      this._executeSwcScript("swc-on-connected", helperHostSet2);
+      this._executeSwcScript("swc-on-after-connected", helperHostSet2);
       this.__swc_connected = true;
     } finally {
-      for (const m of findAllLifecycleMetadata(this, ON_CONNECTED_COMPLETED_METADATA_KEY)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
+      for (const m of findAllLifecycleMetadata(this, ON_CONNECTED_COMPLETED_METADATA_KEY)) await this._invokeLifecycleMethod(m.propertyKey, helperHostSet2);
       if (appHost && typeof appHost._connectedDone === "function") {
         await appHost._connectedDone(this);
       }
@@ -16379,13 +17617,13 @@ var elementDefine = (name, config = {}) => (constructor) => {
   };
   const originalDisconnected = proto.disconnectedCallback;
   proto.disconnectedCallback = function() {
-    const appHost = helperHostSet?.$appHost;
+    const appHost = helperHostSet2?.$appHost;
     if (appHost && typeof appHost._disconnected === "function") {
       appHost._disconnected(this);
     }
-    this._executeSwcScript("swc-on-before-disconnected", helperHostSet);
-    for (const m of findAllLifecycleMetadata(this, ON_BEFORE_DISCONNECTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
-    for (const c of cyclers) c.onDisconnected?.(helperHostSet);
+    this._executeSwcScript("swc-on-before-disconnected", helperHostSet2);
+    for (const m of findAllLifecycleMetadata(this, ON_BEFORE_DISCONNECTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, helperHostSet2);
+    for (const c of cyclers) c.onDisconnected?.(helperHostSet2);
     for (const o of this.__swc_observers ?? []) {
       try {
         o?.disconnect?.();
@@ -16396,21 +17634,21 @@ var elementDefine = (name, config = {}) => (constructor) => {
     this.__swc_observers = [];
     new ElementApply(this, { id: this._swcId }).removeAllEventListener();
     if (originalDisconnected) originalDisconnected.apply(this);
-    for (const m of findAllLifecycleMetadata(this, ON_AFTER_DISCONNECTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, helperHostSet);
-    this._executeSwcScript("swc-on-disconnected", helperHostSet);
-    this._executeSwcScript("swc-on-after-disconnected", helperHostSet);
+    for (const m of findAllLifecycleMetadata(this, ON_AFTER_DISCONNECTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, helperHostSet2);
+    this._executeSwcScript("swc-on-disconnected", helperHostSet2);
+    this._executeSwcScript("swc-on-after-disconnected", helperHostSet2);
     this.__swc_connected = false;
   };
   const originalAdopted = proto.adoptedCallback;
   proto.adoptedCallback = function() {
-    const hostSet = SwcUtils.getHostSet(this);
-    this._executeSwcScript("swc-on-before-adopted", hostSet);
-    for (const m of findAllLifecycleMetadata(this, ON_BEFORE_ADOPTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, hostSet);
-    for (const c of cyclers) c.onAdopted?.(helperHostSet);
+    const hostSet2 = SwcUtils.getHostSet(this);
+    this._executeSwcScript("swc-on-before-adopted", hostSet2);
+    for (const m of findAllLifecycleMetadata(this, ON_BEFORE_ADOPTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, hostSet2);
+    for (const c of cyclers) c.onAdopted?.(helperHostSet2);
     if (originalAdopted) originalAdopted.apply(this);
-    for (const m of findAllLifecycleMetadata(this, ON_AFTER_ADOPTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, hostSet);
-    this._executeSwcScript("swc-on-adopted", hostSet);
-    this._executeSwcScript("swc-on-after-adopted", hostSet);
+    for (const m of findAllLifecycleMetadata(this, ON_AFTER_ADOPTED_METADATA_KEY)) this._invokeLifecycleMethod(m.propertyKey, hostSet2);
+    this._executeSwcScript("swc-on-adopted", hostSet2);
+    this._executeSwcScript("swc-on-after-adopted", hostSet2);
   };
   const originalAttributeChanged = proto.attributeChangedCallback;
   proto.attributeChangedCallback = function(name2, old, newVal) {
@@ -16505,8 +17743,8 @@ var resolveAttributeTargets = (inst, selector, options) => {
   const results = [];
   let resolvedSelector = selector;
   if (typeof selector === "function") {
-    const hostSet = SwcUtils.getHelperAndHostSet(currentWin, inst);
-    resolvedSelector = selector(inst, hostSet);
+    const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, inst);
+    resolvedSelector = selector(inst, hostSet2);
   }
   if (resolvedSelector instanceof currentWin.Element) {
     results.push(resolvedSelector);
@@ -16536,16 +17774,16 @@ var resolveAttributeTargets = (inst, selector, options) => {
   if (stringSelector === "$this" || !stringSelector) {
     applyRoot(inst);
   } else {
-    const hostSet = SwcUtils.getHostSet(inst);
-    if (stringSelector === "$host") applyRoot(hostSet.$host);
-    else if (stringSelector === "$parentHost") applyRoot(hostSet.$parentHost);
-    else if (stringSelector === "$appHost") applyRoot(hostSet.$appHost);
-    else if (stringSelector === "$firstHost") applyRoot(hostSet.$firstHost);
-    else if (stringSelector === "$lastHost") applyRoot(hostSet.$lastHost);
-    else if (stringSelector === "$firstAppHost") applyRoot(hostSet.$firstAppHost);
-    else if (stringSelector === "$lastAppHost") applyRoot(hostSet.$lastAppHost);
-    else if (stringSelector === "$hosts") hostSet.$hosts.forEach(applyRoot);
-    else if (stringSelector === "$appHosts") hostSet.$appHosts.forEach(applyRoot);
+    const hostSet2 = SwcUtils.getHostSet(inst);
+    if (stringSelector === "$host") applyRoot(hostSet2.$host);
+    else if (stringSelector === "$parentHost") applyRoot(hostSet2.$parentHost);
+    else if (stringSelector === "$appHost") applyRoot(hostSet2.$appHost);
+    else if (stringSelector === "$firstHost") applyRoot(hostSet2.$firstHost);
+    else if (stringSelector === "$lastHost") applyRoot(hostSet2.$lastHost);
+    else if (stringSelector === "$firstAppHost") applyRoot(hostSet2.$firstAppHost);
+    else if (stringSelector === "$lastAppHost") applyRoot(hostSet2.$lastAppHost);
+    else if (stringSelector === "$hosts") hostSet2.$hosts.forEach(applyRoot);
+    else if (stringSelector === "$appHosts") hostSet2.$appHosts.forEach(applyRoot);
     else {
       if (r === "shadow") {
         const found = inst.shadowRoot?.querySelectorAll(stringSelector);
@@ -16598,9 +17836,9 @@ function applyAttribute(selector, targetAttributeNameOrOptions, options) {
       const conf = getElementConfig(inst);
       const currentWin = conf.window;
       const targetEls = resolveAttributeTargets(inst, selector, finalOptions);
-      const hostSet = SwcUtils.getHelperAndHostSet(currentWin, inst);
+      const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, inst);
       targetEls.forEach((targetEl) => {
-        if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: inst, helper: hostSet })) {
+        if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: inst, helper: hostSet2 })) {
           return;
         }
         if (resolvedValue === null) {
@@ -16699,11 +17937,17 @@ var findAllAttributeApplyMetadata = (target) => {
   return result;
 };
 var attr = applyAttribute;
-function attrThis(targetAttributeName, options) {
-  return applyAttribute("$this", targetAttributeName, options);
+function attrThis(targetAttributeNameOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyAttribute("$this", void 0, {})(targetAttributeNameOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyAttribute("$this", targetAttributeNameOrTarget, optionsOrPropertyKey);
 }
-function attrAppHost(targetAttributeName, options) {
-  return applyAttribute("$appHost", targetAttributeName, options);
+function attrAppHost(targetAttributeNameOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyAttribute("$appHost", void 0, {})(targetAttributeNameOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyAttribute("$appHost", targetAttributeNameOrTarget, optionsOrPropertyKey);
 }
 function attrLight(selector, targetAttributeName, options) {
   return applyAttribute(selector, targetAttributeName, { ...options ?? {}, root: "light" });
@@ -16719,8 +17963,8 @@ function attrAll(selector, targetAttributeName, options) {
 var APPLY_NODE_METADATA_KEY = Symbol.for("simple-web-component:apply-node");
 var resolveSelector = (selector, inst, win) => {
   if (typeof selector === "function") {
-    const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
-    const result = selector(inst, hostSet);
+    const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
+    const result = selector(inst, hostSet2);
     if (result instanceof win.Element) {
       return result;
     }
@@ -16744,7 +17988,7 @@ var applyToDom = (currentThis, targetEl, res, pos, win, host) => {
     return [];
   }
   const doc = win.document;
-  const hostSet = SwcUtils.getHelperAndHostSet(win, currentThis);
+  const hostSet2 = SwcUtils.getHelperAndHostSet(win, currentThis);
   const id = currentThis._swcId;
   const nodes = [];
   if (res instanceof win.Node) {
@@ -16773,7 +18017,7 @@ var applyToDom = (currentThis, targetEl, res, pos, win, host) => {
     else if (pos === "beforeBegin" && !isShadowRoot) targetEl.before(...nodes);
     else if (pos === "afterEnd" && !isShadowRoot) targetEl.after(...nodes);
   }
-  const stateContext = { ...hostSet };
+  const stateContext = { ...hostSet2 };
   findAllStateMetadata(currentThis).forEach((it) => {
     stateContext[it.name] = currentThis[it.propertyKey];
   });
@@ -16804,7 +18048,7 @@ function applyNode(selectorOrOptions, maybeOptions) {
       const conf = getElementConfig(this);
       const currentWin = this._resolveWindow?.(conf) || (typeof window !== "undefined" ? window : void 0);
       const currentDoc = currentWin.document;
-      const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+      const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, this);
       const getTarget = () => {
         const r = options.root || "auto";
         const applyRoot = (t) => {
@@ -16824,11 +18068,11 @@ function applyNode(selectorOrOptions, maybeOptions) {
         }
         const stringSelector = resolved;
         if (stringSelector === "$this") return applyRoot(this);
-        if (stringSelector === "$host") return applyRoot(hostSet.$host);
-        if (stringSelector === "$parentHost") return applyRoot(hostSet.$parentHost);
-        if (stringSelector === "$appHost") return applyRoot(hostSet.$appHost);
-        if (stringSelector === "$firstHost") return applyRoot(hostSet.$firstHost);
-        if (stringSelector === "$lastHost") return applyRoot(hostSet.$lastHost);
+        if (stringSelector === "$host") return applyRoot(hostSet2.$host);
+        if (stringSelector === "$parentHost") return applyRoot(hostSet2.$parentHost);
+        if (stringSelector === "$appHost") return applyRoot(hostSet2.$appHost);
+        if (stringSelector === "$firstHost") return applyRoot(hostSet2.$firstHost);
+        if (stringSelector === "$lastHost") return applyRoot(hostSet2.$lastHost);
         const targetRoot = applyRoot(this);
         return targetRoot ? targetRoot.querySelector(stringSelector) : null;
       };
@@ -16844,13 +18088,13 @@ function applyNode(selectorOrOptions, maybeOptions) {
       const runApply = (target, val) => {
         const pos = options.position || "beforeEnd";
         const processedVal = val;
-        if (!options.filter || options.filter(target, processedVal, { currentThis: this, helper: hostSet })) {
+        if (!options.filter || options.filter(target, processedVal, { currentThis: this, helper: hostSet2 })) {
           applyToDom(this, target, processedVal, pos, currentWin);
         }
       };
       const fallbackNodes = [];
       if (targetEl && options.fallback) {
-        const loadingRes = options.fallback.call(this, hostSet);
+        const loadingRes = options.fallback.call(this, hostSet2);
         fallbackNodes.push(...applyToDom(this, targetEl, loadingRes, options.position || "beforeEnd", currentWin));
       }
       if (res instanceof Promise) {
@@ -17006,11 +18250,17 @@ function clearChildrenLight(selectorOrOptions, maybeOptions, descriptor) {
 }
 var apply = applyNode;
 var node = applyNode;
-function applyThis(options) {
-  return applyNode("$this", options);
+function applyThis(optionsOrTarget, propertyKey, descriptor) {
+  if ((typeof propertyKey === "string" || typeof propertyKey === "symbol") && descriptor !== void 0) {
+    return applyNode("$this", {})(optionsOrTarget, propertyKey, descriptor);
+  }
+  return applyNode("$this", optionsOrTarget);
 }
-function applyAppHost(options) {
-  return applyNode("$appHost", options);
+function applyAppHost(optionsOrTarget, propertyKey, descriptor) {
+  if ((typeof propertyKey === "string" || typeof propertyKey === "symbol") && descriptor !== void 0) {
+    return applyNode("$appHost", {})(optionsOrTarget, propertyKey, descriptor);
+  }
+  return applyNode("$appHost", optionsOrTarget);
 }
 function applyLight(selector, options) {
   return applyNode(selector, { ...options ?? {}, root: "light" });
@@ -17074,8 +18324,8 @@ var applyIfChanged = (target, newValue) => {
 var CLASS_METADATA_KEY = Symbol.for("simple-web-component:class");
 var resolveSelector2 = (selector, inst, win) => {
   if (typeof selector === "function") {
-    const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
-    const result = selector(inst, hostSet);
+    const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
+    const result = selector(inst, hostSet2);
     if (result instanceof win.Element) {
       return [result];
     }
@@ -17103,21 +18353,21 @@ var getTargetElements = (selector, inst, win, root) => {
   const stringSelector = resolved;
   const targetEls = [];
   const host = inst;
-  const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
+  const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
   const applyRoot = (t) => {
     if (!t || !(t instanceof win.HTMLElement)) return;
     targetEls.push(t);
   };
   if (stringSelector === "$this" || !stringSelector) applyRoot(host);
-  else if (stringSelector === "$host") applyRoot(hostSet.$host);
-  else if (stringSelector === "$parentHost") applyRoot(hostSet.$parentHost);
-  else if (stringSelector === "$appHost") applyRoot(hostSet.$appHost);
-  else if (stringSelector === "$firstHost") applyRoot(hostSet.$firstHost);
-  else if (stringSelector === "$lastHost") applyRoot(hostSet.$lastHost);
-  else if (stringSelector === "$firstAppHost") applyRoot(hostSet.$firstAppHost);
-  else if (stringSelector === "$lastAppHost") applyRoot(hostSet.$lastAppHost);
-  else if (stringSelector === "$hosts") hostSet.$hosts.forEach(applyRoot);
-  else if (stringSelector === "$appHosts") hostSet.$appHosts.forEach(applyRoot);
+  else if (stringSelector === "$host") applyRoot(hostSet2.$host);
+  else if (stringSelector === "$parentHost") applyRoot(hostSet2.$parentHost);
+  else if (stringSelector === "$appHost") applyRoot(hostSet2.$appHost);
+  else if (stringSelector === "$firstHost") applyRoot(hostSet2.$firstHost);
+  else if (stringSelector === "$lastHost") applyRoot(hostSet2.$lastHost);
+  else if (stringSelector === "$firstAppHost") applyRoot(hostSet2.$firstAppHost);
+  else if (stringSelector === "$lastAppHost") applyRoot(hostSet2.$lastAppHost);
+  else if (stringSelector === "$hosts") hostSet2.$hosts.forEach(applyRoot);
+  else if (stringSelector === "$appHosts") hostSet2.$appHosts.forEach(applyRoot);
   else {
     const targetRoot = root === "auto" ? host.shadowRoot || host : root === "shadow" ? host.shadowRoot : host;
     if (targetRoot) {
@@ -17159,20 +18409,20 @@ function createClassDecorator(action) {
           if (resolvedValue !== void 0) {
             const win = this.ownerDocument?.defaultView || window;
             const host = this;
-            const hostSet = { ...SwcUtils.getHelperAndHostSet(win, host), $this: this };
+            const hostSet2 = { ...SwcUtils.getHelperAndHostSet(win, host), $this: this };
             const r = finalOptions.root || "auto";
             const targetEls = getTargetElements(selector, this, win, r);
             targetEls.forEach((targetEl) => {
-              if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: this, helper: hostSet })) {
+              if (finalOptions.filter && !finalOptions.filter(targetEl, resolvedValue, { currentThis: this, helper: hostSet2 })) {
                 return;
               }
-              const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet) : resolvedValue;
+              const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet2) : resolvedValue;
               if (action === "set") {
                 let classes = "";
                 if (classMap && typeof classMap === "string") {
                   classes = resolvedRes ? classMap : "";
                 } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
-                  classes = Object.entries(resolvedRes).filter(([_, force]) => typeof force === "function" ? force(targetEl, hostSet) : !!force).map(([cls2]) => cls2).join(" ");
+                  classes = Object.entries(resolvedRes).filter(([_, force]) => typeof force === "function" ? force(targetEl, hostSet2) : !!force).map(([cls2]) => cls2).join(" ");
                 } else {
                   classes = Array.isArray(resolvedRes) ? resolvedRes.join(" ") : String(resolvedRes);
                 }
@@ -17182,7 +18432,7 @@ function createClassDecorator(action) {
                   targetEl.classList.toggle(classMap, !!resolvedRes);
                 } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
                   Object.entries(resolvedRes).forEach(([cls2, force]) => {
-                    const isActive = typeof force === "function" ? force(targetEl, hostSet) : !!force;
+                    const isActive = typeof force === "function" ? force(targetEl, hostSet2) : !!force;
                     targetEl.classList.toggle(cls2, isActive);
                   });
                 } else {
@@ -17196,7 +18446,7 @@ function createClassDecorator(action) {
                   else targetEl.classList.remove(classMap);
                 } else if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
                   Object.entries(resolvedRes).forEach(([cls2, force]) => {
-                    const shouldExecute = typeof force === "function" ? force(targetEl, hostSet) : !!force;
+                    const shouldExecute = typeof force === "function" ? force(targetEl, hostSet2) : !!force;
                     if (shouldExecute) {
                       if (action === "add") targetEl.classList.add(cls2);
                       else targetEl.classList.remove(cls2);
@@ -17281,11 +18531,17 @@ function toggleClass(selectorOrTarget, classMapOrOptionsOrPropertyKey, optionsOr
   return createClassDecorator("toggle")("$this", selectorOrTarget);
 }
 var cls = applyClass;
-function clsThis(action, options) {
-  return applyClass("$this", action, options);
+function clsThis(actionOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyClass("$this", void 0, {})(actionOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyClass("$this", actionOrTarget, optionsOrPropertyKey);
 }
-function clsAppHost(action, options) {
-  return applyClass("$appHost", action, options);
+function clsAppHost(actionOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyClass("$appHost", void 0, {})(actionOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyClass("$appHost", actionOrTarget, optionsOrPropertyKey);
 }
 function clsLight(selector, actionOrOptions, options) {
   const action = typeof actionOrOptions === "string" ? actionOrOptions : void 0;
@@ -17317,8 +18573,8 @@ var findAllClassMetadata = (target) => {
 var STYLE_METADATA_KEY = Symbol.for("simple-web-component:style");
 var resolveSelector3 = (selector, inst, win) => {
   if (typeof selector === "function") {
-    const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
-    const result = selector(inst, hostSet);
+    const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
+    const result = selector(inst, hostSet2);
     if (result instanceof win.Element) {
       return [result];
     }
@@ -17346,21 +18602,21 @@ var getTargetElements2 = (selector, inst, win, root) => {
   const stringSelector = resolved;
   const targetEls = [];
   const host = inst;
-  const hostSet = SwcUtils.getHelperAndHostSet(win, inst);
+  const hostSet2 = SwcUtils.getHelperAndHostSet(win, inst);
   const applyRoot = (t) => {
     if (!t || !(t instanceof win.HTMLElement)) return;
     targetEls.push(t);
   };
   if (stringSelector === "$this" || !stringSelector) applyRoot(host);
-  else if (stringSelector === "$host") applyRoot(hostSet.$host);
-  else if (stringSelector === "$parentHost") applyRoot(hostSet.$parentHost);
-  else if (stringSelector === "$appHost") applyRoot(hostSet.$appHost);
-  else if (stringSelector === "$firstHost") applyRoot(hostSet.$firstHost);
-  else if (stringSelector === "$lastHost") applyRoot(hostSet.$lastHost);
-  else if (stringSelector === "$firstAppHost") applyRoot(hostSet.$firstAppHost);
-  else if (stringSelector === "$lastAppHost") applyRoot(hostSet.$lastAppHost);
-  else if (stringSelector === "$hosts") hostSet.$hosts.forEach(applyRoot);
-  else if (stringSelector === "$appHosts") hostSet.$appHosts.forEach(applyRoot);
+  else if (stringSelector === "$host") applyRoot(hostSet2.$host);
+  else if (stringSelector === "$parentHost") applyRoot(hostSet2.$parentHost);
+  else if (stringSelector === "$appHost") applyRoot(hostSet2.$appHost);
+  else if (stringSelector === "$firstHost") applyRoot(hostSet2.$firstHost);
+  else if (stringSelector === "$lastHost") applyRoot(hostSet2.$lastHost);
+  else if (stringSelector === "$firstAppHost") applyRoot(hostSet2.$firstAppHost);
+  else if (stringSelector === "$lastAppHost") applyRoot(hostSet2.$lastAppHost);
+  else if (stringSelector === "$hosts") hostSet2.$hosts.forEach(applyRoot);
+  else if (stringSelector === "$appHosts") hostSet2.$appHosts.forEach(applyRoot);
   else {
     const targetRoot = root === "auto" ? host.shadowRoot || host : root === "shadow" ? host.shadowRoot : host;
     if (targetRoot) {
@@ -17395,19 +18651,19 @@ function createStyleDecorator(action) {
           if (resolvedValue !== void 0) {
             const win = this.ownerDocument?.defaultView || window;
             const host = this;
-            const hostSet = { ...SwcUtils.getHelperAndHostSet(win, host), $this: this };
+            const hostSet2 = { ...SwcUtils.getHelperAndHostSet(win, host), $this: this };
             const r = options.root || "auto";
             const targetEls = getTargetElements2(selector, this, win, r);
             targetEls.forEach((targetEl) => {
-              if (options.filter && !options.filter(targetEl, resolvedValue, { currentThis: this, helper: hostSet })) {
+              if (options.filter && !options.filter(targetEl, resolvedValue, { currentThis: this, helper: hostSet2 })) {
                 return;
               }
-              const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet) : resolvedValue;
+              const resolvedRes = typeof resolvedValue === "function" ? resolvedValue(targetEl, hostSet2) : resolvedValue;
               if (action === "set" || action === "update") {
                 if (action === "set") targetEl.style.cssText = "";
                 if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
                   Object.entries(resolvedRes).forEach(([prop2, val]) => {
-                    const finalVal = typeof val === "function" ? val(targetEl, hostSet) : val;
+                    const finalVal = typeof val === "function" ? val(targetEl, hostSet2) : val;
                     if (finalVal === null || finalVal === void 0) {
                       targetEl.style.removeProperty(prop2);
                     } else {
@@ -17420,7 +18676,7 @@ function createStyleDecorator(action) {
               } else if (action === "remove") {
                 if (typeof resolvedRes === "object" && resolvedRes !== null && !Array.isArray(resolvedRes)) {
                   Object.entries(resolvedRes).forEach(([prop2, val]) => {
-                    const shouldRemove = typeof val === "function" ? val(targetEl, hostSet) : !!val;
+                    const shouldRemove = typeof val === "function" ? val(targetEl, hostSet2) : !!val;
                     if (shouldRemove) {
                       targetEl.style.removeProperty(prop2);
                     }
@@ -17485,11 +18741,17 @@ function removeStyle(selectorOrTarget, optionsOrPropertyKey, descriptor) {
   return createStyleDecorator("remove")("$this", selectorOrTarget);
 }
 var style = applyStyle;
-function styleThis(action, options) {
-  return applyStyle("$this", action, options);
+function styleThis(actionOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyStyle("$this", void 0, {})(actionOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyStyle("$this", actionOrTarget, optionsOrPropertyKey);
 }
-function styleAppHost(action, options) {
-  return applyStyle("$appHost", action, options);
+function styleAppHost(actionOrTarget, optionsOrPropertyKey, descriptor) {
+  if ((typeof optionsOrPropertyKey === "string" || typeof optionsOrPropertyKey === "symbol") && descriptor !== void 0) {
+    return applyStyle("$appHost", void 0, {})(actionOrTarget, optionsOrPropertyKey, descriptor);
+  }
+  return applyStyle("$appHost", actionOrTarget, optionsOrPropertyKey);
 }
 function styleLight(selector, actionOrOptions, options) {
   const action = typeof actionOrOptions === "string" ? actionOrOptions : void 0;
@@ -17593,8 +18855,8 @@ var getPublishSwcAppMessageMetadata = (target) => {
 
 // src/decorators/applySlot.ts
 var APPLY_SLOT_METADATA_KEY = Symbol.for("simple-web-component:apply-slot");
-var applyToDom2 = (swcId, id, pos, nodes) => {
-  const nodeSlot = new NodeSlot(void 0, swcId);
+var applyToDom2 = (host, swcId, id, pos, nodes) => {
+  const nodeSlot = new NodeSlot(host, swcId);
   if (pos === "replaceChildrenText" || pos === "replaceChildren" || pos === "replaceChildrenHtml") {
     nodeSlot.replaceChildren(id, ...nodes);
   } else if (pos === "appendHtml" || pos === "append" || pos === "appendText") {
@@ -17618,11 +18880,12 @@ function applySlot(targetId, opt) {
     const original = descriptor.value;
     descriptor.value = function(...args) {
       ensureInit(this);
+      const host = this;
       const conf = getElementConfig(this);
       const currentWin = conf.window;
       const swcId = this._swcId;
       const currentDoc = currentWin.document;
-      const hostSet = SwcUtils.getHelperAndHostSet(currentWin, this);
+      const hostSet2 = SwcUtils.getHelperAndHostSet(currentWin, this);
       const pos = options.position;
       const resToNodes = (res2) => {
         const nodes = [];
@@ -17640,10 +18903,10 @@ function applySlot(targetId, opt) {
       };
       const fallbackNodes = [];
       if (options.fallback) {
-        const res2 = options.fallback.call(this, hostSet);
+        const res2 = options.fallback.call(this, hostSet2);
         const nodes = resToNodes(res2);
         fallbackNodes.push(...nodes);
-        applyToDom2(swcId, targetId, options.position, nodes);
+        applyToDom2(host, swcId, targetId, options.position, nodes);
       }
       const extractValue = (v) => {
         const keyToUse = options.valueKey ?? APPLY_SLOT_METADATA_KEY;
@@ -17658,12 +18921,12 @@ function applySlot(targetId, opt) {
           const extracted = extractValue(asyncRes);
           const nodes = resToNodes(extracted);
           fallbackNodes.forEach((it) => it.remove());
-          applyToDom2(swcId, targetId, options.position, nodes);
+          applyToDom2(host, swcId, targetId, options.position, nodes);
         });
       } else {
         const extracted = extractValue(res);
         const nodes = resToNodes(extracted);
-        applyToDom2(swcId, targetId, options.position, nodes);
+        applyToDom2(host, swcId, targetId, options.position, nodes);
       }
     };
   };
@@ -20501,7 +21764,6 @@ function SwcAppMixin(Base) {
       try {
         const routeChangeSubscribers = getSubscribeSwcAppRouteChangeWhileConnectedMetadata(instance);
         if (routeChangeSubscribers.length > 0) {
-          console.log("[SWC-MIXIN] Route change subscribers found");
           for (const metadata of routeChangeSubscribers) {
             const methodName = metadata.propertyKey;
             let pathPattern = metadata.options?.path;
@@ -20534,10 +21796,19 @@ function SwcAppMixin(Base) {
               pathData = SwcUtils.parsePathPattern(pathPattern, re.path || "/");
               pathMatched = pathData !== null;
             }
-            const hostSet = SwcUtils.getHelperAndHostSet(this.config.window, this);
-            const filterPassed = !filter || filter(this.router, { helper: hostSet, currentThis: instance });
+            const hostSet2 = SwcUtils.getHelperAndHostSet(this.config.window, this);
+            const filterPassed = !filter || filter(this.router, { helper: hostSet2, currentThis: instance });
             if (pathMatched && filterPassed && instance[methodName]) {
-              const result = extractValue(await instance[methodName]({ ...re, pathData }));
+              const routeEventValue = { ...re, pathData };
+              const instanceHelperHostSet = SwcUtils.getHelperAndHostSet(this.config.window, instance);
+              const instanceHelperSet = SwcUtils.getHelperSet(this.config.window);
+              const args = buildSwcParameterArgs(instance, methodName, {
+                routerEvent: routeEventValue,
+                hostSet: instanceHelperHostSet,
+                helperHostSet: instanceHelperHostSet,
+                helperSet: instanceHelperSet
+              }, [routeEventValue]);
+              const result = extractValue(await instance[methodName](...args));
               if (result !== void 0 && result !== null) {
                 break;
               }
@@ -20716,7 +21987,15 @@ function SwcAppMixin(Base) {
             filterMatched = filter(message, instance);
           }
           if (typeMatched && filterMatched && typeof instance[methodName] === "function") {
-            instance[methodName](message);
+            const instanceHelperHostSet = SwcUtils.getHelperAndHostSet(this.config.window, instance);
+            const instanceHelperSet = SwcUtils.getHelperSet(this.config.window);
+            const args = buildSwcParameterArgs(instance, methodName, {
+              appMessage: message,
+              hostSet: instanceHelperHostSet,
+              helperHostSet: instanceHelperHostSet,
+              helperSet: instanceHelperSet
+            }, [message]);
+            instance[methodName](...args);
           }
         });
       }
@@ -20911,8 +22190,10 @@ export {
   DOM_EVENT_NAMES,
   ELEMENT_CONFIG_KEY,
   EMIT_CUSTOM_EVENT_METADATA_KEY,
+  EVENT_MEDIA_METADATA_KEY,
   EmitCustomEventLifeCycler,
   EventListenerLifeCycler,
+  EventMediaLifeCycler,
   HTML_TAG_ENTRIES,
   INTERSECTION_OBSERVER_METADATA_KEY,
   InjectSituationType2 as InjectSituationType,
@@ -20936,7 +22217,9 @@ export {
   PUBLISH_SWC_APP_MESSAGE_METADATA_KEY,
   QUERY_ALL_METADATA_KEY,
   QUERY_METADATA_KEY,
+  REQUEST_ANIMATION_FRAME_METADATA_KEY,
   RESIZE_OBSERVER_METADATA_KEY,
+  RequestAnimationFrameLifeCycler,
   ResizeObserverLifeCycler,
   RouteSubscribeLifeCycler,
   SET_INTERVAL_METADATA_KEY,
@@ -20979,6 +22262,7 @@ export {
   addEventListenerShadow,
   addEventListenerThis,
   addEventListenerWindow,
+  appMessage,
   appendHtmlSlot,
   appendSlot,
   appendTextSlot,
@@ -21002,6 +22286,7 @@ export {
   attrShadow,
   attrThis,
   attribute,
+  buildSwcParameterArgs,
   callProperty,
   callPropertyAll,
   callPropertyLight,
@@ -21046,19 +22331,966 @@ export {
   ensureInit,
   event,
   eventAll,
+  eventAnimationcancel,
+  eventAnimationcancelAll,
+  eventAnimationcancelAppHost,
+  eventAnimationcancelDelegate,
+  eventAnimationcancelDelegateAll,
+  eventAnimationcancelDelegateLight,
+  eventAnimationcancelDelegateShadow,
+  eventAnimationcancelDocument,
+  eventAnimationcancelLight,
+  eventAnimationcancelMutation,
+  eventAnimationcancelMutationAll,
+  eventAnimationcancelMutationLight,
+  eventAnimationcancelMutationShadow,
+  eventAnimationcancelShadow,
+  eventAnimationcancelThis,
+  eventAnimationcancelWindow,
+  eventAnimationend,
+  eventAnimationendAll,
+  eventAnimationendAppHost,
+  eventAnimationendDelegate,
+  eventAnimationendDelegateAll,
+  eventAnimationendDelegateLight,
+  eventAnimationendDelegateShadow,
+  eventAnimationendDocument,
+  eventAnimationendLight,
+  eventAnimationendMutation,
+  eventAnimationendMutationAll,
+  eventAnimationendMutationLight,
+  eventAnimationendMutationShadow,
+  eventAnimationendShadow,
+  eventAnimationendThis,
+  eventAnimationendWindow,
+  eventAnimationiteration,
+  eventAnimationiterationAll,
+  eventAnimationiterationAppHost,
+  eventAnimationiterationDelegate,
+  eventAnimationiterationDelegateAll,
+  eventAnimationiterationDelegateLight,
+  eventAnimationiterationDelegateShadow,
+  eventAnimationiterationDocument,
+  eventAnimationiterationLight,
+  eventAnimationiterationMutation,
+  eventAnimationiterationMutationAll,
+  eventAnimationiterationMutationLight,
+  eventAnimationiterationMutationShadow,
+  eventAnimationiterationShadow,
+  eventAnimationiterationThis,
+  eventAnimationiterationWindow,
+  eventAnimationstart,
+  eventAnimationstartAll,
+  eventAnimationstartAppHost,
+  eventAnimationstartDelegate,
+  eventAnimationstartDelegateAll,
+  eventAnimationstartDelegateLight,
+  eventAnimationstartDelegateShadow,
+  eventAnimationstartDocument,
+  eventAnimationstartLight,
+  eventAnimationstartMutation,
+  eventAnimationstartMutationAll,
+  eventAnimationstartMutationLight,
+  eventAnimationstartMutationShadow,
+  eventAnimationstartShadow,
+  eventAnimationstartThis,
+  eventAnimationstartWindow,
   eventAppHost,
+  eventBlur,
+  eventBlurAll,
+  eventBlurAppHost,
+  eventBlurDelegate,
+  eventBlurDelegateAll,
+  eventBlurDelegateLight,
+  eventBlurDelegateShadow,
+  eventBlurDocument,
+  eventBlurLight,
+  eventBlurMutation,
+  eventBlurMutationAll,
+  eventBlurMutationLight,
+  eventBlurMutationShadow,
+  eventBlurShadow,
+  eventBlurThis,
+  eventBlurWindow,
+  eventChange,
+  eventChangeAll,
+  eventChangeAppHost,
+  eventChangeDelegate,
+  eventChangeDelegateAll,
+  eventChangeDelegateLight,
+  eventChangeDelegateShadow,
+  eventChangeDocument,
+  eventChangeLight,
+  eventChangeMutation,
+  eventChangeMutationAll,
+  eventChangeMutationLight,
+  eventChangeMutationShadow,
+  eventChangeShadow,
+  eventChangeThis,
+  eventChangeWindow,
+  eventClick,
+  eventClickAll,
+  eventClickAppHost,
+  eventClickDelegate,
+  eventClickDelegateAll,
+  eventClickDelegateLight,
+  eventClickDelegateShadow,
+  eventClickDocument,
+  eventClickLight,
+  eventClickMutation,
+  eventClickMutationAll,
+  eventClickMutationLight,
+  eventClickMutationShadow,
+  eventClickShadow,
+  eventClickThis,
+  eventClickWindow,
+  eventContextmenu,
+  eventContextmenuAll,
+  eventContextmenuAppHost,
+  eventContextmenuDelegate,
+  eventContextmenuDelegateAll,
+  eventContextmenuDelegateLight,
+  eventContextmenuDelegateShadow,
+  eventContextmenuDocument,
+  eventContextmenuLight,
+  eventContextmenuMutation,
+  eventContextmenuMutationAll,
+  eventContextmenuMutationLight,
+  eventContextmenuMutationShadow,
+  eventContextmenuShadow,
+  eventContextmenuThis,
+  eventContextmenuWindow,
+  eventCopy,
+  eventCopyAll,
+  eventCopyAppHost,
+  eventCopyDelegate,
+  eventCopyDelegateAll,
+  eventCopyDelegateLight,
+  eventCopyDelegateShadow,
+  eventCopyDocument,
+  eventCopyLight,
+  eventCopyMutation,
+  eventCopyMutationAll,
+  eventCopyMutationLight,
+  eventCopyMutationShadow,
+  eventCopyShadow,
+  eventCopyThis,
+  eventCopyWindow,
+  eventCut,
+  eventCutAll,
+  eventCutAppHost,
+  eventCutDelegate,
+  eventCutDelegateAll,
+  eventCutDelegateLight,
+  eventCutDelegateShadow,
+  eventCutDocument,
+  eventCutLight,
+  eventCutMutation,
+  eventCutMutationAll,
+  eventCutMutationLight,
+  eventCutMutationShadow,
+  eventCutShadow,
+  eventCutThis,
+  eventCutWindow,
+  eventDblclick,
+  eventDblclickAll,
+  eventDblclickAppHost,
+  eventDblclickDelegate,
+  eventDblclickDelegateAll,
+  eventDblclickDelegateLight,
+  eventDblclickDelegateShadow,
+  eventDblclickDocument,
+  eventDblclickLight,
+  eventDblclickMutation,
+  eventDblclickMutationAll,
+  eventDblclickMutationLight,
+  eventDblclickMutationShadow,
+  eventDblclickShadow,
+  eventDblclickThis,
+  eventDblclickWindow,
   eventDelegate,
   eventDelegateAll,
   eventDelegateLight,
   eventDelegateShadow,
   eventDocument,
+  eventDrag,
+  eventDragAll,
+  eventDragAppHost,
+  eventDragDelegate,
+  eventDragDelegateAll,
+  eventDragDelegateLight,
+  eventDragDelegateShadow,
+  eventDragDocument,
+  eventDragLight,
+  eventDragMutation,
+  eventDragMutationAll,
+  eventDragMutationLight,
+  eventDragMutationShadow,
+  eventDragShadow,
+  eventDragThis,
+  eventDragWindow,
+  eventDragend,
+  eventDragendAll,
+  eventDragendAppHost,
+  eventDragendDelegate,
+  eventDragendDelegateAll,
+  eventDragendDelegateLight,
+  eventDragendDelegateShadow,
+  eventDragendDocument,
+  eventDragendLight,
+  eventDragendMutation,
+  eventDragendMutationAll,
+  eventDragendMutationLight,
+  eventDragendMutationShadow,
+  eventDragendShadow,
+  eventDragendThis,
+  eventDragendWindow,
+  eventDragenter,
+  eventDragenterAll,
+  eventDragenterAppHost,
+  eventDragenterDelegate,
+  eventDragenterDelegateAll,
+  eventDragenterDelegateLight,
+  eventDragenterDelegateShadow,
+  eventDragenterDocument,
+  eventDragenterLight,
+  eventDragenterMutation,
+  eventDragenterMutationAll,
+  eventDragenterMutationLight,
+  eventDragenterMutationShadow,
+  eventDragenterShadow,
+  eventDragenterThis,
+  eventDragenterWindow,
+  eventDragleave,
+  eventDragleaveAll,
+  eventDragleaveAppHost,
+  eventDragleaveDelegate,
+  eventDragleaveDelegateAll,
+  eventDragleaveDelegateLight,
+  eventDragleaveDelegateShadow,
+  eventDragleaveDocument,
+  eventDragleaveLight,
+  eventDragleaveMutation,
+  eventDragleaveMutationAll,
+  eventDragleaveMutationLight,
+  eventDragleaveMutationShadow,
+  eventDragleaveShadow,
+  eventDragleaveThis,
+  eventDragleaveWindow,
+  eventDragover,
+  eventDragoverAll,
+  eventDragoverAppHost,
+  eventDragoverDelegate,
+  eventDragoverDelegateAll,
+  eventDragoverDelegateLight,
+  eventDragoverDelegateShadow,
+  eventDragoverDocument,
+  eventDragoverLight,
+  eventDragoverMutation,
+  eventDragoverMutationAll,
+  eventDragoverMutationLight,
+  eventDragoverMutationShadow,
+  eventDragoverShadow,
+  eventDragoverThis,
+  eventDragoverWindow,
+  eventDragstart,
+  eventDragstartAll,
+  eventDragstartAppHost,
+  eventDragstartDelegate,
+  eventDragstartDelegateAll,
+  eventDragstartDelegateLight,
+  eventDragstartDelegateShadow,
+  eventDragstartDocument,
+  eventDragstartLight,
+  eventDragstartMutation,
+  eventDragstartMutationAll,
+  eventDragstartMutationLight,
+  eventDragstartMutationShadow,
+  eventDragstartShadow,
+  eventDragstartThis,
+  eventDragstartWindow,
+  eventDrop,
+  eventDropAll,
+  eventDropAppHost,
+  eventDropDelegate,
+  eventDropDelegateAll,
+  eventDropDelegateLight,
+  eventDropDelegateShadow,
+  eventDropDocument,
+  eventDropLight,
+  eventDropMutation,
+  eventDropMutationAll,
+  eventDropMutationLight,
+  eventDropMutationShadow,
+  eventDropShadow,
+  eventDropThis,
+  eventDropWindow,
+  eventError,
+  eventErrorAll,
+  eventErrorAppHost,
+  eventErrorDelegate,
+  eventErrorDelegateAll,
+  eventErrorDelegateLight,
+  eventErrorDelegateShadow,
+  eventErrorDocument,
+  eventErrorLight,
+  eventErrorMutation,
+  eventErrorMutationAll,
+  eventErrorMutationLight,
+  eventErrorMutationShadow,
+  eventErrorShadow,
+  eventErrorThis,
+  eventErrorWindow,
+  eventFocus,
+  eventFocusAll,
+  eventFocusAppHost,
+  eventFocusDelegate,
+  eventFocusDelegateAll,
+  eventFocusDelegateLight,
+  eventFocusDelegateShadow,
+  eventFocusDocument,
+  eventFocusLight,
+  eventFocusMutation,
+  eventFocusMutationAll,
+  eventFocusMutationLight,
+  eventFocusMutationShadow,
+  eventFocusShadow,
+  eventFocusThis,
+  eventFocusWindow,
+  eventFocusin,
+  eventFocusinAll,
+  eventFocusinAppHost,
+  eventFocusinDelegate,
+  eventFocusinDelegateAll,
+  eventFocusinDelegateLight,
+  eventFocusinDelegateShadow,
+  eventFocusinDocument,
+  eventFocusinLight,
+  eventFocusinMutation,
+  eventFocusinMutationAll,
+  eventFocusinMutationLight,
+  eventFocusinMutationShadow,
+  eventFocusinShadow,
+  eventFocusinThis,
+  eventFocusinWindow,
+  eventFocusout,
+  eventFocusoutAll,
+  eventFocusoutAppHost,
+  eventFocusoutDelegate,
+  eventFocusoutDelegateAll,
+  eventFocusoutDelegateLight,
+  eventFocusoutDelegateShadow,
+  eventFocusoutDocument,
+  eventFocusoutLight,
+  eventFocusoutMutation,
+  eventFocusoutMutationAll,
+  eventFocusoutMutationLight,
+  eventFocusoutMutationShadow,
+  eventFocusoutShadow,
+  eventFocusoutThis,
+  eventFocusoutWindow,
+  eventInput,
+  eventInputAll,
+  eventInputAppHost,
+  eventInputDelegate,
+  eventInputDelegateAll,
+  eventInputDelegateLight,
+  eventInputDelegateShadow,
+  eventInputDocument,
+  eventInputLight,
+  eventInputMutation,
+  eventInputMutationAll,
+  eventInputMutationLight,
+  eventInputMutationShadow,
+  eventInputShadow,
+  eventInputThis,
+  eventInputWindow,
+  eventInvalid,
+  eventInvalidAll,
+  eventInvalidAppHost,
+  eventInvalidDelegate,
+  eventInvalidDelegateAll,
+  eventInvalidDelegateLight,
+  eventInvalidDelegateShadow,
+  eventInvalidDocument,
+  eventInvalidLight,
+  eventInvalidMutation,
+  eventInvalidMutationAll,
+  eventInvalidMutationLight,
+  eventInvalidMutationShadow,
+  eventInvalidShadow,
+  eventInvalidThis,
+  eventInvalidWindow,
+  eventKeydown,
+  eventKeydownAll,
+  eventKeydownAppHost,
+  eventKeydownDelegate,
+  eventKeydownDelegateAll,
+  eventKeydownDelegateLight,
+  eventKeydownDelegateShadow,
+  eventKeydownDocument,
+  eventKeydownLight,
+  eventKeydownMutation,
+  eventKeydownMutationAll,
+  eventKeydownMutationLight,
+  eventKeydownMutationShadow,
+  eventKeydownShadow,
+  eventKeydownThis,
+  eventKeydownWindow,
+  eventKeypress,
+  eventKeypressAll,
+  eventKeypressAppHost,
+  eventKeypressDelegate,
+  eventKeypressDelegateAll,
+  eventKeypressDelegateLight,
+  eventKeypressDelegateShadow,
+  eventKeypressDocument,
+  eventKeypressLight,
+  eventKeypressMutation,
+  eventKeypressMutationAll,
+  eventKeypressMutationLight,
+  eventKeypressMutationShadow,
+  eventKeypressShadow,
+  eventKeypressThis,
+  eventKeypressWindow,
+  eventKeyup,
+  eventKeyupAll,
+  eventKeyupAppHost,
+  eventKeyupDelegate,
+  eventKeyupDelegateAll,
+  eventKeyupDelegateLight,
+  eventKeyupDelegateShadow,
+  eventKeyupDocument,
+  eventKeyupLight,
+  eventKeyupMutation,
+  eventKeyupMutationAll,
+  eventKeyupMutationLight,
+  eventKeyupMutationShadow,
+  eventKeyupShadow,
+  eventKeyupThis,
+  eventKeyupWindow,
   eventLight,
+  eventLoad,
+  eventLoadAll,
+  eventLoadAppHost,
+  eventLoadDelegate,
+  eventLoadDelegateAll,
+  eventLoadDelegateLight,
+  eventLoadDelegateShadow,
+  eventLoadDocument,
+  eventLoadLight,
+  eventLoadMutation,
+  eventLoadMutationAll,
+  eventLoadMutationLight,
+  eventLoadMutationShadow,
+  eventLoadShadow,
+  eventLoadThis,
+  eventLoadWindow,
+  eventMedia,
+  eventMediaChange,
+  eventMousedown,
+  eventMousedownAll,
+  eventMousedownAppHost,
+  eventMousedownDelegate,
+  eventMousedownDelegateAll,
+  eventMousedownDelegateLight,
+  eventMousedownDelegateShadow,
+  eventMousedownDocument,
+  eventMousedownLight,
+  eventMousedownMutation,
+  eventMousedownMutationAll,
+  eventMousedownMutationLight,
+  eventMousedownMutationShadow,
+  eventMousedownShadow,
+  eventMousedownThis,
+  eventMousedownWindow,
+  eventMouseenter,
+  eventMouseenterAll,
+  eventMouseenterAppHost,
+  eventMouseenterDelegate,
+  eventMouseenterDelegateAll,
+  eventMouseenterDelegateLight,
+  eventMouseenterDelegateShadow,
+  eventMouseenterDocument,
+  eventMouseenterLight,
+  eventMouseenterMutation,
+  eventMouseenterMutationAll,
+  eventMouseenterMutationLight,
+  eventMouseenterMutationShadow,
+  eventMouseenterShadow,
+  eventMouseenterThis,
+  eventMouseenterWindow,
+  eventMouseleave,
+  eventMouseleaveAll,
+  eventMouseleaveAppHost,
+  eventMouseleaveDelegate,
+  eventMouseleaveDelegateAll,
+  eventMouseleaveDelegateLight,
+  eventMouseleaveDelegateShadow,
+  eventMouseleaveDocument,
+  eventMouseleaveLight,
+  eventMouseleaveMutation,
+  eventMouseleaveMutationAll,
+  eventMouseleaveMutationLight,
+  eventMouseleaveMutationShadow,
+  eventMouseleaveShadow,
+  eventMouseleaveThis,
+  eventMouseleaveWindow,
+  eventMousemove,
+  eventMousemoveAll,
+  eventMousemoveAppHost,
+  eventMousemoveDelegate,
+  eventMousemoveDelegateAll,
+  eventMousemoveDelegateLight,
+  eventMousemoveDelegateShadow,
+  eventMousemoveDocument,
+  eventMousemoveLight,
+  eventMousemoveMutation,
+  eventMousemoveMutationAll,
+  eventMousemoveMutationLight,
+  eventMousemoveMutationShadow,
+  eventMousemoveShadow,
+  eventMousemoveThis,
+  eventMousemoveWindow,
+  eventMouseout,
+  eventMouseoutAll,
+  eventMouseoutAppHost,
+  eventMouseoutDelegate,
+  eventMouseoutDelegateAll,
+  eventMouseoutDelegateLight,
+  eventMouseoutDelegateShadow,
+  eventMouseoutDocument,
+  eventMouseoutLight,
+  eventMouseoutMutation,
+  eventMouseoutMutationAll,
+  eventMouseoutMutationLight,
+  eventMouseoutMutationShadow,
+  eventMouseoutShadow,
+  eventMouseoutThis,
+  eventMouseoutWindow,
+  eventMouseover,
+  eventMouseoverAll,
+  eventMouseoverAppHost,
+  eventMouseoverDelegate,
+  eventMouseoverDelegateAll,
+  eventMouseoverDelegateLight,
+  eventMouseoverDelegateShadow,
+  eventMouseoverDocument,
+  eventMouseoverLight,
+  eventMouseoverMutation,
+  eventMouseoverMutationAll,
+  eventMouseoverMutationLight,
+  eventMouseoverMutationShadow,
+  eventMouseoverShadow,
+  eventMouseoverThis,
+  eventMouseoverWindow,
+  eventMouseup,
+  eventMouseupAll,
+  eventMouseupAppHost,
+  eventMouseupDelegate,
+  eventMouseupDelegateAll,
+  eventMouseupDelegateLight,
+  eventMouseupDelegateShadow,
+  eventMouseupDocument,
+  eventMouseupLight,
+  eventMouseupMutation,
+  eventMouseupMutationAll,
+  eventMouseupMutationLight,
+  eventMouseupMutationShadow,
+  eventMouseupShadow,
+  eventMouseupThis,
+  eventMouseupWindow,
   eventMutation,
   eventMutationAll,
   eventMutationLight,
   eventMutationShadow,
+  eventObject,
+  eventPaste,
+  eventPasteAll,
+  eventPasteAppHost,
+  eventPasteDelegate,
+  eventPasteDelegateAll,
+  eventPasteDelegateLight,
+  eventPasteDelegateShadow,
+  eventPasteDocument,
+  eventPasteLight,
+  eventPasteMutation,
+  eventPasteMutationAll,
+  eventPasteMutationLight,
+  eventPasteMutationShadow,
+  eventPasteShadow,
+  eventPasteThis,
+  eventPasteWindow,
+  eventPointercancel,
+  eventPointercancelAll,
+  eventPointercancelAppHost,
+  eventPointercancelDelegate,
+  eventPointercancelDelegateAll,
+  eventPointercancelDelegateLight,
+  eventPointercancelDelegateShadow,
+  eventPointercancelDocument,
+  eventPointercancelLight,
+  eventPointercancelMutation,
+  eventPointercancelMutationAll,
+  eventPointercancelMutationLight,
+  eventPointercancelMutationShadow,
+  eventPointercancelShadow,
+  eventPointercancelThis,
+  eventPointercancelWindow,
+  eventPointerdown,
+  eventPointerdownAll,
+  eventPointerdownAppHost,
+  eventPointerdownDelegate,
+  eventPointerdownDelegateAll,
+  eventPointerdownDelegateLight,
+  eventPointerdownDelegateShadow,
+  eventPointerdownDocument,
+  eventPointerdownLight,
+  eventPointerdownMutation,
+  eventPointerdownMutationAll,
+  eventPointerdownMutationLight,
+  eventPointerdownMutationShadow,
+  eventPointerdownShadow,
+  eventPointerdownThis,
+  eventPointerdownWindow,
+  eventPointerenter,
+  eventPointerenterAll,
+  eventPointerenterAppHost,
+  eventPointerenterDelegate,
+  eventPointerenterDelegateAll,
+  eventPointerenterDelegateLight,
+  eventPointerenterDelegateShadow,
+  eventPointerenterDocument,
+  eventPointerenterLight,
+  eventPointerenterMutation,
+  eventPointerenterMutationAll,
+  eventPointerenterMutationLight,
+  eventPointerenterMutationShadow,
+  eventPointerenterShadow,
+  eventPointerenterThis,
+  eventPointerenterWindow,
+  eventPointerleave,
+  eventPointerleaveAll,
+  eventPointerleaveAppHost,
+  eventPointerleaveDelegate,
+  eventPointerleaveDelegateAll,
+  eventPointerleaveDelegateLight,
+  eventPointerleaveDelegateShadow,
+  eventPointerleaveDocument,
+  eventPointerleaveLight,
+  eventPointerleaveMutation,
+  eventPointerleaveMutationAll,
+  eventPointerleaveMutationLight,
+  eventPointerleaveMutationShadow,
+  eventPointerleaveShadow,
+  eventPointerleaveThis,
+  eventPointerleaveWindow,
+  eventPointermove,
+  eventPointermoveAll,
+  eventPointermoveAppHost,
+  eventPointermoveDelegate,
+  eventPointermoveDelegateAll,
+  eventPointermoveDelegateLight,
+  eventPointermoveDelegateShadow,
+  eventPointermoveDocument,
+  eventPointermoveLight,
+  eventPointermoveMutation,
+  eventPointermoveMutationAll,
+  eventPointermoveMutationLight,
+  eventPointermoveMutationShadow,
+  eventPointermoveShadow,
+  eventPointermoveThis,
+  eventPointermoveWindow,
+  eventPointerout,
+  eventPointeroutAll,
+  eventPointeroutAppHost,
+  eventPointeroutDelegate,
+  eventPointeroutDelegateAll,
+  eventPointeroutDelegateLight,
+  eventPointeroutDelegateShadow,
+  eventPointeroutDocument,
+  eventPointeroutLight,
+  eventPointeroutMutation,
+  eventPointeroutMutationAll,
+  eventPointeroutMutationLight,
+  eventPointeroutMutationShadow,
+  eventPointeroutShadow,
+  eventPointeroutThis,
+  eventPointeroutWindow,
+  eventPointerover,
+  eventPointeroverAll,
+  eventPointeroverAppHost,
+  eventPointeroverDelegate,
+  eventPointeroverDelegateAll,
+  eventPointeroverDelegateLight,
+  eventPointeroverDelegateShadow,
+  eventPointeroverDocument,
+  eventPointeroverLight,
+  eventPointeroverMutation,
+  eventPointeroverMutationAll,
+  eventPointeroverMutationLight,
+  eventPointeroverMutationShadow,
+  eventPointeroverShadow,
+  eventPointeroverThis,
+  eventPointeroverWindow,
+  eventPointerup,
+  eventPointerupAll,
+  eventPointerupAppHost,
+  eventPointerupDelegate,
+  eventPointerupDelegateAll,
+  eventPointerupDelegateLight,
+  eventPointerupDelegateShadow,
+  eventPointerupDocument,
+  eventPointerupLight,
+  eventPointerupMutation,
+  eventPointerupMutationAll,
+  eventPointerupMutationLight,
+  eventPointerupMutationShadow,
+  eventPointerupShadow,
+  eventPointerupThis,
+  eventPointerupWindow,
+  eventReset,
+  eventResetAll,
+  eventResetAppHost,
+  eventResetDelegate,
+  eventResetDelegateAll,
+  eventResetDelegateLight,
+  eventResetDelegateShadow,
+  eventResetDocument,
+  eventResetLight,
+  eventResetMutation,
+  eventResetMutationAll,
+  eventResetMutationLight,
+  eventResetMutationShadow,
+  eventResetShadow,
+  eventResetThis,
+  eventResetWindow,
+  eventResize,
+  eventResizeAll,
+  eventResizeAppHost,
+  eventResizeDelegate,
+  eventResizeDelegateAll,
+  eventResizeDelegateLight,
+  eventResizeDelegateShadow,
+  eventResizeDocument,
+  eventResizeLight,
+  eventResizeMutation,
+  eventResizeMutationAll,
+  eventResizeMutationLight,
+  eventResizeMutationShadow,
+  eventResizeShadow,
+  eventResizeThis,
+  eventResizeWindow,
+  eventScroll,
+  eventScrollAll,
+  eventScrollAppHost,
+  eventScrollDelegate,
+  eventScrollDelegateAll,
+  eventScrollDelegateLight,
+  eventScrollDelegateShadow,
+  eventScrollDocument,
+  eventScrollLight,
+  eventScrollMutation,
+  eventScrollMutationAll,
+  eventScrollMutationLight,
+  eventScrollMutationShadow,
+  eventScrollShadow,
+  eventScrollThis,
+  eventScrollWindow,
+  eventSelect,
+  eventSelectAll,
+  eventSelectAppHost,
+  eventSelectDelegate,
+  eventSelectDelegateAll,
+  eventSelectDelegateLight,
+  eventSelectDelegateShadow,
+  eventSelectDocument,
+  eventSelectLight,
+  eventSelectMutation,
+  eventSelectMutationAll,
+  eventSelectMutationLight,
+  eventSelectMutationShadow,
+  eventSelectShadow,
+  eventSelectThis,
+  eventSelectWindow,
   eventShadow,
+  eventSubmit,
+  eventSubmitAll,
+  eventSubmitAppHost,
+  eventSubmitDelegate,
+  eventSubmitDelegateAll,
+  eventSubmitDelegateLight,
+  eventSubmitDelegateShadow,
+  eventSubmitDocument,
+  eventSubmitLight,
+  eventSubmitMutation,
+  eventSubmitMutationAll,
+  eventSubmitMutationLight,
+  eventSubmitMutationShadow,
+  eventSubmitShadow,
+  eventSubmitThis,
+  eventSubmitWindow,
   eventThis,
+  eventToggle,
+  eventToggleAll,
+  eventToggleAppHost,
+  eventToggleDelegate,
+  eventToggleDelegateAll,
+  eventToggleDelegateLight,
+  eventToggleDelegateShadow,
+  eventToggleDocument,
+  eventToggleLight,
+  eventToggleMutation,
+  eventToggleMutationAll,
+  eventToggleMutationLight,
+  eventToggleMutationShadow,
+  eventToggleShadow,
+  eventToggleThis,
+  eventToggleWindow,
+  eventTouchcancel,
+  eventTouchcancelAll,
+  eventTouchcancelAppHost,
+  eventTouchcancelDelegate,
+  eventTouchcancelDelegateAll,
+  eventTouchcancelDelegateLight,
+  eventTouchcancelDelegateShadow,
+  eventTouchcancelDocument,
+  eventTouchcancelLight,
+  eventTouchcancelMutation,
+  eventTouchcancelMutationAll,
+  eventTouchcancelMutationLight,
+  eventTouchcancelMutationShadow,
+  eventTouchcancelShadow,
+  eventTouchcancelThis,
+  eventTouchcancelWindow,
+  eventTouchend,
+  eventTouchendAll,
+  eventTouchendAppHost,
+  eventTouchendDelegate,
+  eventTouchendDelegateAll,
+  eventTouchendDelegateLight,
+  eventTouchendDelegateShadow,
+  eventTouchendDocument,
+  eventTouchendLight,
+  eventTouchendMutation,
+  eventTouchendMutationAll,
+  eventTouchendMutationLight,
+  eventTouchendMutationShadow,
+  eventTouchendShadow,
+  eventTouchendThis,
+  eventTouchendWindow,
+  eventTouchmove,
+  eventTouchmoveAll,
+  eventTouchmoveAppHost,
+  eventTouchmoveDelegate,
+  eventTouchmoveDelegateAll,
+  eventTouchmoveDelegateLight,
+  eventTouchmoveDelegateShadow,
+  eventTouchmoveDocument,
+  eventTouchmoveLight,
+  eventTouchmoveMutation,
+  eventTouchmoveMutationAll,
+  eventTouchmoveMutationLight,
+  eventTouchmoveMutationShadow,
+  eventTouchmoveShadow,
+  eventTouchmoveThis,
+  eventTouchmoveWindow,
+  eventTouchstart,
+  eventTouchstartAll,
+  eventTouchstartAppHost,
+  eventTouchstartDelegate,
+  eventTouchstartDelegateAll,
+  eventTouchstartDelegateLight,
+  eventTouchstartDelegateShadow,
+  eventTouchstartDocument,
+  eventTouchstartLight,
+  eventTouchstartMutation,
+  eventTouchstartMutationAll,
+  eventTouchstartMutationLight,
+  eventTouchstartMutationShadow,
+  eventTouchstartShadow,
+  eventTouchstartThis,
+  eventTouchstartWindow,
+  eventTransitioncancel,
+  eventTransitioncancelAll,
+  eventTransitioncancelAppHost,
+  eventTransitioncancelDelegate,
+  eventTransitioncancelDelegateAll,
+  eventTransitioncancelDelegateLight,
+  eventTransitioncancelDelegateShadow,
+  eventTransitioncancelDocument,
+  eventTransitioncancelLight,
+  eventTransitioncancelMutation,
+  eventTransitioncancelMutationAll,
+  eventTransitioncancelMutationLight,
+  eventTransitioncancelMutationShadow,
+  eventTransitioncancelShadow,
+  eventTransitioncancelThis,
+  eventTransitioncancelWindow,
+  eventTransitionend,
+  eventTransitionendAll,
+  eventTransitionendAppHost,
+  eventTransitionendDelegate,
+  eventTransitionendDelegateAll,
+  eventTransitionendDelegateLight,
+  eventTransitionendDelegateShadow,
+  eventTransitionendDocument,
+  eventTransitionendLight,
+  eventTransitionendMutation,
+  eventTransitionendMutationAll,
+  eventTransitionendMutationLight,
+  eventTransitionendMutationShadow,
+  eventTransitionendShadow,
+  eventTransitionendThis,
+  eventTransitionendWindow,
+  eventTransitionrun,
+  eventTransitionrunAll,
+  eventTransitionrunAppHost,
+  eventTransitionrunDelegate,
+  eventTransitionrunDelegateAll,
+  eventTransitionrunDelegateLight,
+  eventTransitionrunDelegateShadow,
+  eventTransitionrunDocument,
+  eventTransitionrunLight,
+  eventTransitionrunMutation,
+  eventTransitionrunMutationAll,
+  eventTransitionrunMutationLight,
+  eventTransitionrunMutationShadow,
+  eventTransitionrunShadow,
+  eventTransitionrunThis,
+  eventTransitionrunWindow,
+  eventTransitionstart,
+  eventTransitionstartAll,
+  eventTransitionstartAppHost,
+  eventTransitionstartDelegate,
+  eventTransitionstartDelegateAll,
+  eventTransitionstartDelegateLight,
+  eventTransitionstartDelegateShadow,
+  eventTransitionstartDocument,
+  eventTransitionstartLight,
+  eventTransitionstartMutation,
+  eventTransitionstartMutationAll,
+  eventTransitionstartMutationLight,
+  eventTransitionstartMutationShadow,
+  eventTransitionstartShadow,
+  eventTransitionstartThis,
+  eventTransitionstartWindow,
+  eventWheel,
+  eventWheelAll,
+  eventWheelAppHost,
+  eventWheelDelegate,
+  eventWheelDelegateAll,
+  eventWheelDelegateLight,
+  eventWheelDelegateShadow,
+  eventWheelDocument,
+  eventWheelLight,
+  eventWheelMutation,
+  eventWheelMutationAll,
+  eventWheelMutationLight,
+  eventWheelMutationShadow,
+  eventWheelShadow,
+  eventWheelThis,
+  eventWheelWindow,
   eventWindow,
   findAllApplyNodeMetadata,
   findAllApplySlotMetadata,
@@ -21066,12 +23298,14 @@ export {
   findAllAttributeChangedMetadata,
   findAllAttributeMetadata,
   findAllClassMetadata,
+  findAllEventMediaMetadata,
   findAllLifecycleMetadata,
   findAllOnConnectedAfterMetadata,
   findAllOnConnectedBeforeMetadata,
   findAllOnConnectedMetadata,
   findAllPropertyApplyMetadata,
   findAllPropertyMetadata,
+  findAllRequestAnimationFrameMetadata,
   findAllSetIntervalMetadata,
   findAllSetTimeoutMetadata,
   findAllStateMetadata,
@@ -21083,12 +23317,16 @@ export {
   getEmitCustomEventMetadataList,
   getIntersectionObserverMetadata,
   getMutationObserverMetadata,
+  getParameterMetadata,
   getPublishSwcAppMessageMetadata,
   getQueryAllMetadata,
   getQueryMetadata,
   getResizeObserverMetadata,
   getSubscribeSwcAppMessageWhileConnectedMetadata,
   getSubscribeSwcAppRouteChangeWhileConnectedMetadata,
+  helperHostSet,
+  helperSet,
+  hostSet,
   html,
   htmlAElement,
   htmlArticleElement,
@@ -21122,6 +23360,8 @@ export {
   intersectionObserverShadow,
   intersectionObserverThis,
   isSSR,
+  makeTypedEventAliases,
+  matchedElement,
   mutationObserver,
   mutationObserverAll,
   mutationObserverDelegate,
@@ -21182,6 +23422,7 @@ export {
   replaceChildrenLight,
   replaceChildrenSlot,
   replaceChildrenTextSlot,
+  requestAnimationFrame,
   resizeObserver,
   resizeObserverAll,
   resizeObserverDelegate,
@@ -21194,6 +23435,7 @@ export {
   resolveAttributeTargets,
   resolvePropertyTargets,
   resolveQueryElements,
+  routerEvent,
   setAttribute,
   setClass,
   setInterval2 as setInterval,