1 files changed, 40 insertions, 28 deletions

diff --git a/std/node/events.ts b/std/node/events.ts
index b267852aa..bc27731ca 100644
--- a/std/node/events.ts
+++ b/std/node/events.ts
@@ -24,8 +24,11 @@
 import { validateIntegerRange } from "./util.ts";
 import { assert } from "../_util/assert.ts";
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GenericFunction = (...args: any[]) => any;
+
 export interface WrappedFunction extends Function {
-  listener: Function;
+  listener: GenericFunction;
 }
 
 /**
@@ -35,7 +38,10 @@ export default class EventEmitter {
   public static defaultMaxListeners = 10;
   public static errorMonitor = Symbol("events.errorMonitor");
   private maxListeners: number | undefined;
-  private _events: Map<string | symbol, Array<Function | WrappedFunction>>;
+  private _events: Map<
+    string | symbol,
+    Array<GenericFunction | WrappedFunction>
+  >;
 
   public constructor() {
     this._events = new Map();
@@ -43,13 +49,13 @@ export default class EventEmitter {
 
   private _addListener(
     eventName: string | symbol,
-    listener: Function | WrappedFunction,
+    listener: GenericFunction | WrappedFunction,
     prepend: boolean,
   ): this {
     this.emit("newListener", eventName, listener);
     if (this._events.has(eventName)) {
       const listeners = this._events.get(eventName) as Array<
-        Function | WrappedFunction
+        GenericFunction | WrappedFunction
       >;
       if (prepend) {
         listeners.unshift(listener);
@@ -76,7 +82,7 @@ export default class EventEmitter {
   /** Alias for emitter.on(eventName, listener). */
   public addListener(
     eventName: string | symbol,
-    listener: Function | WrappedFunction,
+    listener: GenericFunction | WrappedFunction,
   ): this {
     return this._addListener(eventName, listener, false);
   }
@@ -96,7 +102,9 @@ export default class EventEmitter {
       ) {
         this.emit(EventEmitter.errorMonitor, ...args);
       }
-      const listeners = (this._events.get(eventName) as Function[]).slice(); // We copy with slice() so array is not mutated during emit
+      const listeners = (this._events.get(
+        eventName,
+      ) as GenericFunction[]).slice(); // We copy with slice() so array is not mutated during emit
       for (const listener of listeners) {
         try {
           listener.apply(this, args);
@@ -138,7 +146,7 @@ export default class EventEmitter {
    */
   public listenerCount(eventName: string | symbol): number {
     if (this._events.has(eventName)) {
-      return (this._events.get(eventName) as Function[]).length;
+      return (this._events.get(eventName) as GenericFunction[]).length;
     } else {
       return 0;
     }
@@ -148,21 +156,19 @@ export default class EventEmitter {
     target: EventEmitter,
     eventName: string | symbol,
     unwrap: boolean,
-  ): Function[] {
+  ): GenericFunction[] {
     if (!target._events.has(eventName)) {
       return [];
     }
-    const eventListeners: Function[] = target._events.get(
-      eventName,
-    ) as Function[];
+    const eventListeners = target._events.get(eventName) as GenericFunction[];
 
     return unwrap
       ? this.unwrapListeners(eventListeners)
       : eventListeners.slice(0);
   }
 
-  private unwrapListeners(arr: Function[]): Function[] {
-    const unwrappedListeners: Function[] = new Array(arr.length) as Function[];
+  private unwrapListeners(arr: GenericFunction[]): GenericFunction[] {
+    const unwrappedListeners = new Array(arr.length) as GenericFunction[];
     for (let i = 0; i < arr.length; i++) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       unwrappedListeners[i] = (arr[i] as any)["listener"] || arr[i];
@@ -171,7 +177,7 @@ export default class EventEmitter {
   }
 
   /** Returns a copy of the array of listeners for the event named eventName.*/
-  public listeners(eventName: string | symbol): Function[] {
+  public listeners(eventName: string | symbol): GenericFunction[] {
     return this._listeners(this, eventName, true);
   }
 
@@ -181,12 +187,12 @@ export default class EventEmitter {
    */
   public rawListeners(
     eventName: string | symbol,
-  ): Array<Function | WrappedFunction> {
+  ): Array<GenericFunction | WrappedFunction> {
     return this._listeners(this, eventName, false);
   }
 
   /** Alias for emitter.removeListener(). */
-  public off(eventName: string | symbol, listener: Function): this {
+  public off(eventName: string | symbol, listener: GenericFunction): this {
     return this.removeListener(eventName, listener);
   }
 
@@ -199,7 +205,7 @@ export default class EventEmitter {
    */
   public on(
     eventName: string | symbol,
-    listener: Function | WrappedFunction,
+    listener: GenericFunction | WrappedFunction,
   ): this {
     return this.addListener(eventName, listener);
   }
@@ -208,7 +214,7 @@ export default class EventEmitter {
    * Adds a one-time listener function for the event named eventName. The next
    * time eventName is triggered, this listener is removed and then invoked.
    */
-  public once(eventName: string | symbol, listener: Function): this {
+  public once(eventName: string | symbol, listener: GenericFunction): this {
     const wrapped: WrappedFunction = this.onceWrap(eventName, listener);
     this.on(eventName, wrapped);
     return this;
@@ -217,19 +223,22 @@ export default class EventEmitter {
   // Wrapped function that calls EventEmitter.removeListener(eventName, self) on execution.
   private onceWrap(
     eventName: string | symbol,
-    listener: Function,
+    listener: GenericFunction,
   ): WrappedFunction {
     const wrapper = function (
       this: {
         eventName: string | symbol;
-        listener: Function;
-        rawListener: Function;
+        listener: GenericFunction;
+        rawListener: GenericFunction | WrappedFunction;
         context: EventEmitter;
       },
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ...args: any[]
     ): void {
-      this.context.removeListener(this.eventName, this.rawListener);
+      this.context.removeListener(
+        this.eventName,
+        this.rawListener as GenericFunction,
+      );
       this.listener.apply(this.context, args);
     };
     const wrapperContext = {
@@ -255,7 +264,7 @@ export default class EventEmitter {
    */
   public prependListener(
     eventName: string | symbol,
-    listener: Function | WrappedFunction,
+    listener: GenericFunction | WrappedFunction,
   ): this {
     return this._addListener(eventName, listener, true);
   }
@@ -267,7 +276,7 @@ export default class EventEmitter {
    */
   public prependOnceListener(
     eventName: string | symbol,
-    listener: Function,
+    listener: GenericFunction,
   ): this {
     const wrapped: WrappedFunction = this.onceWrap(eventName, listener);
     this.prependListener(eventName, wrapped);
@@ -283,7 +292,7 @@ export default class EventEmitter {
     if (eventName) {
       if (this._events.has(eventName)) {
         const listeners = (this._events.get(eventName) as Array<
-          Function | WrappedFunction
+          GenericFunction | WrappedFunction
         >).slice(); // Create a copy; We use it AFTER it's deleted.
         this._events.delete(eventName);
         for (const listener of listeners) {
@@ -304,10 +313,13 @@ export default class EventEmitter {
    * Removes the specified listener from the listener array for the event
    * named eventName.
    */
-  public removeListener(eventName: string | symbol, listener: Function): this {
+  public removeListener(
+    eventName: string | symbol,
+    listener: GenericFunction,
+  ): this {
     if (this._events.has(eventName)) {
       const arr:
-        | Array<Function | WrappedFunction>
+        | Array<GenericFunction | WrappedFunction>
         | undefined = this._events.get(eventName);
 
       assert(arr);
@@ -382,7 +394,7 @@ export function once(
         }
         resolve(args);
       };
-      let errorListener: Function;
+      let errorListener: GenericFunction;
 
       // Adding an error listener is not optional because
       // if an error is thrown on an event emitter we cannot