@developit i think the feature would find itself very convenient if you consider:

1. wrapping many events in some qualified functions:

function someSpecificFunction() {
 const handler = () => console.log(arguments)
 const unsubs = ['event1', 'event2', 'event3'].map(ev => {
 mitt.on(ev, handler)
 return () => mitt.off(ev, handler)
 })
 return () => unsubs.forEach(fn => fn())
}

which, with this PR could be made more concise like:

function someSpecificFunction() {
 const handler = () => console.log(arguments)
 const unsubs = [
 mitt.on('event1', handler),
 mitt.on('event2', handler),
 mitt.on('event3', handler),
 ]
 return () => unsubs.forEach(fn => fn())
}

2. use in modern frontend libraries such as React:

A typical use could be:

useEffect(() => {
 const listener = mitt.on('event', setStateSomething)
 return listener
}, [someDep])

which, with this PR could be made more concise like:

useEffect(
 () => mitt.on('event', setStateSomething),
 [someDep],
)

In the end people could just also have a workaround such as:

const on = mitt.on
mitt.on = (ev, fn) => on(ev, fn) ?? () => mitt.off(ev, fn)

...but it's such a common use nowadays that it just doesn't make sense not to have it. (i personally look forward to this PR to start using mitt into my company's sdk)

@developit hi. this looks what I am looking for. are you still not considering merging it?

Hi - I'm also looking for this feature. Obviously I will create it in my app for now, but would be nice for the lib to have as a core feature.

About the ownership comment above #138 (comment)
Has it been considered using WeakMap or an implementation using Symbols (stored in a metadata structure) to map registered handler functions with an off function? That way, at least in my head, it could be possible to create off functions without a direct reference to the handler function, and thus avoid memory leaks due to referenced off functions. What impact it will have on the lib size is probably another story.