A 'do what I mean' addEventListener / removeEventListener interface. Heavily overloaded intuition signature. Returns an object with an off handle to remove all listeners thus added.

on.js

const supports = {
  capture : false,
  passive : false,
  once    : false
}

try {
  document.addEventListener( 'test', null, {
    get capture(){ supports.capture = true },
    get passive(){ supports.passive = true },
    get once(){    supports.once    = true },
  } )
}
catch( e ){}

function listen( target, event, handler = Function.prototype, options = false ){
  const { capture, passive, once } = options
  let   wrapper = handler

  function off(){
    target.removeEventListener( event, wrapper, options )
  }

  if( typeof options === object ){
    if( once && !supports.once )
      wrapper = function(){
        off()

        return handler.apply( this, arguments ) || passive
      }

    if( capture && !supports.capture )
      options = true
  }

  return { off }
}

function slice( list, start, end ){
  return Array.prototype.slice.call( list, start, end )
}

function offal( listeners ){
  return {
    off : () => listeners.map( ( { off } ) => off() )
  }
}

export default function on( target, event, handler, options ){
  return (
     Array.isArray( target )
    ? offall( target.map( args => 
        on.call( this, ...args, slice( arguments, 1 ) )
      ) )

    : Array.isArray( event )
    ? offall( event.map( args =>
        on.call( this, target, ...args, slice( arguments, 2 ) )
      ) )

    : typeof event == 'object'
    ? offall( Object.keys( event ).map( event =>
        on.call( this, target, event, arguments[ 1 ][ event ], slice( arguments, 2 ) )
      ) )

    : event.includes( ' ' )
    ? offall( event.split( ' ' ).map( event =>
        on.call( this, target, event, slice( arguments, 2 ) )
      ) )

    : Array.isArray( handler )
    ? offall( handler.map( handler => 
        on.call( this, target, event, handler, slice( arguments, 3 ) )
      ) )

    : Array.isArray( options )
    ? listen.call( this, target, event, handler, options[ 0 ] )

    : listen.apply( this, arguments )
  )
}