### Install typescript-event-target via NPM

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

Install the package using npm. Then import the TypedEventTarget class.

```bash
npm i --save typescript-event-target
```

```typescript
import { TypedEventTarget } from 'typescript-event-target';
```

--------------------------------

### Install TypedEventTarget with NPM

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Install the typescript-event-target package using npm for use in Node.js projects.

```bash
npm i --save typescript-event-target
```

--------------------------------

### Install typescript-event-target via Deno

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

Install the package from JSR or import directly from deno.land/x. It is recommended to pin to a specific version.

```bash
deno add @derzade/typescript-event-target
```

```typescript
import { TypedEventTarget } from 'https://deno.land/x/typescript_event_target/mod.ts';
```

```typescript
import { TypedEventTarget } from 'https://deno.land/x/typescript_event_target@v1.0.0/mod.ts';
```

--------------------------------

### Install TypedEventTarget with Deno (JSR)

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Add the typescript-event-target package from JSR for use in Deno projects.

```bash
deno add @derzade/typescript-event-target
```

--------------------------------

### Import TypedEventTarget from NPM

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Import the TypedEventTarget class from the installed npm package.

```typescript
import { TypedEventTarget } from 'typescript-event-target';
```

--------------------------------

### TypedEventTarget removeEventListener Example

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Demonstrates removing an event listener using removeEventListener. The callback must match the type declared in the event map.

```typescript
import { TypedEventTarget } from 'typescript-event-target';

interface ClockEventMap {
    tick: CustomEvent<number>;
}

const clock = new TypedEventTarget<ClockEventMap>();

const onTick = (e: CustomEvent<number>) => {
    console.log('Tick:', e.detail);
    // Remove itself after the first call
    clock.removeEventListener('tick', onTick);
};

clock.addEventListener('tick', onTick);

clock.dispatchTypedEvent('tick', new CustomEvent('tick', { detail: Date.now() })); // logs once
clock.dispatchTypedEvent('tick', new CustomEvent('tick', { detail: Date.now() })); // no-op
```

--------------------------------

### Import TypedEventTarget from Deno.land/x

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Import TypedEventTarget directly from a pinned version on deno.land/x.

```typescript
import { TypedEventTarget } from 'https://deno.land/x/typescript_event_target@v1.1.2/mod.ts';
```

--------------------------------

### Import TypedEventTarget from Deno (JSR)

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Import the TypedEventTarget class from the Deno JSR registry.

```typescript
import { TypedEventTarget } from '@derzade/typescript-event-target';
```

--------------------------------

### TypedEventTarget addEventListener with Options and EventListenerObject

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Shows how to use addEventListener with options like 'once', 'passive', and 'capture', and how to use an EventListenerObject for handling events.

```typescript
import { TypedEventTarget } from 'typescript-event-target';

interface SensorEventMap {
    data:       CustomEvent<{ temperature: number; humidity: number }>;
    disconnect: Event;
}

const sensor = new TypedEventTarget<SensorEventMap>();

// Callback type is inferred as (e: CustomEvent<{temperature: number, humidity: number}>) => void
sensor.addEventListener('data', (e) => {
    const { temperature, humidity } = e.detail; // ✅ fully typed
    console.log(`Temp: ${temperature}°C  Humidity: ${humidity}%`);
}, { once: false, passive: true });

// Using an EventListenerObject (handleEvent pattern)
const disconnectHandler = {
    handleEvent(e: Event) {
        console.log('Sensor disconnected');
    }
};
sensor.addEventListener('disconnect', disconnectHandler);
```

--------------------------------

### Basic TypedEventTarget Usage

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

Create an interface for your event map, then instantiate TypedEventTarget with this map. Event listeners will be strictly typed.

```typescript
// Step 1: Create an interface,
// which
// includes all dispatchable events
interface MyEventMap {
    hello: Event;
    time: CustomEvent<number>;
}

// Step 2: Create your TypedEventTarget, with
// the EventMap as the type parameter
const eventTarget = new TypedEventTarget<MyEventMap>();

// Step 3: Strictly typed EventListeners 🎉
eventTarget.addEventListener('time', (event) => {
    // event is of type CustomEvent<number>

    const time = event.detail;

    // time is of type number
});
```

--------------------------------

### Using Different Event Types

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

The `EventMap` can include native `Event` types like `MouseEvent` and `KeyboardEvent`, as well as custom event classes that extend `Event`.

```typescript
class MyEvent extends Event {
    /* [...] */
}

class MyEventMap {
    boring: Event;
    custom: CustomEvent<number>;
    mine: MyEvent;
    mouse: MouseEvent;
    keyboard: KeyboardEvent;
}

const eventTarget = new TypedEventTarget<MyEventMap>();

eventTarget.addEventListener('mine', (e) => {
    // e is of type MyEvent
});
```

--------------------------------

### TypedEventTarget Basic Usage

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Demonstrates defining an event map and using TypedEventTarget with addEventListener and dispatchTypedEvent. TypeScript enforces type correctness for event names and details.

```typescript
import { TypedEventTarget } from 'typescript-event-target';

// Define the event map: keys are event type names, values are Event subclasses
interface AppEventMap {
    ready:   Event;
    message: CustomEvent<string>;
    error:   ErrorEvent;
    tick:    CustomEvent<number>;
}

// Instantiate with the event map
const emitter = new TypedEventTarget<AppEventMap>();

// addEventListener is strictly typed — 'message' callback receives CustomEvent<string>
emitter.addEventListener('message', (e) => {
    const text: string = e.detail; // ✅ fully typed
    console.log('Received:', text);
});

// TypeScript will error on unknown event types at compile time
// emitter.addEventListener('unknown', () => {}); // ❌ Type error

// dispatchTypedEvent ensures the dispatched event matches the declared type
emitter.dispatchTypedEvent('message', new CustomEvent('message', { detail: 'Hello!' }));
// dispatchTypedEvent('message', new Event('message')); // ❌ Type error — wrong event class
```

--------------------------------

### addEventListener<T>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

The overridden `addEventListener` method registers a typed event listener. It only accepts event types declared in the event map `M` and automatically infers the correct event class for the callback parameter. It supports all native `AddEventListenerOptions`.

```APIDOC
## addEventListener<T>

### Description
Registers a typed event listener. Accepts only event types declared in the event map `M` and automatically infers the correct event class for the callback parameter. Supports all native `AddEventListenerOptions` (e.g., `once`, `capture`, `passive`).

### Parameters
- **type** (string) - The event type to listen for.
- **listener** (EventListenerOrEventListenerObject) - The callback function or EventListenerObject.
- **options** (AddEventListenerOptions) - Optional configuration options.

### Usage Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface SensorEventMap {
    data:       CustomEvent<{ temperature: number; humidity: number }>;
    disconnect: Event;
}

const sensor = new TypedEventTarget<SensorEventMap>();

// Callback type is inferred as (e: CustomEvent<{temperature: number, humidity: number}>) => void
sensor.addEventListener('data', (e) => {
    const { temperature, humidity } = e.detail; // ✅ fully typed
    console.log(`Temp: ${temperature}°C  Humidity: ${humidity}%`);
}, { once: false, passive: true });

// Using an EventListenerObject (handleEvent pattern)
const disconnectHandler = {
    handleEvent(e: Event) {
        console.log('Sensor disconnected');
    }
};
sensor.addEventListener('disconnect', disconnectHandler);
```
```

--------------------------------

### Implement Typed Object Listeners with `TypedEventListenerObject`

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Use `TypedEventListenerObject` for type-safe `EventListenerObject` implementations. This requires a `handleEvent` method that correctly types the incoming event object.

```typescript
import { TypedEventTarget, TypedEventListenerObject } from 'typescript-event-target';

interface TimerEventMap {
    tick: CustomEvent<{ elapsed: number }>;
}

class TickHandler implements TypedEventListenerObject<TimerEventMap, 'tick'> {
    private count = 0;

    handleEvent(e: CustomEvent<{ elapsed: number }>) {
        this.count++;
        console.log(`Tick #${this.count} — elapsed: ${e.detail.elapsed}ms`);
    }
}

const timer = new TypedEventTarget<TimerEventMap>();
const handler = new TickHandler();

timer.addEventListener('tick', handler);
timer.dispatchTypedEvent('tick', new CustomEvent('tick', { detail: { elapsed: 1000 } }));
// Output: Tick #1 — elapsed: 1000ms
```

--------------------------------

### Extending TypedEventTarget

Source: https://context7.com/derzade/typescript-event-target/llms.txt

`TypedEventTarget` can be extended to create custom event-emitting classes. This pattern is idiomatic for building event-driven services or components that encapsulate their own event logic and expose a typed public API.

```APIDOC
## Extending TypedEventTarget

### Description
Subclassing `TypedEventTarget` allows for the creation of custom classes that manage and dispatch typed events internally, providing a clean, type-safe event API for components or services.

### Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface StoreEventMap {
    change: CustomEvent<{ key: string; value: unknown }>;
    reset:  Event;
}

class Store<T extends Record<string, unknown>> extends TypedEventTarget<StoreEventMap> {
    private data: T;

    constructor(initial: T) {
        super();
        this.data = { ...initial };
    }

    set<K extends keyof T>(key: K, value: T[K]) {
        this.data[key] = value;
        this.dispatchTypedEvent('change', new CustomEvent('change', {
            detail: { key: key as string, value }
        }));
    }

    reset() {
        this.data = {} as T;
        this.dispatchTypedEvent('reset', new Event('reset'));
    }

    get<K extends keyof T>(key: K): T[K] {
        return this.data[key];
    }
}

const store = new Store({ count: 0, name: 'Alice' });

store.addEventListener('change', (e) => {
    console.log(`Changed: ${e.detail.key} =`, e.detail.value);
});
store.addEventListener('reset', () => {
    console.log('Store was reset');
});

store.set('count', 42);
store.reset();
```
```

--------------------------------

### Extending TypedEventTarget

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

You can extend `TypedEventTarget` to create custom event target classes. Define your event map in the extending class.

```typescript
interface MyEventMap {
    time: CustomEvent<number>;
    // [...]
}

class MyEventTarget extends TypedEventTarget<MyEventMap> {
    /* [...] */
}

const myTarget = new MyEventTarget();
myTarget.addEventListener('time', (e) => {
    /* [...] */
});
```

--------------------------------

### TypedEventTarget<M>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

The generic TypedEventTarget class extends the native EventTarget. The type parameter `M` is an event map interface that maps event type strings to their corresponding Event subclasses. This ensures type safety for all event-related methods.

```APIDOC
## TypedEventTarget<M>

### Description
A generic class that extends the native `EventTarget`. The type parameter `M` is an event map interface where each key is an event type string and each value is a class that extends `Event`. All methods (`addEventListener`, `removeEventListener`, `dispatchTypedEvent`) are fully typed against this map, so TypeScript will enforce correct event types at every call site.

### Usage Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface AppEventMap {
    ready:   Event;
    message: CustomEvent<string>;
    error:   ErrorEvent;
    tick:    CustomEvent<number>;
}

const emitter = new TypedEventTarget<AppEventMap>();

emitter.addEventListener('message', (e) => {
    const text: string = e.detail; // ✅ fully typed
    console.log('Received:', text);
});

emitter.dispatchTypedEvent('message', new CustomEvent('message', { detail: 'Hello!' }));
```
```

--------------------------------

### Dispatching Typed Events

Source: https://github.com/derzade/typescript-event-target/blob/master/README.md

Use `dispatchTypedEvent` for strictly typed event dispatching. It requires an additional `_type` parameter for type checking.

```typescript
interface MyEventMap {
    time: CustomEvent<number>;
}

const eventTarget = new TypedEventTarget<MyEventMap>();

eventTarget.dispatchTypedEvent(
    'time',
    new CustomEvent('time', { detail: Date.now() })
);
```

--------------------------------

### TypedEventListenerObject<M, T>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

`TypedEventListenerObject<M, T>` defines the structure for an event listener implemented as an object with a `handleEvent` method. This provides type safety when using the `EventListenerObject` pattern with `TypedEventTarget`.

```APIDOC
## TypedEventListenerObject<M, T>

### Description
A utility type representing an event listener as an object with a `handleEvent` method, providing type safety.

### Parameters
- **M** (EventMap) - The event map defining the events and their corresponding event types.
- **T** (keyof M) - The specific event type for which the listener is defined.

### Example
```ts
import { TypedEventTarget, TypedEventListenerObject } from 'typescript-event-target';

interface TimerEventMap {
    tick: CustomEvent<{ elapsed: number }>;
}

class TickHandler implements TypedEventListenerObject<TimerEventMap, 'tick'> {
    private count = 0;

    handleEvent(e: CustomEvent<{ elapsed: number }>) {
        this.count++;
        console.log(`Tick #${this.count} — elapsed: ${e.detail.elapsed}ms`);
    }
}

const timer = new TypedEventTarget<TimerEventMap>();
const handler = new TickHandler();

timer.addEventListener('tick', handler);
```
```

--------------------------------

### Define Typed Event Listeners with `TypedEventListener`

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Use `TypedEventListener` to annotate standalone listener functions for `addEventListener`. This ensures the event object passed to the callback is correctly typed according to the event map.

```typescript
import { TypedEventTarget, TypedEventListener } from 'typescript-event-target';

interface NetworkEventMap {
    connect:    Event;
    disconnect: Event;
    data:       CustomEvent<Uint8Array>;
}

// Annotate a standalone function with the correct listener type
const onData: TypedEventListener<NetworkEventMap, 'data'> = (e) => {
    // e is CustomEvent<Uint8Array> — fully typed
    console.log('Received bytes:', e.detail.byteLength);
};

const socket = new TypedEventTarget<NetworkEventMap>();
socket.addEventListener('data', onData);
socket.removeEventListener('data', onData);
```

--------------------------------

### dispatchTypedEvent

Source: https://context7.com/derzade/typescript-event-target/llms.txt

A thin wrapper around `dispatchEvent` that enforces event type safety at compile time. It ensures that the dispatched event matches the declared type in the event map `M`.

```APIDOC
## dispatchTypedEvent

### Description
A thin wrapper around `dispatchEvent` that enforces event type safety at compile time. It ensures that the dispatched event matches the declared type in the event map `M`.

### Parameters
- **event** (T) - The event to dispatch, where `T` is a type from the event map `M`.

### Usage Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface AppEventMap {
    message: CustomEvent<string>;
}

const emitter = new TypedEventTarget<AppEventMap>();

emitter.dispatchTypedEvent('message', new CustomEvent('message', { detail: 'Hello!' }));

// TypeScript will error if the event type or class does not match the map
// emitter.dispatchTypedEvent('message', new Event('message')); // ❌ Type error
```
```

--------------------------------

### Extend `TypedEventTarget` for Class-Based Event Management

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Subclass `TypedEventTarget` to create event-driven services or components. This pattern allows encapsulating event dispatch logic while exposing a typed public API.

```typescript
import { TypedEventTarget } from 'typescript-event-target';

interface StoreEventMap {
    change: CustomEvent<{ key: string; value: unknown }>;
    reset:  Event;
}

class Store<T extends Record<string, unknown>> extends TypedEventTarget<StoreEventMap> {
    private data: T;

    constructor(initial: T) {
        super();
        this.data = { ...initial };
    }

    set<K extends keyof T>(key: K, value: T[K]) {
        this.data[key] = value;
        this.dispatchTypedEvent('change', new CustomEvent('change', {
            detail: { key: key as string, value }
        }));
    }

    reset() {
        this.data = {} as T;
        this.dispatchTypedEvent('reset', new Event('reset'));
    }

    get<K extends keyof T>(key: K): T[K] {
        return this.data[key];
    }
}

const store = new Store({ count: 0, name: 'Alice' });

store.addEventListener('change', (e) => {
    console.log(`Changed: ${e.detail.key} =`, e.detail.value);
});
store.addEventListener('reset', () => {
    console.log('Store was reset');
});

store.set('count', 42);  // Changed: count = 42
store.set('name', 'Bob'); // Changed: name = Bob
store.reset();             // Store was reset
```

--------------------------------

### dispatchTypedEvent<T>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

`dispatchTypedEvent` provides a type-safe alternative to the native `dispatchEvent`. It ensures that the dispatched event object matches the expected event type defined in the event map, preventing runtime errors due to type mismatches.

```APIDOC
## dispatchTypedEvent<T>

### Description
Dispatches a strictly typed event. This method is a type-safe alternative to the native `dispatchEvent`.

### Parameters
- **event_type** (string) - The type of the event to dispatch. Used for type inference.
- **event** (Event) - The event object to dispatch. Must conform to the type specified in the event map for the given `event_type`.

### Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface MyEventMap {
    data: CustomEvent<string>;
    ready: Event;
}

const target = new TypedEventTarget<MyEventMap>();

target.dispatchTypedEvent('data', new CustomEvent('data', { detail: 'some data' }));
target.dispatchTypedEvent('ready', new Event('ready'));
```
```

--------------------------------

### TypedEventListener<M, T>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

`TypedEventListener<M, T>` is a utility type for defining typed callback functions for event listeners. It ensures that the event object passed to the listener function has the correct type based on the event map `M` and the specific event type `T`.

```APIDOC
## TypedEventListener<M, T>

### Description
A utility type representing a typed callback function for event listeners.

### Parameters
- **M** (EventMap) - The event map defining the events and their corresponding event types.
- **T** (keyof M) - The specific event type for which the listener is defined.

### Example
```ts
import { TypedEventTarget, TypedEventListener } from 'typescript-event-target';

interface NetworkEventMap {
    connect: Event;
    data: CustomEvent<Uint8Array>;
}

const onData: TypedEventListener<NetworkEventMap, 'data'> = (e) => {
    // e is CustomEvent<Uint8Array> — fully typed
    console.log('Received bytes:', e.detail.byteLength);
};

const socket = new TypedEventTarget<NetworkEventMap>();
socket.addEventListener('data', onData);
```
```

--------------------------------

### Dispatch Strictly Typed Events with `dispatchTypedEvent`

Source: https://context7.com/derzade/typescript-event-target/llms.txt

Use `dispatchTypedEvent` for type-safe event dispatching. TypeScript enforces that the event object matches the declared event class for the given event type. Avoid the deprecated native `dispatchEvent`.

```typescript
import { TypedEventTarget } from 'typescript-event-target';

class FileEvent extends Event {
    constructor(public readonly fileName: string, public readonly size: number) {
        super('file');
    }
}

interface UploadEventMap {
    file:     FileEvent;
    progress: CustomEvent<number>;
    done:     Event;
}

const uploader = new TypedEventTarget<UploadEventMap>();

uploader.addEventListener('file', (e) => {
    console.log(`Uploading ${e.fileName} (${e.size} bytes)`);
});
uploader.addEventListener('progress', (e) => {
    console.log(`Progress: ${e.detail}%`);
});
uploader.addEventListener('done', () => {
    console.log('Upload complete');
});

// All strictly typed — passing the wrong event class is a compile-time error
uploader.dispatchTypedEvent('file', new FileEvent('photo.jpg', 204800));
uploader.dispatchTypedEvent('progress', new CustomEvent('progress', { detail: 42 }));
uploader.dispatchTypedEvent('done', new Event('done'));

// uploader.dispatchTypedEvent('file', new Event('file')); // ❌ Type error
// uploader.dispatchTypedEvent('progress', new CustomEvent('progress', { detail: 'bad' })); // ❌ Type error
```

--------------------------------

### removeEventListener<T>

Source: https://context7.com/derzade/typescript-event-target/llms.txt

The overridden `removeEventListener` method removes a typed event listener. It enforces type constraints similar to `addEventListener`, ensuring the callback type matches the declared type for the given event key in the event map.

```APIDOC
## removeEventListener<T>

### Description
Removes a typed event listener. Mirrors `addEventListener` in type constraints, ensuring the callback type matches the declared type for the given event key in the event map.

### Parameters
- **type** (string) - The event type to remove the listener for.
- **listener** (EventListenerOrEventListenerObject) - The callback function or EventListenerObject to remove.
- **options** (EventListenerOptions) - Optional configuration options.

### Usage Example
```ts
import { TypedEventTarget } from 'typescript-event-target';

interface ClockEventMap {
    tick: CustomEvent<number>;
}

const clock = new TypedEventTarget<ClockEventMap>();

const onTick = (e: CustomEvent<number>) => {
    console.log('Tick:', e.detail);
    // Remove itself after the first call
    clock.removeEventListener('tick', onTick);
};

clock.addEventListener('tick', onTick);

clock.dispatchTypedEvent('tick', new CustomEvent('tick', { detail: Date.now() })); // logs once
clock.dispatchTypedEvent('tick', new CustomEvent('tick', { detail: Date.now() })); // no-op
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.