event-emission 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1126 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setupEventForwarding: () => setupEventForwarding,
+  pipe: () => pipe,
+  isObserved: () => isObserved,
+  getOriginal: () => getOriginal,
+  fromEventTarget: () => fromEventTarget,
+  forwardToEventTarget: () => forwardToEventTarget,
+  createEventTarget: () => createEventTarget,
+  SymbolObservable: () => SymbolObservable,
+  PROXY_MARKER: () => PROXY_MARKER,
+  ORIGINAL_TARGET: () => ORIGINAL_TARGET,
+  Eventful: () => Eventful,
+  BufferOverflowError: () => BufferOverflowError
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/symbols.ts
+var SymbolObservable = typeof Symbol === "function" && Symbol.observable || Symbol.for("@@observable");
+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/observe.ts
+var PROXY_MARKER = Symbol.for("@lasercat/eventful/proxy");
+var ORIGINAL_TARGET = Symbol.for("@lasercat/eventful/original");
+var ARRAY_MUTATORS = new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+function isProxyable(value) {
+  return value !== null && typeof value === "object" && !isProxied(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof WeakMap) && !(value instanceof WeakSet) && !(value instanceof Promise) && !(value instanceof Error) && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+}
+function isProxied(value) {
+  return typeof value === "object" && value !== null && value[PROXY_MARKER] === true;
+}
+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 parts = path.split(".");
+  if (Array.isArray(obj)) {
+    return [...obj];
+  }
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0;i < parts.length; i++) {
+    const key = parts[i];
+    const value = current[key];
+    if (value !== null && typeof value === "object") {
+      current[key] = Array.isArray(value) ? [...value] : { ...value };
+      if (i < parts.length - 1) {
+        current = current[key];
+      }
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function cloneForComparison(obj, strategy, changedPath) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  switch (strategy) {
+    case "shallow":
+      return Array.isArray(obj) ? [...obj] : { ...obj };
+    case "deep":
+      return structuredClone(obj);
+    case "path":
+      return cloneAlongPath(obj, changedPath);
+    default:
+      return obj;
+  }
+}
+function computeArrayDiff(method, before, _after, args) {
+  switch (method) {
+    case "push":
+      return { added: args };
+    case "pop":
+      return { removed: before.length > 0 ? [before[before.length - 1]] : [] };
+    case "shift":
+      return { removed: before.length > 0 ? [before[0]] : [] };
+    case "unshift":
+      return { added: args };
+    case "splice": {
+      const [start, deleteCount, ...items] = args;
+      const actualStart = start < 0 ? Math.max(before.length + start, 0) : Math.min(start, before.length);
+      const actualDeleteCount = Math.min(deleteCount ?? before.length - actualStart, before.length - actualStart);
+      return {
+        removed: before.slice(actualStart, actualStart + actualDeleteCount),
+        added: items
+      };
+    }
+    case "sort":
+    case "reverse":
+    case "fill":
+    case "copyWithin":
+      return {};
+    default:
+      return {};
+  }
+}
+var proxyRegistry = new WeakMap;
+function getContextRegistry(target) {
+  let contextMap = proxyRegistry.get(target);
+  if (!contextMap) {
+    contextMap = new WeakMap;
+    proxyRegistry.set(target, contextMap);
+  }
+  return contextMap;
+}
+function createArrayMethodInterceptor(array, method, path, context) {
+  const original = array[method];
+  return function(...args) {
+    const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, path);
+    const previousItems = [...array];
+    const result = original.apply(this, args);
+    const { added, removed } = computeArrayDiff(method, previousItems, array, args);
+    const methodEventPath = path ? `update:${path}.${method}` : `update:${method}`;
+    const arrayEventPath = path ? `update:${path}` : "update:";
+    context.eventTarget.dispatchEvent({
+      type: methodEventPath,
+      detail: {
+        method,
+        args,
+        result,
+        added,
+        removed,
+        current: context.originalRoot,
+        previous: previousState
+      }
+    });
+    if (path) {
+      context.eventTarget.dispatchEvent({
+        type: arrayEventPath,
+        detail: {
+          value: array,
+          current: context.originalRoot,
+          previous: previousState
+        }
+      });
+    }
+    context.eventTarget.dispatchEvent({
+      type: "update",
+      detail: {
+        current: context.originalRoot,
+        previous: previousState
+      }
+    });
+    return result;
+  };
+}
+function createObservableProxyInternal(target, path, context) {
+  const contextRegistry = getContextRegistry(target);
+  const existing = contextRegistry.get(context);
+  if (existing) {
+    return existing.proxy;
+  }
+  const proxy = new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (prop === PROXY_MARKER)
+        return true;
+      if (prop === ORIGINAL_TARGET)
+        return obj;
+      if (typeof prop === "symbol") {
+        return Reflect.get(obj, prop, receiver);
+      }
+      const value = Reflect.get(obj, prop, receiver);
+      if (Array.isArray(obj) && isArrayMutator(prop)) {
+        return createArrayMethodInterceptor(obj, prop, path, context);
+      }
+      if (context.options.deep && isProxyable(value)) {
+        const nestedPath = path ? `${path}.${prop}` : prop;
+        return createObservableProxyInternal(value, nestedPath, context);
+      }
+      return value;
+    },
+    set(obj, prop, value, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(obj, prop, value, receiver);
+      }
+      const oldValue = Reflect.get(obj, prop, receiver);
+      if (Object.is(oldValue, value)) {
+        return true;
+      }
+      const propPath = path ? `${path}.${prop}` : prop;
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath);
+      const success = Reflect.set(obj, prop, value, receiver);
+      if (success) {
+        context.eventTarget.dispatchEvent({
+          type: `update:${propPath}`,
+          detail: {
+            value,
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+        context.eventTarget.dispatchEvent({
+          type: "update",
+          detail: {
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+      }
+      return success;
+    },
+    deleteProperty(obj, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.deleteProperty(obj, prop);
+      }
+      const propPath = path ? `${path}.${String(prop)}` : String(prop);
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath);
+      const success = Reflect.deleteProperty(obj, prop);
+      if (success) {
+        context.eventTarget.dispatchEvent({
+          type: `update:${propPath}`,
+          detail: {
+            value: undefined,
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+        context.eventTarget.dispatchEvent({
+          type: "update",
+          detail: {
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+      }
+      return success;
+    }
+  });
+  contextRegistry.set(context, {
+    proxy,
+    path
+  });
+  return proxy;
+}
+function isEventTarget(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.addEventListener === "function" && typeof obj.removeEventListener === "function" && typeof obj.dispatchEvent === "function";
+}
+function setupEventForwarding(source, target) {
+  const handlers = new Map;
+  const forwardHandler = (type) => (event) => {
+    const detail = event.detail ?? event;
+    target.dispatchEvent({
+      type,
+      detail
+    });
+  };
+  const originalAddEventListener = target.addEventListener.bind(target);
+  const wrappedAddEventListener = (type, listener, options) => {
+    if (!handlers.has(type) && type !== "update" && !type.startsWith("update:")) {
+      const handler = forwardHandler(type);
+      handlers.set(type, handler);
+      source.addEventListener(type, handler);
+    }
+    return originalAddEventListener(type, listener, options);
+  };
+  target.addEventListener = wrappedAddEventListener;
+  return () => {
+    target.addEventListener = originalAddEventListener;
+    for (const [type, handler] of handlers) {
+      source.removeEventListener(type, handler);
+    }
+    handlers.clear();
+  };
+}
+function isObserved(obj) {
+  return isProxied(obj);
+}
+function getOriginal(proxy) {
+  if (!isProxied(proxy)) {
+    return proxy;
+  }
+  return proxy[ORIGINAL_TARGET] ?? proxy;
+}
+function createObservableProxy(target, eventTarget, options) {
+  const resolvedOptions = {
+    deep: options?.deep ?? true,
+    cloneStrategy: options?.cloneStrategy ?? "path"
+  };
+  const context = {
+    eventTarget,
+    originalRoot: target,
+    options: resolvedOptions
+  };
+  const proxy = createObservableProxyInternal(target, "", context);
+  if (isEventTarget(target)) {
+    setupEventForwarding(target, eventTarget);
+  }
+  return proxy;
+}
+
+// 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;
+}
+function createEventTarget(targetOrOpts, opts) {
+  if (opts?.observe === true && targetOrOpts && typeof targetOrOpts === "object") {
+    const target = targetOrOpts;
+    const eventTarget = createEventTargetInternal({
+      onListenerError: opts.onListenerError
+    });
+    const proxy = createObservableProxy(target, eventTarget, {
+      deep: opts.deep,
+      cloneStrategy: opts.cloneStrategy
+    });
+    const methodNames = [
+      "addEventListener",
+      "removeEventListener",
+      "dispatchEvent",
+      "clear",
+      "once",
+      "removeAllListeners",
+      "pipe",
+      "addWildcardListener",
+      "removeWildcardListener",
+      "complete",
+      "subscribe",
+      "toObservable",
+      "events"
+    ];
+    for (const name of methodNames) {
+      Object.defineProperty(proxy, name, {
+        value: eventTarget[name],
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    Object.defineProperty(proxy, "completed", {
+      get: () => eventTarget.completed,
+      enumerable: false,
+      configurable: true
+    });
+    return proxy;
+  }
+  return createEventTargetInternal(targetOrOpts);
+}
+function createEventTargetInternal(opts) {
+  const listeners = new Map;
+  const wildcardListeners = new Set;
+  let isCompleted = false;
+  const completionCallbacks = new Set;
+  const handleListenerError = (eventType, error) => {
+    if (eventType === "error")
+      return;
+    if (opts?.onListenerError) {
+      opts.onListenerError(eventType, error);
+      return;
+    }
+    const errorListeners = listeners.get("error");
+    if (errorListeners && errorListeners.size > 0) {
+      for (const rec of Array.from(errorListeners)) {
+        try {
+          rec.fn({ type: "error", detail: error });
+        } catch {}
+        if (rec.once)
+          errorListeners.delete(rec);
+      }
+    } else {
+      throw error;
+    }
+  };
+  const notifyWildcardListeners = (eventType, detail) => {
+    if (wildcardListeners.size === 0)
+      return;
+    for (const rec of Array.from(wildcardListeners)) {
+      if (!matchesWildcard(eventType, rec.pattern))
+        continue;
+      const wildcardEvent = {
+        type: rec.pattern,
+        originalType: eventType,
+        detail
+      };
+      try {
+        const res = rec.fn(wildcardEvent);
+        if (res && typeof res.then === "function") {
+          res.catch((error) => {
+            try {
+              handleListenerError(eventType, error);
+            } catch (rethrown) {
+              queueMicrotask(() => {
+                throw rethrown;
+              });
+            }
+          });
+        }
+      } catch (error) {
+        handleListenerError(eventType, error);
+      } finally {
+        if (rec.once)
+          wildcardListeners.delete(rec);
+      }
+    }
+  };
+  const addEventListener = (type, listener, options) => {
+    if (isCompleted) {
+      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);
+    }
+    set.add(record);
+    const unsubscribe = () => {
+      const setNow = listeners.get(type);
+      setNow?.delete(record);
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    };
+    if (opts2.signal) {
+      const onAbort = () => unsubscribe();
+      record.abortHandler = onAbort;
+      opts2.signal.addEventListener("abort", onAbort, { once: true });
+      if (opts2.signal.aborted)
+        onAbort();
+    }
+    return unsubscribe;
+  };
+  const addWildcardListener = (pattern, listener, options) => {
+    if (isCompleted)
+      return () => {};
+    const opts2 = options ?? {};
+    const record = {
+      fn: listener,
+      pattern,
+      once: opts2.once,
+      signal: opts2.signal
+    };
+    wildcardListeners.add(record);
+    const unsubscribe = () => {
+      wildcardListeners.delete(record);
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    };
+    if (opts2.signal) {
+      const onAbort = () => unsubscribe();
+      record.abortHandler = onAbort;
+      opts2.signal.addEventListener("abort", onAbort, { once: true });
+      if (opts2.signal.aborted)
+        onAbort();
+    }
+    return unsubscribe;
+  };
+  const removeWildcardListener = (pattern, listener) => {
+    for (const record of 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;
+    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)) {
+      try {
+        const res = rec.fn(event);
+        if (res && typeof res.then === "function") {
+          res.catch((error) => {
+            try {
+              handleListenerError(event.type, error);
+            } catch (rethrown) {
+              queueMicrotask(() => {
+                throw rethrown;
+              });
+            }
+          });
+        }
+      } catch (error) {
+        handleListenerError(event.type, error);
+      } finally {
+        if (rec.once)
+          set.delete(rec);
+      }
+    }
+    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);
+        }
+        break;
+      }
+    }
+  };
+  const clear = () => {
+    for (const set of listeners.values()) {
+      for (const record of set) {
+        if (record.signal && record.abortHandler) {
+          record.signal.removeEventListener("abort", record.abortHandler);
+        }
+      }
+      set.clear();
+    }
+    listeners.clear();
+    for (const record of wildcardListeners) {
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    }
+    wildcardListeners.clear();
+  };
+  const once = (type, listener, options) => {
+    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);
+          }
+        }
+        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);
+          }
+        }
+        set.clear();
+      }
+      listeners.clear();
+      for (const record of wildcardListeners) {
+        if (record.signal && record.abortHandler) {
+          record.signal.removeEventListener("abort", record.abortHandler);
+        }
+      }
+      wildcardListeners.clear();
+    }
+  };
+  const pipe = (target2, mapFn) => {
+    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);
+        }
+      });
+      unsubscribes.push(unsub);
+    };
+    for (const type of listeners.keys()) {
+      subscribeToType(type);
+    }
+    const completionUnsub = () => {
+      for (const unsub of unsubscribes) {
+        unsub();
+      }
+    };
+    completionCallbacks.add(completionUnsub);
+    return () => {
+      completionCallbacks.delete(completionUnsub);
+      for (const unsub of unsubscribes) {
+        unsub();
+      }
+    };
+  };
+  const complete = () => {
+    if (isCompleted)
+      return;
+    isCompleted = true;
+    for (const cb of completionCallbacks) {
+      try {
+        cb();
+      } catch (err) {
+        try {
+          handleListenerError("complete", err);
+        } catch {}
+      }
+    }
+    completionCallbacks.clear();
+    for (const set of listeners.values()) {
+      for (const record of set) {
+        if (record.signal && record.abortHandler) {
+          record.signal.removeEventListener("abort", record.abortHandler);
+        }
+      }
+      set.clear();
+    }
+    listeners.clear();
+    for (const record of wildcardListeners) {
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    }
+    wildcardListeners.clear();
+  };
+  const subscribe = (type, observerOrNext, error, completeHandler) => {
+    let observer;
+    if (typeof observerOrNext === "function") {
+      observer = {
+        next: observerOrNext,
+        error,
+        complete: completeHandler
+      };
+    } else {
+      observer = observerOrNext ?? {};
+    }
+    let closed = false;
+    if (isCompleted) {
+      if (observer.complete) {
+        try {
+          observer.complete();
+        } catch {}
+      }
+      return {
+        unsubscribe: () => {
+          closed = true;
+        },
+        get closed() {
+          return closed || isCompleted;
+        }
+      };
+    }
+    const unsub = addEventListener(type, (event) => {
+      if (closed)
+        return;
+      if (observer.next) {
+        try {
+          observer.next(event);
+        } catch (err) {
+          if (observer.error) {
+            try {
+              observer.error(err);
+            } catch {}
+          }
+        }
+      }
+    });
+    const onComplete = () => {
+      if (closed)
+        return;
+      closed = true;
+      if (observer.complete) {
+        try {
+          observer.complete();
+        } catch {}
+      }
+    };
+    completionCallbacks.add(onComplete);
+    return {
+      unsubscribe: () => {
+        if (closed)
+          return;
+        closed = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+      },
+      get closed() {
+        return closed || isCompleted;
+      }
+    };
+  };
+  const toObservable = () => {
+    const observable = {
+      subscribe: (observerOrNext, errorFn, completeFn) => {
+        let next;
+        let error;
+        let completeCallback;
+        if (typeof observerOrNext === "function") {
+          next = observerOrNext;
+          error = errorFn;
+          completeCallback = completeFn;
+        } else if (observerOrNext) {
+          next = observerOrNext.next?.bind(observerOrNext);
+          error = observerOrNext.error?.bind(observerOrNext);
+          completeCallback = observerOrNext.complete?.bind(observerOrNext);
+        }
+        let closed = false;
+        if (isCompleted) {
+          if (completeCallback) {
+            try {
+              completeCallback();
+            } catch {}
+          }
+          return {
+            unsubscribe: () => {
+              closed = true;
+            },
+            get closed() {
+              return true;
+            }
+          };
+        }
+        const wildcardListener = (event) => {
+          if (closed)
+            return;
+          if (next) {
+            try {
+              next({ type: event.originalType, detail: event.detail });
+            } catch (err) {
+              if (error) {
+                try {
+                  error(err);
+                } catch {}
+              }
+            }
+          }
+        };
+        const unsubscribe = addWildcardListener("*", wildcardListener);
+        const onComplete = () => {
+          if (closed)
+            return;
+          closed = true;
+          if (completeCallback) {
+            try {
+              completeCallback();
+            } catch {}
+          }
+        };
+        completionCallbacks.add(onComplete);
+        return {
+          unsubscribe: () => {
+            if (closed)
+              return;
+            closed = true;
+            unsubscribe();
+            completionCallbacks.delete(onComplete);
+          },
+          get closed() {
+            return closed || isCompleted;
+          }
+        };
+      },
+      [SymbolObservable]() {
+        return observable;
+      }
+    };
+    return observable;
+  };
+  function events(type, options) {
+    if (isCompleted) {
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next() {
+          return Promise.resolve({
+            value: undefined,
+            done: true
+          });
+        },
+        return() {
+          return Promise.resolve({
+            value: undefined,
+            done: true
+          });
+        }
+      };
+    }
+    const signal = options?.signal;
+    const bufferSize = options?.bufferSize ?? Infinity;
+    const overflowStrategy = options?.overflowStrategy ?? "drop-oldest";
+    const buffer = [];
+    let resolve = null;
+    let done = false;
+    let hasOverflow = false;
+    const unsub = addEventListener(type, (event) => {
+      if (done)
+        return;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: event, done: false });
+      } else {
+        if (buffer.length >= bufferSize && bufferSize !== Infinity) {
+          switch (overflowStrategy) {
+            case "drop-oldest":
+              buffer.shift();
+              buffer.push(event);
+              break;
+            case "drop-latest":
+              break;
+            case "throw":
+              unsub();
+              completionCallbacks.delete(onComplete);
+              done = true;
+              hasOverflow = true;
+              return;
+          }
+        } else {
+          buffer.push(event);
+        }
+      }
+    });
+    const onComplete = () => {
+      done = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined, done: true });
+      }
+    };
+    completionCallbacks.add(onComplete);
+    let onAbort = null;
+    if (signal) {
+      onAbort = () => {
+        done = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: undefined, done: true });
+        }
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    }
+    const iterator = {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        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;
+          }
+          resolve = _resolve;
+        });
+      },
+      return() {
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: undefined, done: true });
+        }
+        done = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+        if (signal && onAbort) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        return Promise.resolve({
+          value: undefined,
+          done: true
+        });
+      }
+    };
+    return iterator;
+  }
+  const target = {
+    addEventListener,
+    removeEventListener,
+    dispatchEvent,
+    clear,
+    once,
+    removeAllListeners,
+    pipe,
+    addWildcardListener,
+    removeWildcardListener,
+    complete,
+    get completed() {
+      return isCompleted;
+    },
+    subscribe,
+    toObservable,
+    events
+  };
+  target[SymbolObservable] = () => {
+    return toObservable();
+  };
+  return target;
+}
+// src/interop.ts
+function forwardToEventTarget(source, target, options) {
+  const unsubscribe = source.addWildcardListener("*", (event) => {
+    const domEvent = {
+      type: event.originalType,
+      detail: event.detail
+    };
+    target.dispatchEvent(domEvent);
+  }, options);
+  return unsubscribe;
+}
+function fromEventTarget(domTarget, eventTypes, options) {
+  const eventful = createEventTarget({
+    onListenerError: options?.onListenerError
+  });
+  const handlers = new Map;
+  for (const type of eventTypes) {
+    const handler = (event) => {
+      eventful.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();
+      eventful.complete();
+    };
+    options.signal.addEventListener("abort", onAbort, { once: true });
+    if (options.signal.aborted)
+      onAbort();
+  }
+  return {
+    addEventListener: eventful.addEventListener,
+    removeEventListener: eventful.removeEventListener,
+    dispatchEvent: eventful.dispatchEvent,
+    clear: eventful.clear,
+    once: eventful.once,
+    removeAllListeners: eventful.removeAllListeners,
+    pipe: eventful.pipe,
+    addWildcardListener: eventful.addWildcardListener,
+    removeWildcardListener: eventful.removeWildcardListener,
+    subscribe: eventful.subscribe,
+    toObservable: eventful.toObservable,
+    complete: eventful.complete,
+    get completed() {
+      return eventful.completed;
+    },
+    events: eventful.events,
+    destroy: () => {
+      if (options?.signal && onAbort) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+      for (const [type, handler] of handlers) {
+        domTarget.removeEventListener(type, handler);
+      }
+      handlers.clear();
+      eventful.complete();
+    }
+  };
+}
+function pipe(source, target, options) {
+  return source.addWildcardListener("*", (event) => {
+    target.dispatchEvent({
+      type: event.originalType,
+      detail: event.detail
+    });
+  }, options);
+}
+// src/eventful.ts
+class Eventful {
+  #target;
+  constructor() {
+    this.#target = createEventTarget();
+  }
+  addEventListener(type, listener, options) {
+    return this.#target.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener) {
+    this.#target.removeEventListener(type, listener);
+  }
+  dispatchEvent(event) {
+    return this.#target.dispatchEvent(event);
+  }
+  once(type, listener, options) {
+    return this.#target.once(type, listener, options);
+  }
+  removeAllListeners(type) {
+    this.#target.removeAllListeners(type);
+  }
+  clear() {
+    this.#target.clear();
+  }
+  pipe(target, mapFn) {
+    return this.#target.pipe(target, mapFn);
+  }
+  addWildcardListener(pattern, listener, options) {
+    return this.#target.addWildcardListener(pattern, listener, options);
+  }
+  removeWildcardListener(pattern, listener) {
+    this.#target.removeWildcardListener(pattern, listener);
+  }
+  subscribe(typeOrObserver, observerOrNext, error, completeHandler) {
+    if (typeof typeOrObserver === "string") {
+      return this.#target.subscribe(typeOrObserver, observerOrNext, error, completeHandler);
+    }
+    if (typeof typeOrObserver === "function") {
+      return this.#target.toObservable().subscribe(typeOrObserver);
+    }
+    if (typeof typeOrObserver === "object" && typeOrObserver !== null) {
+      const maybeObserver = typeOrObserver;
+      if (typeof maybeObserver.next === "function" || typeof maybeObserver.error === "function" || typeof maybeObserver.complete === "function") {
+        return this.#target.toObservable().subscribe(typeOrObserver);
+      }
+      return this.#target.toObservable().subscribe({});
+    }
+    throw new Error("subscribe() requires a string event type, callback function, or observer object");
+  }
+  toObservable() {
+    return this.#target.toObservable();
+  }
+  [SymbolObservable]() {
+    return this.toObservable();
+  }
+  complete() {
+    this.#target.complete();
+  }
+  get completed() {
+    return this.#target.completed;
+  }
+  events(type, options) {
+    return this.#target.events(type, options);
+  }
+}
+})
+
+//# debugId=C000AD057E5BF10964756E2164756E21