event-emission 0.2.0 → 0.3.0

package/dist/index.js

@@ -4,13 +4,7 @@ var SymbolObservable = typeof Symbol === "function" && Symbol.observable || Symb
 if (typeof Symbol === "function") {
   Symbol.observable = SymbolObservable;
 }
-// src/errors.ts
-class BufferOverflowError extends Error {
-  constructor(eventType, bufferSize) {
-    super(`Buffer overflow for event type "${eventType}" (max: ${bufferSize})`);
-    this.name = "BufferOverflowError";
-  }
-}
+
 // src/observable.ts
 function getMethod(obj, key) {
   if (obj === null || obj === undefined)
@@ -277,17 +271,13 @@ function isArrayMutator(prop) {
   return typeof prop === "string" && ARRAY_MUTATORS.has(prop);
 }
 function cloneAlongPath(obj, path) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (!path) {
-    return Array.isArray(obj) ? [...obj] : { ...obj };
+  const isArray = Array.isArray(obj);
+  const rootClone = isArray ? [...obj] : { ...obj };
+  if (!path || isArray) {
+    return rootClone;
   }
   const parts = path.split(".");
-  if (Array.isArray(obj)) {
-    return [...obj];
-  }
-  const result = { ...obj };
+  const result = rootClone;
   let current = result;
   for (let i = 0;i < parts.length; i++) {
     const key = parts[i];
@@ -303,13 +293,19 @@ function cloneAlongPath(obj, path) {
   }
   return result;
 }
-function cloneForComparison(obj, strategy, changedPath) {
+function cloneForComparison(obj, strategy, changedPath, deepClone) {
   if (obj === null || typeof obj !== "object")
     return obj;
   switch (strategy) {
     case "shallow":
       return Array.isArray(obj) ? [...obj] : { ...obj };
     case "deep":
+      if (deepClone) {
+        return deepClone(obj);
+      }
+      if (typeof structuredClone !== "function") {
+        throw new Error("structuredClone is not available in this runtime; provide observe.deepClone, or use cloneStrategy 'path' or 'shallow'.");
+      }
       return structuredClone(obj);
     case "path":
       return cloneAlongPath(obj, changedPath);
@@ -357,7 +353,7 @@ function getContextRegistry(target) {
 function createArrayMethodInterceptor(array, method, path, context) {
   const original = array[method];
   return function(...args) {
-    const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, path);
+    const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, path, context.options.deepClone);
     const previousItems = [...array];
     const result = original.apply(this, args);
     const { added, removed } = computeArrayDiff(method, previousItems, array, args);
@@ -429,7 +425,7 @@ function createObservableProxyInternal(target, path, context) {
         return true;
       }
       const propPath = path ? `${path}.${prop}` : prop;
-      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath);
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath, context.options.deepClone);
       const success = Reflect.set(obj, prop, value, receiver);
       if (success) {
         context.eventTarget.dispatchEvent({
@@ -455,7 +451,7 @@ function createObservableProxyInternal(target, path, context) {
         return Reflect.deleteProperty(obj, prop);
       }
       const propPath = path ? `${path}.${String(prop)}` : String(prop);
-      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath);
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath, context.options.deepClone);
       const success = Reflect.deleteProperty(obj, prop);
       if (success) {
         context.eventTarget.dispatchEvent({
@@ -488,6 +484,8 @@ function isEventTarget(obj) {
 }
 function setupEventForwarding(source, target) {
   const handlers = new Map;
+  const sourceAddEventListener = source.addEventListener.bind(source);
+  const sourceRemoveEventListener = source.removeEventListener.bind(source);
   const forwardHandler = (type) => (event) => {
     const detail = event.detail ?? event;
     target.dispatchEvent({
@@ -500,7 +498,7 @@ function setupEventForwarding(source, target) {
     if (!handlers.has(type) && type !== "update" && !type.startsWith("update:")) {
       const handler = forwardHandler(type);
       handlers.set(type, handler);
-      source.addEventListener(type, handler);
+      sourceAddEventListener(type, handler);
     }
     return originalAddEventListener(type, listener, options);
   };
@@ -508,7 +506,7 @@ function setupEventForwarding(source, target) {
   return () => {
     target.addEventListener = originalAddEventListener;
     for (const [type, handler] of handlers) {
-      source.removeEventListener(type, handler);
+      sourceRemoveEventListener(type, handler);
     }
     handlers.clear();
   };
@@ -525,7 +523,8 @@ function getOriginal(proxy) {
 function createObservableProxy(target, eventTarget, options) {
   const resolvedOptions = {
     deep: options?.deep ?? true,
-    cloneStrategy: options?.cloneStrategy ?? "path"
+    cloneStrategy: options?.cloneStrategy ?? "path",
+    deepClone: options?.deepClone
   };
   const context = {
     eventTarget,
@@ -534,21 +533,36 @@ function createObservableProxy(target, eventTarget, options) {
   };
   const proxy = createObservableProxyInternal(target, "", context);
   if (isEventTarget(target)) {
-    setupEventForwarding(target, eventTarget);
+    const cleanupForwarding = setupEventForwarding(target, eventTarget);
+    const maybeComplete = eventTarget.complete;
+    if (typeof maybeComplete === "function") {
+      const originalComplete = maybeComplete.bind(eventTarget);
+      let cleaned = false;
+      eventTarget.complete = () => {
+        if (!cleaned) {
+          cleaned = true;
+          cleanupForwarding();
+        }
+        return originalComplete();
+      };
+    }
   }
   return proxy;
 }
-
+// src/errors.ts
+class BufferOverflowError extends Error {
+  constructor(eventType, bufferSize) {
+    super(`Buffer overflow for event type "${eventType}" (max: ${bufferSize})`);
+    this.name = "BufferOverflowError";
+  }
+}
 // src/factory.ts
 function matchesWildcard(eventType, pattern) {
   if (pattern === "*")
     return true;
-  if (pattern.endsWith(":*")) {
-    const namespace = pattern.slice(0, -2);
-    return eventType.startsWith(namespace + ":");
-  }
-  return false;
+  return pattern.endsWith(":*") && eventType.startsWith(pattern.slice(0, -2) + ":");
 }
+var EVENT_STATE = Symbol("event-emission:event-state");
 function createEventTarget(targetOrOpts, opts) {
   if (opts?.observe === true && targetOrOpts && typeof targetOrOpts === "object") {
     const target = targetOrOpts;
@@ -557,7 +571,8 @@ function createEventTarget(targetOrOpts, opts) {
     });
     const proxy = createObservableProxy(target, eventTarget, {
       deep: opts.deep,
-      cloneStrategy: opts.cloneStrategy
+      cloneStrategy: opts.cloneStrategy,
+      deepClone: opts.deepClone
     });
     const methodNames = [
       "addEventListener",
@@ -573,7 +588,17 @@ function createEventTarget(targetOrOpts, opts) {
       "complete",
       "subscribe",
       "toObservable",
-      "events"
+      "events",
+      "emit",
+      "off",
+      "addListener",
+      "removeListener",
+      "prependListener",
+      "prependOnceListener",
+      "listeners",
+      "rawListeners",
+      "listenerCount",
+      "eventNames"
     ];
     for (const name of methodNames) {
       Object.defineProperty(proxy, name, {
@@ -597,38 +622,202 @@ function createEventTargetInternal(opts) {
   const wildcardListeners = new Set;
   let isCompleted = false;
   const completionCallbacks = new Set;
-  const augmentEvent = (type, detail) => {
-    const baseEvent = {
-      bubbles: false,
-      cancelable: false,
-      composed: false,
-      defaultPrevented: false,
-      eventPhase: 2,
-      isTrusted: false,
-      timeStamp: Date.now(),
-      NONE: 0,
-      CAPTURING_PHASE: 1,
-      AT_TARGET: 2,
-      BUBBLING_PHASE: 3,
-      composedPath: () => [target],
-      stopImmediatePropagation: () => {},
-      stopPropagation: () => {}
+  const now = () => typeof globalThis.performance?.now === "function" ? globalThis.performance.now() : Date.now();
+  const initializeEventState = (state, type, bubbles, cancelable) => {
+    state.initializedFlag = true;
+    state.stopPropagationFlag = false;
+    state.stopImmediatePropagationFlag = false;
+    state.canceledFlag = false;
+    state.isTrusted = false;
+    state.target = null;
+    state.currentTarget = null;
+    state.eventPhase = 0;
+    state.type = type;
+    state.bubbles = bubbles;
+    state.cancelable = cancelable;
+  };
+  const setCanceledFlag = (state) => {
+    if (state.cancelable && !state.inPassiveListenerFlag) {
+      state.canceledFlag = true;
+    }
+  };
+  const createEvent = (type, detail, init) => {
+    const state = {
+      dispatchFlag: false,
+      initializedFlag: true,
+      stopPropagationFlag: false,
+      stopImmediatePropagationFlag: false,
+      canceledFlag: false,
+      inPassiveListenerFlag: false,
+      composedFlag: Boolean(init?.composed),
+      eventPhase: init?.eventPhase ?? 0,
+      currentTarget: init?.currentTarget ?? init?.target ?? null,
+      target: init?.target ?? null,
+      timeStamp: init?.timeStamp ?? now(),
+      path: [],
+      type,
+      bubbles: Boolean(init?.bubbles),
+      cancelable: Boolean(init?.cancelable),
+      isTrusted: false
     };
-    return Object.defineProperties({ ...baseEvent, type, detail }, {
-      target: { value: target, enumerable: true, configurable: true },
-      currentTarget: { value: target, enumerable: true, configurable: true },
+    const event = { detail };
+    Object.defineProperties(event, {
+      type: {
+        get: () => state.type,
+        enumerable: true,
+        configurable: true
+      },
+      bubbles: {
+        get: () => state.bubbles,
+        enumerable: true,
+        configurable: true
+      },
+      cancelable: {
+        get: () => state.cancelable,
+        enumerable: true,
+        configurable: true
+      },
+      cancelBubble: {
+        get: () => state.stopPropagationFlag,
+        set: (value) => {
+          if (value)
+            state.stopPropagationFlag = true;
+        },
+        enumerable: true,
+        configurable: true
+      },
+      composed: {
+        get: () => state.composedFlag,
+        enumerable: true,
+        configurable: true
+      },
+      currentTarget: {
+        get: () => state.currentTarget,
+        enumerable: true,
+        configurable: true
+      },
+      defaultPrevented: {
+        get: () => state.canceledFlag,
+        enumerable: true,
+        configurable: true
+      },
+      eventPhase: {
+        get: () => state.eventPhase,
+        enumerable: true,
+        configurable: true
+      },
+      isTrusted: {
+        get: () => state.isTrusted,
+        enumerable: true,
+        configurable: true
+      },
+      returnValue: {
+        get: () => !state.canceledFlag,
+        set: (value) => {
+          if (value === false)
+            setCanceledFlag(state);
+        },
+        enumerable: true,
+        configurable: true
+      },
+      srcElement: {
+        get: () => state.target,
+        enumerable: true,
+        configurable: true
+      },
+      target: {
+        get: () => state.target,
+        enumerable: true,
+        configurable: true
+      },
+      timeStamp: {
+        get: () => state.timeStamp,
+        enumerable: true,
+        configurable: true
+      },
+      composedPath: {
+        value: () => state.path.map((entry) => entry.invocationTarget),
+        enumerable: true,
+        configurable: true
+      },
+      initEvent: {
+        value: (newType, bubbles = false, cancelable = false) => {
+          if (state.dispatchFlag)
+            return;
+          initializeEventState(state, newType, Boolean(bubbles), Boolean(cancelable));
+        },
+        enumerable: true,
+        configurable: true
+      },
       preventDefault: {
-        value: function() {
-          Object.defineProperty(this, "defaultPrevented", {
-            value: true,
-            enumerable: true,
-            configurable: true
-          });
+        value: () => setCanceledFlag(state),
+        enumerable: true,
+        configurable: true
+      },
+      stopImmediatePropagation: {
+        value: () => {
+          state.stopPropagationFlag = true;
+          state.stopImmediatePropagationFlag = true;
+        },
+        enumerable: true,
+        configurable: true
+      },
+      stopPropagation: {
+        value: () => {
+          state.stopPropagationFlag = true;
         },
         enumerable: true,
         configurable: true
+      },
+      NONE: { value: 0, enumerable: true, configurable: true },
+      CAPTURING_PHASE: { value: 1, enumerable: true, configurable: true },
+      AT_TARGET: { value: 2, enumerable: true, configurable: true },
+      BUBBLING_PHASE: { value: 3, enumerable: true, configurable: true },
+      [EVENT_STATE]: {
+        value: state,
+        enumerable: false,
+        configurable: false
       }
     });
+    return event;
+  };
+  const getEventState = (event) => event[EVENT_STATE];
+  const normalizeAddListenerOptions = (options) => {
+    if (typeof options === "boolean") {
+      return {
+        capture: options,
+        passive: false,
+        once: false,
+        signal: null
+      };
+    }
+    return {
+      capture: Boolean(options?.capture),
+      passive: Boolean(options?.passive),
+      once: Boolean(options?.once),
+      signal: options?.signal ?? null
+    };
+  };
+  const normalizeCaptureOption = (options) => {
+    if (typeof options === "boolean")
+      return options;
+    return Boolean(options?.capture);
+  };
+  const removeListenerRecord = (type, record) => {
+    if (record.removed)
+      return;
+    record.removed = true;
+    const list = listeners.get(type);
+    if (list) {
+      const idx = list.indexOf(record);
+      if (idx >= 0)
+        list.splice(idx, 1);
+      if (list.length === 0)
+        listeners.delete(type);
+    }
+    if (record.signal && record.abortHandler) {
+      record.signal.removeEventListener("abort", record.abortHandler);
+    }
   };
   const handleListenerError = (eventType, error2) => {
     if (eventType === "error")
@@ -638,28 +827,27 @@ function createEventTargetInternal(opts) {
       return;
     }
     const errorListeners = listeners.get("error");
-    if (errorListeners && errorListeners.size > 0) {
-      const errorEvent = augmentEvent("error", error2);
-      for (const rec of Array.from(errorListeners)) {
-        try {
-          const fn = rec.fn;
-          fn(errorEvent);
-        } catch {}
-        if (rec.once)
-          errorListeners.delete(rec);
-      }
+    if (errorListeners && errorListeners.length > 0) {
+      dispatchEvent({ type: "error", detail: error2 });
     } else {
       throw error2;
     }
   };
-  const notifyWildcardListeners = (eventType, detail) => {
+  const notifyWildcardListeners = (eventType, event) => {
     if (wildcardListeners.size === 0)
       return;
     for (const rec of Array.from(wildcardListeners)) {
       if (!matchesWildcard(eventType, rec.pattern))
         continue;
-      const baseAugmented = augmentEvent(rec.pattern, detail);
-      const wildcardEvent = Object.defineProperties(baseAugmented, {
+      const baseEvent = createEvent(rec.pattern, event.detail, {
+        target,
+        currentTarget: target,
+        eventPhase: 2,
+        bubbles: event.bubbles,
+        cancelable: event.cancelable,
+        composed: event.composed
+      });
+      const wildcardEvent = Object.defineProperties(baseEvent, {
         originalType: { value: eventType, enumerable: true, configurable: true }
       });
       try {
@@ -682,44 +870,66 @@ function createEventTargetInternal(opts) {
         if (rec.once)
           wildcardListeners.delete(rec);
       }
+      const state = getEventState(wildcardEvent);
+      if (state?.stopImmediatePropagationFlag || state?.stopPropagationFlag) {
+        break;
+      }
     }
   };
-  const addEventListener = (type, listener, options) => {
-    if (isCompleted) {
+  const addListenerInternal = (type, listener, options, position) => {
+    if (isCompleted || !listener) {
       return () => {};
     }
-    const opts2 = options ?? {};
-    const record = {
-      fn: listener,
-      once: opts2.once,
-      signal: opts2.signal
-    };
-    let set = listeners.get(type);
-    if (!set) {
-      set = new Set;
-      listeners.set(type, set);
+    const { capture, passive, once, signal } = normalizeAddListenerOptions(options);
+    let list = listeners.get(type);
+    if (!list) {
+      list = [];
+      listeners.set(type, list);
     }
-    set.add(record);
-    const unsubscribe2 = () => {
-      const setNow = listeners.get(type);
-      setNow?.delete(record);
-      if (record.signal && record.abortHandler) {
-        record.signal.removeEventListener("abort", record.abortHandler);
+    for (const existing of list) {
+      if (existing.original === listener && existing.capture === capture) {
+        return () => removeEventListener(type, listener, options);
       }
+    }
+    const original = listener;
+    const callback = typeof listener === "function" ? listener : (event) => listener.handleEvent(event);
+    const record = {
+      type,
+      original,
+      callback,
+      capture,
+      passive,
+      once,
+      signal,
+      removed: false
     };
-    if (opts2.signal) {
-      const onAbort = () => unsubscribe2();
+    if (position === "prepend") {
+      list.unshift(record);
+    } else {
+      list.push(record);
+    }
+    const unsubscribe2 = () => removeListenerRecord(type, record);
+    if (signal) {
+      const onAbort = () => removeListenerRecord(type, record);
       record.abortHandler = onAbort;
-      opts2.signal.addEventListener("abort", onAbort, { once: true });
-      if (opts2.signal.aborted)
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
         onAbort();
     }
     return unsubscribe2;
   };
+  const addEventListener = (type, listener, options) => {
+    return addListenerInternal(type, listener, options, "append");
+  };
   const addWildcardListener = (pattern, listener, options) => {
     if (isCompleted)
       return () => {};
     const opts2 = options ?? {};
+    for (const existing of wildcardListeners) {
+      if (existing.pattern === pattern && existing.fn === listener) {
+        return () => removeWildcardListener(pattern, listener);
+      }
+    }
     const record = {
       fn: listener,
       pattern,
@@ -743,31 +953,39 @@ function createEventTargetInternal(opts) {
     return unsubscribe2;
   };
   const removeWildcardListener = (pattern, listener) => {
-    for (const record of wildcardListeners) {
+    for (const record of Array.from(wildcardListeners)) {
       if (record.pattern === pattern && record.fn === listener) {
         wildcardListeners.delete(record);
         if (record.signal && record.abortHandler) {
           record.signal.removeEventListener("abort", record.abortHandler);
         }
-        break;
       }
     }
   };
-  const dispatchEvent = (event) => {
-    if (isCompleted)
-      return false;
-    const augmentedEvent = augmentEvent(event.type, event.detail);
-    notifyWildcardListeners(event.type, event.detail);
-    const set = listeners.get(event.type);
-    if (!set || set.size === 0)
-      return true;
-    for (const rec of Array.from(set)) {
+  const invokeListeners = (eventType, event, phase, listenersSnapshot) => {
+    const state = getEventState(event);
+    if (!state || state.stopPropagationFlag)
+      return;
+    state.currentTarget = target;
+    state.target = target;
+    state.eventPhase = event.AT_TARGET;
+    for (const rec of listenersSnapshot) {
+      if (rec.removed)
+        continue;
+      if (phase === "capturing" && !rec.capture)
+        continue;
+      if (phase === "bubbling" && rec.capture)
+        continue;
+      if (rec.once)
+        removeListenerRecord(rec.type, rec);
+      if (rec.passive)
+        state.inPassiveListenerFlag = true;
       try {
-        const res = rec.fn(augmentedEvent);
+        const res = rec.callback.call(state.currentTarget, event);
         if (res && typeof res.then === "function") {
           res.catch((error2) => {
             try {
-              handleListenerError(event.type, error2);
+              handleListenerError(eventType, error2);
             } catch (rethrown) {
               queueMicrotask(() => {
                 throw rethrown;
@@ -776,36 +994,94 @@ function createEventTargetInternal(opts) {
           });
         }
       } catch (error2) {
-        handleListenerError(event.type, error2);
+        handleListenerError(eventType, error2);
       } finally {
-        if (rec.once)
-          set.delete(rec);
+        if (rec.passive)
+          state.inPassiveListenerFlag = false;
       }
+      if (state.stopImmediatePropagationFlag)
+        break;
     }
-    return true;
   };
-  const removeEventListener = (type, listener) => {
-    const set = listeners.get(type);
-    if (!set)
-      return;
-    for (const record of set) {
-      if (record.fn === listener) {
-        set.delete(record);
-        if (record.signal && record.abortHandler) {
-          record.signal.removeEventListener("abort", record.abortHandler);
+  const dispatchEvent = (eventInput) => {
+    if (isCompleted)
+      return false;
+    let event;
+    let state;
+    if (eventInput && typeof eventInput === "object") {
+      state = getEventState(eventInput);
+      if (state) {
+        event = eventInput;
+      } else {
+        const input = eventInput;
+        if (typeof input.type !== "string") {
+          throw new TypeError("Event type must be a string");
         }
-        break;
+        event = createEvent(input.type, input.detail, {
+          bubbles: input.bubbles,
+          cancelable: input.cancelable,
+          composed: input.composed,
+          timeStamp: input.timeStamp
+        });
+        state = getEventState(event);
+      }
+    } else {
+      throw new TypeError("dispatchEvent expects an event object");
+    }
+    const dispatchState = state ?? getEventState(event);
+    if (dispatchState.dispatchFlag || !dispatchState.initializedFlag) {
+      const message = "Failed to execute dispatchEvent: event is already being dispatched";
+      if (typeof globalThis.DOMException === "function") {
+        throw new globalThis.DOMException(message, "InvalidStateError");
+      }
+      const err = new Error(message);
+      err.name = "InvalidStateError";
+      throw err;
+    }
+    dispatchState.isTrusted = false;
+    dispatchState.dispatchFlag = true;
+    dispatchState.path = [
+      {
+        invocationTarget: target,
+        invocationTargetInShadowTree: false,
+        shadowAdjustedTarget: target,
+        relatedTarget: null,
+        touchTargets: [],
+        rootOfClosedTree: false,
+        slotInClosedTree: false
+      }
+    ];
+    notifyWildcardListeners(dispatchState.type, event);
+    const list = listeners.get(dispatchState.type);
+    const snapshot = list ? list.slice() : [];
+    invokeListeners(dispatchState.type, event, "capturing", snapshot);
+    invokeListeners(dispatchState.type, event, "bubbling", snapshot);
+    dispatchState.eventPhase = event.NONE;
+    dispatchState.currentTarget = null;
+    dispatchState.path = [];
+    dispatchState.dispatchFlag = false;
+    dispatchState.stopPropagationFlag = false;
+    dispatchState.stopImmediatePropagationFlag = false;
+    return !dispatchState.canceledFlag;
+  };
+  const removeEventListener = (type, listener, options) => {
+    if (!listener)
+      return;
+    const capture = normalizeCaptureOption(options);
+    const list = listeners.get(type);
+    if (!list)
+      return;
+    for (const record of [...list]) {
+      if (record.original === listener && record.capture === capture) {
+        removeListenerRecord(type, record);
       }
     }
   };
   const clear = () => {
-    for (const set of listeners.values()) {
-      for (const record of set) {
-        if (record.signal && record.abortHandler) {
-          record.signal.removeEventListener("abort", record.abortHandler);
-        }
+    for (const [type, list] of Array.from(listeners.entries())) {
+      for (const record of [...list]) {
+        removeListenerRecord(type, record);
       }
-      set.clear();
     }
     listeners.clear();
     for (const record of wildcardListeners) {
@@ -815,11 +1091,22 @@ function createEventTargetInternal(opts) {
     }
     wildcardListeners.clear();
   };
-  const on = (type, options) => {
+  const isListenerArg = (arg) => {
+    if (typeof arg === "function")
+      return true;
+    if (arg && typeof arg === "object" && typeof arg.handleEvent === "function")
+      return true;
+    return false;
+  };
+  const on = (type, optionsOrListener) => {
+    if (isListenerArg(optionsOrListener)) {
+      return addEventListener(type, optionsOrListener);
+    }
+    const options = optionsOrListener;
     return new Observable((observer) => {
       let opts2;
       if (typeof options === "boolean") {
-        opts2 = { signal: undefined };
+        opts2 = { capture: options };
       } else {
         opts2 = options ?? {};
       }
@@ -856,28 +1143,25 @@ function createEventTargetInternal(opts) {
     });
   };
   const onceMethod = (type, listener, options) => {
-    return addEventListener(type, listener, { ...options, once: true });
+    if (typeof options === "boolean") {
+      return addEventListener(type, listener, { capture: options, once: true });
+    }
+    return addEventListener(type, listener, { ...options ?? {}, once: true });
   };
   const removeAllListeners = (type) => {
     if (type !== undefined) {
-      const set = listeners.get(type);
-      if (set) {
-        for (const record of set) {
-          if (record.signal && record.abortHandler) {
-            record.signal.removeEventListener("abort", record.abortHandler);
-          }
+      const list = listeners.get(type);
+      if (list) {
+        for (const record of [...list]) {
+          removeListenerRecord(type, record);
         }
-        set.clear();
         listeners.delete(type);
       }
     } else {
-      for (const set of listeners.values()) {
-        for (const record of set) {
-          if (record.signal && record.abortHandler) {
-            record.signal.removeEventListener("abort", record.abortHandler);
-          }
+      for (const [eventType, list] of Array.from(listeners.entries())) {
+        for (const record of [...list]) {
+          removeListenerRecord(eventType, record);
         }
-        set.clear();
       }
       listeners.clear();
       for (const record of wildcardListeners) {
@@ -892,38 +1176,33 @@ function createEventTargetInternal(opts) {
     if (isCompleted) {
       return () => {};
     }
-    const unsubscribes = [];
-    const subscribedTypes = new Set;
-    const subscribeToType = (type) => {
-      if (subscribedTypes.has(type))
-        return;
-      subscribedTypes.add(type);
-      const unsub = addEventListener(type, (event) => {
-        if (mapFn) {
-          const mapped = mapFn(event);
-          if (mapped !== null) {
-            target2.dispatchEvent(mapped);
-          }
-        } else {
-          target2.dispatchEvent(event);
+    const unsubscribe2 = addWildcardListener("*", (event) => {
+      if (mapFn) {
+        const mapped = mapFn(createEvent(event.originalType, event.detail, {
+          target: target2,
+          currentTarget: target2,
+          eventPhase: 2,
+          bubbles: event.bubbles,
+          cancelable: event.cancelable,
+          composed: event.composed
+        }));
+        if (mapped !== null) {
+          target2.dispatchEvent(mapped);
         }
-      });
-      unsubscribes.push(unsub);
-    };
-    for (const type of listeners.keys()) {
-      subscribeToType(type);
-    }
-    const completionUnsub = () => {
-      for (const unsub of unsubscribes) {
-        unsub();
+      } else {
+        target2.dispatchEvent({
+          type: event.originalType,
+          detail: event.detail
+        });
       }
+    });
+    const completionUnsub = () => {
+      unsubscribe2();
     };
     completionCallbacks.add(completionUnsub);
     return () => {
       completionCallbacks.delete(completionUnsub);
-      for (const unsub of unsubscribes) {
-        unsub();
-      }
+      unsubscribe2();
     };
   };
   const complete2 = () => {
@@ -940,13 +1219,10 @@ function createEventTargetInternal(opts) {
       }
     }
     completionCallbacks.clear();
-    for (const set of listeners.values()) {
-      for (const record of set) {
-        if (record.signal && record.abortHandler) {
-          record.signal.removeEventListener("abort", record.abortHandler);
-        }
+    for (const [eventType, list] of Array.from(listeners.entries())) {
+      for (const record of [...list]) {
+        removeListenerRecord(eventType, record);
       }
-      set.clear();
     }
     listeners.clear();
     for (const record of wildcardListeners) {
@@ -1029,7 +1305,14 @@ function createEventTargetInternal(opts) {
         return;
       }
       const wildcardListener = (event) => {
-        observer.next(augmentEvent(event.originalType, event.detail));
+        observer.next(createEvent(event.originalType, event.detail, {
+          target,
+          currentTarget: target,
+          eventPhase: 2,
+          bubbles: event.bubbles,
+          cancelable: event.cancelable,
+          composed: event.composed
+        }));
       };
       const unsubscribe2 = addWildcardListener("*", wildcardListener);
       const onComplete = () => {
@@ -1069,19 +1352,26 @@ function createEventTargetInternal(opts) {
     let resolve = null;
     let done = false;
     let hasOverflow = false;
+    let onAbort = null;
+    const cleanupAbortListener = () => {
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    };
     const unsub = addEventListener(type, (event) => {
       if (done)
         return;
+      const typedEvent = event;
       if (resolve) {
         const r = resolve;
         resolve = null;
-        r({ value: event, done: false });
+        r({ value: typedEvent, done: false });
       } else {
         if (buffer.length >= bufferSize && bufferSize !== Infinity) {
           switch (overflowStrategy) {
             case "drop-oldest":
               buffer.shift();
-              buffer.push(event);
+              buffer.push(typedEvent);
               break;
             case "drop-latest":
               break;
@@ -1090,15 +1380,17 @@ function createEventTargetInternal(opts) {
               completionCallbacks.delete(onComplete);
               done = true;
               hasOverflow = true;
+              cleanupAbortListener();
               return;
           }
         } else {
-          buffer.push(event);
+          buffer.push(typedEvent);
         }
       }
     });
     const onComplete = () => {
       done = true;
+      cleanupAbortListener();
       if (resolve) {
         const r = resolve;
         resolve = null;
@@ -1106,7 +1398,6 @@ function createEventTargetInternal(opts) {
       }
     };
     completionCallbacks.add(onComplete);
-    let onAbort = null;
     if (signal) {
       onAbort = () => {
         done = true;
@@ -1130,26 +1421,22 @@ function createEventTargetInternal(opts) {
         if (buffer.length > 0) {
           return { value: buffer.shift(), done: false };
         }
-        if (hasOverflow) {
-          hasOverflow = false;
-          throw new BufferOverflowError(type, bufferSize);
-        }
-        if (done) {
-          return { value: undefined, done: true };
-        }
         if (resolve !== null) {
           return Promise.reject(new Error("Concurrent calls to next() are not supported on this async iterator"));
         }
         return new Promise((_resolve, _reject) => {
-          if (done) {
-            _resolve({ value: undefined, done: true });
-            return;
-          }
           if (hasOverflow) {
             hasOverflow = false;
             _reject(new BufferOverflowError(type, bufferSize));
             return;
           }
+          if (done) {
+            _resolve({
+              value: undefined,
+              done: true
+            });
+            return;
+          }
           resolve = _resolve;
         });
       },
@@ -1162,9 +1449,7 @@ function createEventTargetInternal(opts) {
         done = true;
         completionCallbacks.delete(onComplete);
         unsub();
-        if (signal && onAbort) {
-          signal.removeEventListener("abort", onAbort);
-        }
+        cleanupAbortListener();
         return Promise.resolve({
           value: undefined,
           done: true
@@ -1173,6 +1458,72 @@ function createEventTargetInternal(opts) {
     };
     return iterator;
   }
+  const emit = (type, detail) => {
+    if (isCompleted)
+      return false;
+    const list = listeners.get(type);
+    const hasListeners = list !== undefined && list.length > 0;
+    let hasWildcard = false;
+    if (wildcardListeners.size > 0) {
+      for (const rec of wildcardListeners) {
+        if (matchesWildcard(type, rec.pattern)) {
+          hasWildcard = true;
+          break;
+        }
+      }
+    }
+    dispatchEvent({ type, detail });
+    return hasListeners || hasWildcard;
+  };
+  const off = (type, listener) => {
+    removeEventListener(type, listener);
+  };
+  const addListener = (type, listener) => {
+    return addEventListener(type, listener);
+  };
+  const removeListener = (type, listener) => {
+    removeEventListener(type, listener);
+  };
+  const prependListener = (type, listener) => {
+    return addListenerInternal(type, listener, undefined, "prepend");
+  };
+  const prependOnceListener = (type, listener) => {
+    return addListenerInternal(type, listener, { once: true }, "prepend");
+  };
+  const getListeners = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return [];
+    return list.filter((r) => !r.removed).map((r) => r.original);
+  };
+  const rawListenersMethod = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return [];
+    return list.filter((r) => !r.removed).map((r) => {
+      if (r.once) {
+        const wrapper = (...args) => r.callback(...args);
+        wrapper.listener = r.original;
+        return wrapper;
+      }
+      return r.original;
+    });
+  };
+  const listenerCount = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return 0;
+    return list.filter((r) => !r.removed).length;
+  };
+  const eventNamesMethod = () => {
+    const names = [];
+    for (const [type, list] of listeners) {
+      if (list.some((r) => !r.removed)) {
+        names.push(type);
+      }
+    }
+    return names;
+  };
   const target = {
     addEventListener,
     removeEventListener,
@@ -1190,90 +1541,23 @@ function createEventTargetInternal(opts) {
     },
     subscribe,
     toObservable,
-    events
+    events,
+    emit,
+    off,
+    addListener,
+    removeListener,
+    prependListener,
+    prependOnceListener,
+    listeners: getListeners,
+    rawListeners: rawListenersMethod,
+    listenerCount,
+    eventNames: eventNamesMethod
   };
   target[SymbolObservable] = () => {
     return toObservable();
   };
   return target;
 }
-// src/interop.ts
-function forwardToEventTarget(source, target, options) {
-  const unsubscribe2 = source.addWildcardListener("*", (event) => {
-    const domEvent = {
-      type: event.originalType,
-      detail: event.detail
-    };
-    target.dispatchEvent(domEvent);
-  }, options);
-  return unsubscribe2;
-}
-function fromEventTarget(domTarget, eventTypes, options) {
-  const emitter = createEventTarget({
-    onListenerError: options?.onListenerError
-  });
-  const handlers = new Map;
-  for (const type of eventTypes) {
-    const handler = (event) => {
-      emitter.dispatchEvent({
-        type,
-        detail: event.detail ?? event
-      });
-    };
-    handlers.set(type, handler);
-    domTarget.addEventListener(type, handler);
-  }
-  let onAbort = null;
-  if (options?.signal) {
-    onAbort = () => {
-      for (const [type, handler] of handlers) {
-        domTarget.removeEventListener(type, handler);
-      }
-      handlers.clear();
-      emitter.complete();
-    };
-    options.signal.addEventListener("abort", onAbort, { once: true });
-    if (options.signal.aborted)
-      onAbort();
-  }
-  return {
-    addEventListener: emitter.addEventListener,
-    removeEventListener: emitter.removeEventListener,
-    dispatchEvent: emitter.dispatchEvent,
-    clear: emitter.clear,
-    once: emitter.once,
-    removeAllListeners: emitter.removeAllListeners,
-    pipe: emitter.pipe,
-    addWildcardListener: emitter.addWildcardListener,
-    removeWildcardListener: emitter.removeWildcardListener,
-    on: emitter.on,
-    subscribe: emitter.subscribe,
-    toObservable: emitter.toObservable,
-    complete: emitter.complete,
-    get completed() {
-      return emitter.completed;
-    },
-    events: emitter.events,
-    destroy: () => {
-      if (options?.signal && onAbort) {
-        options.signal.removeEventListener("abort", onAbort);
-      }
-      for (const [type, handler] of handlers) {
-        domTarget.removeEventListener(type, handler);
-      }
-      handlers.clear();
-      emitter.complete();
-    }
-  };
-}
-function pipe(source, target, options) {
-  return source.addWildcardListener("*", (event) => {
-    target.dispatchEvent({
-      type: event.originalType,
-      detail: event.detail
-    });
-  }, options);
-}
 // src/event-emission.ts
 class EventEmission {
   #target;
@@ -1283,14 +1567,14 @@ class EventEmission {
   addEventListener(type, listener, options) {
     return this.#target.addEventListener(type, listener, options);
   }
-  removeEventListener(type, listener) {
-    this.#target.removeEventListener(type, listener);
+  removeEventListener(type, listener, options) {
+    this.#target.removeEventListener(type, listener, options);
   }
   dispatchEvent(event) {
     return this.#target.dispatchEvent(event);
   }
-  on(type, options) {
-    return this.#target.on(type, options);
+  on(type, optionsOrListener) {
+    return this.#target.on(type, optionsOrListener);
   }
   once(type, listener, options) {
     return this.#target.once(type, listener, options);
@@ -1304,6 +1588,36 @@ class EventEmission {
   pipe(target, mapFn) {
     return this.#target.pipe(target, mapFn);
   }
+  emit(type, detail) {
+    return this.#target.emit(type, detail);
+  }
+  off(type, listener) {
+    this.#target.off(type, listener);
+  }
+  addListener(type, listener) {
+    return this.#target.addListener(type, listener);
+  }
+  removeListener(type, listener) {
+    this.#target.removeListener(type, listener);
+  }
+  prependListener(type, listener) {
+    return this.#target.prependListener(type, listener);
+  }
+  prependOnceListener(type, listener) {
+    return this.#target.prependOnceListener(type, listener);
+  }
+  listeners(type) {
+    return this.#target.listeners(type);
+  }
+  rawListeners(type) {
+    return this.#target.rawListeners(type);
+  }
+  listenerCount(type) {
+    return this.#target.listenerCount(type);
+  }
+  eventNames() {
+    return this.#target.eventNames();
+  }
   addWildcardListener(pattern, listener, options) {
     return this.#target.addWildcardListener(pattern, listener, options);
   }
@@ -1343,19 +1657,10 @@ class EventEmission {
   }
 }
 export {
-  setupEventForwarding,
-  pipe,
-  isObserved,
-  getOriginal,
-  fromEventTarget,
-  forwardToEventTarget,
   createEventTarget,
   SymbolObservable,
-  PROXY_MARKER,
-  Observable,
-  ORIGINAL_TARGET,
   EventEmission,
   BufferOverflowError
 };
 
-//# debugId=444E2053CE7B039864756E2164756E21
+//# debugId=320F1C6E7F0CB63D64756E2164756E21