embedded-javascript/moddable

Since TypeScript generates inefficient code for private fields (for the moment) and since the implementation of EventEmitter doesn't use TypeScript features beyond type checking, you can use JavaScript for the implementation and have a parallel *.d.ts file with the type declarations. That seems to work.

declare module "event-emitter-mod" {
    class EventEmitter {
        on: (event: string, listener: Function) => Boolean | null | undefined;
        emit: (event:string, args?: any) => Error | Boolean;
        addListener: (event: string, listener: Function) => Boolean | null | undefined;
        removeListener: (event:string, listener: Function) => Boolean | null | undefined;
    }

    export {EventEmitter as default};
}

And

export default class {
    #events = new Map();
    #maxListeners;
    constructor(options) {
        this.#maxListeners = options?.maxListeners ?? 10;
    }

    on(event, listener) {
        return this.addListener(event, listener);
    }

    emit(event, args) {
        const listeners = this.#events.get(event);
        if (!listeners) return false;
        listeners.forEach(triggerCallback(args))
        return true
    }

    addListener(event, listener) {
        const listeners = this.#events.get(event);

        if (!listeners) {
            this.#events.set(event, [listener]);
        } else {
            if ((listeners.length >= this.#maxListeners) || listeners.includes(listener))
                return false;

                listeners.push(listener)
        }
        return true
    }

    removeListener(event, listener) {
        const listeners = this.#events.get(event);
        if (!listeners)
            return false;

        const index = listeners.indexOf(listener);
        if (index < 0)
            return false;

        listeners.splice(index, 1);
        if (!listeners.length)
            this.#events.delete(event);

        return true
    }
}

function triggerCallback(args) {
    return cb => {
        try {
            cb(args)
        } catch(err) {
            throw new Error(err)
        }
    }
}