brave-real-puppeteer-core 24.25.0 → 24.33.0-patch.1

package/src/cdp/NetworkManager.ts

@@ -88,6 +88,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     ['Fetch.requestPaused', this.#onRequestPaused],
     ['Fetch.authRequired', this.#onAuthRequired],
     ['Network.requestWillBeSent', this.#onRequestWillBeSent],
+    ['Network.requestWillBeSentExtraInfo', this.#onRequestWillBeSentExtraInfo],
     ['Network.requestServedFromCache', this.#onRequestServedFromCache],
     ['Network.responseReceived', this.#onResponseReceived],
     ['Network.loadingFinished', this.#onLoadingFinished],
@@ -108,7 +109,9 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
   #canIgnoreError(error: unknown) {
     return (
       isErrorLike(error) &&
-      (isTargetClosedError(error) || error.message.includes('Not supported'))
+      (isTargetClosedError(error) ||
+        error.message.includes('Not supported') ||
+        error.message.includes("wasn't found"))
     );
   }
 
@@ -534,6 +537,13 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
           redirectResponseExtraInfo,
         );
         redirectChain = request._redirectChain;
+
+        const extraInfo = this.#networkEventManager
+          .requestExtraInfo(event.requestId)
+          .shift();
+        if (extraInfo) {
+          request.updateHeaders(extraInfo.headers);
+        }
       }
     }
     const frame = event.frameId
@@ -548,12 +558,32 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
       event,
       redirectChain,
     );
+
+    const extraInfo = this.#networkEventManager
+      .requestExtraInfo(event.requestId)
+      .shift();
+    if (extraInfo) {
+      request.updateHeaders(extraInfo.headers);
+    }
+
     request._fromMemoryCache = fromMemoryCache;
     this.#networkEventManager.storeRequest(event.requestId, request);
     this.emit(NetworkManagerEvent.Request, request);
     void request.finalizeInterceptions();
   }
 
+  #onRequestWillBeSentExtraInfo(
+    _client: CDPSession,
+    event: Protocol.Network.RequestWillBeSentExtraInfoEvent,
+  ): void {
+    const request = this.#networkEventManager.getRequest(event.requestId);
+    if (request) {
+      request.updateHeaders(event.headers);
+    } else {
+      this.#networkEventManager.requestExtraInfo(event.requestId).push(event);
+    }
+  }
+
   #onRequestServedFromCache(
     client: CDPSession,
     event: Protocol.Network.RequestServedFromCacheEvent,

package/src/cdp/Page.ts

@@ -7,14 +7,16 @@
 import type {Protocol} from 'devtools-protocol';
 
 import {firstValueFrom, from, raceWith} from '../../third_party/rxjs/rxjs.js';
-import type {Browser} from '../api/Browser.js';
+import type {BluetoothEmulation} from '../api/BluetoothEmulation.js';
+import type {Browser, WindowId} from '../api/Browser.js';
 import type {BrowserContext} from '../api/BrowserContext.js';
 import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import type {ElementHandle} from '../api/ElementHandle.js';
 import type {Frame, WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {JSHandle} from '../api/JSHandle.js';
-import type {Credentials} from '../api/Page.js';
+import type {Credentials, ReloadOptions} from '../api/Page.js';
 import {
   Page,
   PageEvent,
@@ -58,10 +60,11 @@ import {AsyncDisposableStack} from '../util/disposable.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
 import {Binding} from './Binding.js';
+import {CdpBluetoothEmulation} from './BluetoothEmulation.js';
+import type {CdpBrowser} from './Browser.js';
 import {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
 import {Coverage} from './Coverage.js';
-import type {DeviceRequestPrompt} from './DeviceRequestPrompt.js';
 import {CdpDialog} from './Dialog.js';
 import {EmulationManager} from './EmulationManager.js';
 import type {CdpFrame} from './Frame.js';
@@ -119,6 +122,7 @@ export class CdpPage extends Page {
 
   #closed = false;
   readonly #targetManager: TargetManager;
+  readonly #cdpBluetoothEmulation: CdpBluetoothEmulation;
 
   #primaryTargetClient: CdpCDPSession;
   #primaryTarget: CdpTarget;
@@ -158,6 +162,12 @@ export class CdpPage extends Page {
     this.#coverage = new Coverage(client);
     this.#viewport = null;
 
+    // Use browser context's connection, as current Bluetooth emulation in Chromium is
+    // implemented on the browser context level, and not tight to the specific tab.
+    this.#cdpBluetoothEmulation = new CdpBluetoothEmulation(
+      this.#primaryTargetClient.connection(),
+    );
+
     const frameManagerEmitter = new EventEmitter(this.#frameManager);
     frameManagerEmitter.on(FrameManagerEvent.FrameAttached, frame => {
       this.emit(PageEvent.FrameAttached, frame);
@@ -365,17 +375,22 @@ export class CdpPage extends Page {
     contentWidth: number;
     contentHeight: number;
   }): Promise<void> {
-    const {windowId} = await this.#primaryTargetClient.send(
-      'Browser.getWindowForTarget',
-    );
-
+    const windowId = await this.windowId();
     await this.#primaryTargetClient.send('Browser.setContentsSize', {
-      windowId,
+      windowId: Number(windowId),
       width: params.contentWidth,
       height: params.contentHeight,
     });
   }
 
+  override async windowId(): Promise<WindowId> {
+    const {windowId} = await this.#primaryTargetClient.send(
+      'Browser.getWindowForTarget',
+    );
+
+    return windowId.toString();
+  }
+
   async #onFileChooser(
     event: Protocol.Page.FileChooserOpenedEvent,
   ): Promise<void> {
@@ -417,6 +432,13 @@ export class CdpPage extends Page {
     return this.#emulationManager.javascriptEnabled;
   }
 
+  override async openDevTools(): Promise<Page> {
+    const pageTargetId = this.target()._targetId;
+    const browser = this.browser() as CdpBrowser;
+    const devtoolsPage = await browser._createDevToolsPage(pageTargetId);
+    return devtoolsPage;
+  }
+
   override async waitForFileChooser(
     options: WaitTimeoutOptions = {},
   ): Promise<FileChooser> {
@@ -480,7 +502,8 @@ export class CdpPage extends Page {
   }
 
   #onLogEntryAdded(event: Protocol.Log.EntryAddedEvent): void {
-    const {level, text, args, source, url, lineNumber} = event.entry;
+    const {level, text, args, source, url, lineNumber, stackTrace} =
+      event.entry;
     if (args) {
       args.map(arg => {
         void releaseObject(this.#primaryTargetClient, arg);
@@ -494,6 +517,8 @@ export class CdpPage extends Page {
           text,
           [],
           [{url, lineNumber}],
+          undefined,
+          stackTrace,
         ),
       );
     }
@@ -560,6 +585,10 @@ export class CdpPage extends Page {
     );
   }
 
+  override async emulateFocusedPage(enabled: boolean): Promise<void> {
+    return await this.#emulationManager.emulateFocus(enabled);
+  }
+
   override setDefaultNavigationTimeout(timeout: number): void {
     this._timeoutSettings.setDefaultNavigationTimeout(timeout);
   }
@@ -859,7 +888,7 @@ export class CdpPage extends Page {
     }
     const textTokens = [];
     // eslint-disable-next-line max-len -- The comment is long.
-    // eslint-disable-next-line rulesdir/use-using -- These are not owned by this function.
+    // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
     for (const arg of args) {
       const remoteObject = arg.remoteObject();
       if (remoteObject.objectId) {
@@ -883,6 +912,8 @@ export class CdpPage extends Page {
       textTokens.join(' '),
       args,
       stackTraceLocations,
+      undefined,
+      stackTrace,
     );
     this.emit(PageEvent.Console, message);
   }
@@ -898,15 +929,15 @@ export class CdpPage extends Page {
     this.emit(PageEvent.Dialog, dialog);
   }
 
-  override async reload(
-    options?: WaitForOptions,
-  ): Promise<HTTPResponse | null> {
+  override async reload(options?: ReloadOptions): Promise<HTTPResponse | null> {
     const [result] = await Promise.all([
       this.waitForNavigation({
         ...options,
         ignoreSameDocumentNavigation: true,
       }),
-      this.#primaryTargetClient.send('Page.reload'),
+      this.#primaryTargetClient.send('Page.reload', {
+        ignoreCache: options?.ignoreCache ?? false,
+      }),
     ]);
 
     return result;
@@ -1219,6 +1250,10 @@ export class CdpPage extends Page {
   ): Promise<DeviceRequestPrompt> {
     return await this.mainFrame().waitForDevicePrompt(options);
   }
+
+  override get bluetooth(): BluetoothEmulation {
+    return this.#cdpBluetoothEmulation;
+  }
 }
 
 const supportedMetrics = new Set<string>([

package/src/cdp/TargetManager.ts

@@ -15,7 +15,8 @@ import {Deferred} from '../util/Deferred.js';
 
 import {CdpCDPSession} from './CdpSession.js';
 import type {Connection} from './Connection.js';
-import {CdpTarget, InitializationStatus} from './Target.js';
+import type {CdpTarget} from './Target.js';
+import {InitializationStatus} from './Target.js';
 import type {TargetManagerEvents} from './TargetManageEvents.js';
 import {TargetManagerEvent} from './TargetManageEvents.js';
 
@@ -90,10 +91,20 @@ export class TargetManager
   >();
 
   #initializeDeferred = Deferred.create<void>();
-  #targetsIdsForInit = new Set<string>();
   #waitForInitiallyDiscoveredTargets = true;
 
   #discoveryFilter: Protocol.Target.FilterEntry[] = [{}];
+  // IDs of tab targets detected while running the initial Target.setAutoAttach
+  // request. These are the targets whose initialization we want to await for
+  // before resolving puppeteer.connect() or launch() to avoid flakiness.
+  // Whenever a sub-target whose parent is a tab target is attached, we remove
+  // the tab target from this list. Once the list is empty, we resolve the
+  // initializeDeferred.
+  #targetsIdsForInit = new Set<string>();
+  // This is false until the connection-level Target.setAutoAttach request is
+  // done. It indicates whethere we are running the initial auto-attach step or
+  // if we are handling targets after that.
+  #initialAttachDone = false;
 
   constructor(
     connection: Connection,
@@ -117,45 +128,12 @@ export class TargetManager
     this.#setupAttachmentListeners(this.#connection);
   }
 
-  #storeExistingTargetsForInit = () => {
-    if (!this.#waitForInitiallyDiscoveredTargets) {
-      return;
-    }
-    for (const [
-      targetId,
-      targetInfo,
-    ] of this.#discoveredTargetsByTargetId.entries()) {
-      const targetForFilter = new CdpTarget(
-        targetInfo,
-        undefined,
-        undefined,
-        this,
-        undefined,
-      );
-      // Only wait for pages and frames (except those from extensions)
-      // to auto-attach.
-      const isPageOrFrame =
-        targetInfo.type === 'page' || targetInfo.type === 'iframe';
-      const isExtension = targetInfo.url.startsWith('chrome-extension://');
-      if (
-        (!this.#targetFilterCallback ||
-          this.#targetFilterCallback(targetForFilter)) &&
-        isPageOrFrame &&
-        !isExtension
-      ) {
-        this.#targetsIdsForInit.add(targetId);
-      }
-    }
-  };
-
   async initialize(): Promise<void> {
     await this.#connection.send('Target.setDiscoverTargets', {
       discover: true,
       filter: this.#discoveryFilter,
     });
 
-    this.#storeExistingTargetsForInit();
-
     await this.#connection.send('Target.setAutoAttach', {
       waitForDebuggerOnStart: true,
       flatten: true,
@@ -168,6 +146,7 @@ export class TargetManager
         ...this.#discoveryFilter,
       ],
     });
+    this.#initialAttachDone = true;
     this.#finishInitializationIfReady();
     await this.#initializeDeferred.valueOrThrow();
   }
@@ -346,7 +325,6 @@ export class TargetManager
     // should determine if a target is auto-attached or not with the help of
     // CDP.
     if (targetInfo.type === 'service_worker') {
-      this.#finishInitializationIfReady(targetInfo.targetId);
       await silentDetach();
       if (this.#attachedTargetsByTargetId.has(targetInfo.targetId)) {
         return;
@@ -370,13 +348,26 @@ export class TargetManager
           parentSession instanceof CdpCDPSession ? parentSession : undefined,
         );
 
+    const parentTarget =
+      parentSession instanceof CdpCDPSession ? parentSession.target() : null;
+
     if (this.#targetFilterCallback && !this.#targetFilterCallback(target)) {
       this.#ignoredTargets.add(targetInfo.targetId);
-      this.#finishInitializationIfReady(targetInfo.targetId);
+      if (parentTarget?.type() === 'tab') {
+        this.#finishInitializationIfReady(parentTarget._targetId);
+      }
       await silentDetach();
       return;
     }
 
+    if (
+      this.#waitForInitiallyDiscoveredTargets &&
+      event.targetInfo.type === 'tab' &&
+      !this.#initialAttachDone
+    ) {
+      this.#targetsIdsForInit.add(event.targetInfo.targetId);
+    }
+
     this.#setupAttachmentListeners(session);
 
     if (isExistingTarget) {
@@ -391,19 +382,16 @@ export class TargetManager
       this.#attachedTargetsBySessionId.set(session.id(), target);
     }
 
-    const parentTarget =
-      parentSession instanceof CDPSession
-        ? (parentSession as CdpCDPSession).target()
-        : null;
     parentTarget?._addChildTarget(target);
 
     parentSession.emit(CDPSessionEvent.Ready, session);
 
-    this.#targetsIdsForInit.delete(target._targetId);
     if (!isExistingTarget) {
       this.emit(TargetManagerEvent.TargetAvailable, target);
     }
-    this.#finishInitializationIfReady();
+    if (parentTarget?.type() === 'tab') {
+      this.#finishInitializationIfReady(parentTarget._targetId);
+    }
 
     // TODO: the browser might be shutting down here. What do we do with the
     // error?
@@ -422,6 +410,11 @@ export class TargetManager
     if (targetId !== undefined) {
       this.#targetsIdsForInit.delete(targetId);
     }
+    // If we are still initializing it might be that we have not learned about
+    // some targets yet.
+    if (!this.#initialAttachDone) {
+      return;
+    }
     if (this.#targetsIdsForInit.size === 0) {
       this.#initializeDeferred.resolve();
     }

package/src/cdp/WebWorker.ts

@@ -114,9 +114,8 @@ export class CdpWebWorker extends WebWorker {
 
   override async close(): Promise<void> {
     switch (this.#targetType) {
-      case TargetType.SERVICE_WORKER:
-      case TargetType.SHARED_WORKER: {
-        // For service and shared workers we need to close the target and detach to allow
+      case TargetType.SERVICE_WORKER: {
+        // For service workers we need to close the target and detach to allow
         // the worker to stop.
         await this.client.connection()?.send('Target.closeTarget', {
           targetId: this.#id,
@@ -126,6 +125,12 @@ export class CdpWebWorker extends WebWorker {
         });
         break;
       }
+      case TargetType.SHARED_WORKER: {
+        await this.client.connection()?.send('Target.closeTarget', {
+          targetId: this.#id,
+        });
+        break;
+      }
       default:
         await this.evaluate(() => {
           self.close();

package/src/cdp/cdp.ts

@@ -6,6 +6,7 @@
 
 export * from './Accessibility.js';
 export * from './Binding.js';
+export * from './BluetoothEmulation.js';
 export * from './Browser.js';
 export * from './BrowserContext.js';
 export * from './BrowserConnector.js';

package/src/cdp/utils.ts

@@ -94,7 +94,7 @@ const getErrorDetails = (details: Protocol.Runtime.ExceptionDetails) => {
  */
 export function createClientError(
   details: Protocol.Runtime.ExceptionDetails,
-): Error {
+): Error | unknown {
   let name: string;
   let message: string;
   if (!details.exception) {
@@ -141,7 +141,7 @@ export function createClientError(
  */
 export function valueFromRemoteObject(
   remoteObject: Protocol.Runtime.RemoteObject,
-): any {
+): unknown {
   assert(!remoteObject.objectId, 'Cannot extract value when objectId is given');
   if (remoteObject.unserializableValue) {
     if (remoteObject.type === 'bigint') {

package/src/common/BrowserConnector.ts

@@ -7,7 +7,7 @@
 import type {Browser} from '../api/Browser.js';
 import {_connectToBiDiBrowser} from '../bidi/BrowserConnector.js';
 import {_connectToCdpBrowser} from '../cdp/BrowserConnector.js';
-import {isNode} from '../environment.js';
+import {environment, isNode} from '../environment.js';
 import {assert} from '../util/assert.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
@@ -57,12 +57,21 @@ export async function _connectToBrowser(
 async function getConnectionTransport(
   options: ConnectOptions,
 ): Promise<{connectionTransport: ConnectionTransport; endpointUrl: string}> {
-  const {browserWSEndpoint, browserURL, transport, headers = {}} = options;
+  const {
+    browserWSEndpoint,
+    browserURL,
+    channel,
+    transport,
+    headers = {},
+  } = options;
 
   assert(
-    Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) ===
+    Number(!!browserWSEndpoint) +
+      Number(!!browserURL) +
+      Number(!!transport) +
+      Number(!!channel) ===
       1,
-    'Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect',
+    'Exactly one of browserWSEndpoint, browserURL, transport or channel must be passed to puppeteer.connect',
   );
 
   if (transport) {
@@ -84,6 +93,60 @@ async function getConnectionTransport(
       connectionTransport: connectionTransport,
       endpointUrl: connectionURL,
     };
+  } else if (options.channel && isNode) {
+    const {detectBrowserPlatform, resolveDefaultUserDataDir, Browser} =
+      await import('@puppeteer/browsers');
+    const platform = detectBrowserPlatform();
+    if (!platform) {
+      throw new Error('Could not detect required browser platform');
+    }
+    const {convertPuppeteerChannelToBrowsersChannel} =
+      await import('../node/LaunchOptions.js');
+    const {join} = await import('node:path');
+    const userDataDir = resolveDefaultUserDataDir(
+      Browser.CHROME,
+      platform,
+      convertPuppeteerChannelToBrowsersChannel(options.channel),
+    );
+    const portPath = join(userDataDir, 'DevToolsActivePort');
+    try {
+      const fileContent = await environment.value.fs.promises.readFile(
+        portPath,
+        'ascii',
+      );
+      const [rawPort, rawPath] = fileContent
+        .split('\n')
+        .map(line => {
+          return line.trim();
+        })
+        .filter(line => {
+          return !!line;
+        });
+      if (!rawPort || !rawPath) {
+        throw new Error(`Invalid DevToolsActivePort '${fileContent}' found`);
+      }
+      const port = parseInt(rawPort, 10);
+      if (isNaN(port) || port <= 0 || port > 65535) {
+        throw new Error(`Invalid port '${rawPort}' found`);
+      }
+      const browserWSEndpoint = `ws://localhost:${port}${rawPath}`;
+      const WebSocketClass = await getWebSocketTransportClass();
+      const connectionTransport = await WebSocketClass.create(
+        browserWSEndpoint,
+        headers,
+      );
+      return {
+        connectionTransport: connectionTransport,
+        endpointUrl: browserWSEndpoint,
+      };
+    } catch (error) {
+      throw new Error(
+        `Could not find DevToolsActivePort for ${options.channel} at ${portPath}`,
+        {
+          cause: error,
+        },
+      );
+    }
   }
   throw new Error('Invalid connection options');
 }

package/src/common/CallbackRegistry.ts

@@ -6,21 +6,23 @@
 
 import {Deferred} from '../util/Deferred.js';
 import {rewriteError} from '../util/ErrorLike.js';
-import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
+import type {GetIdFn} from '../util/incremental-id-generator.js';
 
 import {ProtocolError, TargetCloseError} from './Errors.js';
 import {debugError} from './util.js';
 
-const idGenerator = createIncrementalIdGenerator();
-
 /**
  * Manages callbacks and their IDs for the protocol request/response communication.
  *
  * @internal
  */
 export class CallbackRegistry {
-  #callbacks = new Map<number, Callback>();
-  #idGenerator = idGenerator;
+  readonly #callbacks = new Map<number, Callback>();
+  readonly #idGenerator: GetIdFn;
+
+  constructor(idGenerator: GetIdFn) {
+    this.#idGenerator = idGenerator;
+  }
 
   create(
     label: string,

package/src/common/ConnectOptions.ts

@@ -38,6 +38,15 @@ export interface SupportedWebDriverCapabilities {
   alwaysMatch?: SupportedWebDriverCapability;
 }
 
+/**
+ * @public
+ */
+export type ChromeReleaseChannel =
+  | 'chrome'
+  | 'chrome-beta'
+  | 'chrome-canary'
+  | 'chrome-dev';
+
 /**
  * Generic browser options that can be passed when launching any browser or when
  * connecting to an existing browser instance.
@@ -49,6 +58,17 @@ export interface ConnectOptions {
    * @defaultValue `false`
    */
   acceptInsecureCerts?: boolean;
+  /**
+   * If specified, puppeteer looks for an open WebSocket at the well-known
+   * default user data directory for the specified channel and attempts to
+   * connect to it using ws://localhost:$ActivePort/devtools/browser. Only works
+   * for Chrome and when run in Node.js.
+   *
+   * This option is experimental when used with puppeteer.connect().
+   *
+   * @experimental
+   */
+  channel?: ChromeReleaseChannel;
   /**
    * Experimental setting to disable monitoring network events by default. When
    * set to `false`, parts of Puppeteer that depend on network events would not
@@ -112,6 +132,14 @@ export interface ConnectOptions {
   browserWSEndpoint?: string;
   browserURL?: string;
   transport?: ConnectionTransport;
+  /**
+   * @internal
+   *
+   * Custom ID generator for CDP / BiDi messages. Useful if the same transport
+   * is shared for multiple connections.
+   */
+  idGenerator?: () => number;
+
   /**
    * Headers to use for the web socket connection.
    * @remarks

package/src/common/ConsoleMessage.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {Protocol} from 'devtools-protocol';
+
 import type {Frame} from '../api/Frame.js';
 import type {JSHandle} from '../api/JSHandle.js';
 
@@ -62,6 +64,7 @@ export class ConsoleMessage {
   #args: JSHandle[];
   #stackTraceLocations: ConsoleMessageLocation[];
   #frame?: Frame;
+  #rawStackTrace?: Protocol.Runtime.StackTrace;
 
   /**
    * @internal
@@ -72,12 +75,14 @@ export class ConsoleMessage {
     args: JSHandle[],
     stackTraceLocations: ConsoleMessageLocation[],
     frame?: Frame,
+    rawStackTrace?: Protocol.Runtime.StackTrace,
   ) {
     this.#type = type;
     this.#text = text;
     this.#args = args;
     this.#stackTraceLocations = stackTraceLocations;
     this.#frame = frame;
+    this.#rawStackTrace = rawStackTrace;
   }
 
   /**
@@ -117,4 +122,13 @@ export class ConsoleMessage {
   stackTrace(): ConsoleMessageLocation[] {
     return this.#stackTraceLocations;
   }
+
+  /**
+   * The underlying protocol stack trace if available.
+   *
+   * @internal
+   */
+  _rawStackTrace(): Protocol.Runtime.StackTrace | undefined {
+    return this.#rawStackTrace;
+  }
 }

package/src/common/EventEmitter.ts

@@ -56,9 +56,9 @@ export type EventsWithWildcard<Events extends Record<EventType, unknown>> =
  *
  * @public
  */
-export class EventEmitter<Events extends Record<EventType, unknown>>
-  implements CommonEventEmitter<EventsWithWildcard<Events>>
-{
+export class EventEmitter<
+  Events extends Record<EventType, unknown>,
+> implements CommonEventEmitter<EventsWithWildcard<Events>> {
   #emitter: Emitter<EventsWithWildcard<Events>> | EventEmitter<Events>;
   #handlers = new Map<keyof Events | '*', Array<Handler<any>>>();