diff --git a/packages/.vitepress/plugins/markdownTransform.ts b/packages/.vitepress/plugins/markdownTransform.ts
index 2ec1c704b27..c2d85437b0e 100644
--- a/packages/.vitepress/plugins/markdownTransform.ts
+++ b/packages/.vitepress/plugins/markdownTransform.ts
@@ -78,7 +78,7 @@ export async function getFunctionMarkdown(pkg: string, name: string) {
 ## Type Declarations
 
 <details>
-<summary op50 italic>Show Type Declarations</summary>
+<summary op50 italic cursor-pointer select-none>Show Type Declarations</summary>
 
 ${code}
 
diff --git a/packages/.vitepress/theme/components/TeamMember.vue b/packages/.vitepress/theme/components/TeamMember.vue
index 2fb97146a61..012a5f2d0a2 100644
--- a/packages/.vitepress/theme/components/TeamMember.vue
+++ b/packages/.vitepress/theme/components/TeamMember.vue
@@ -45,9 +45,9 @@ defineProps<{
         :aria-label="`Sponsor ${data.name}`"
       />
     </div>
-    <div v-if="data.functions || data.packages" bg-gray:5 mb2 p2 rounded grid="~ cols-[20px_1fr] gap-y-2" items-start w="5/6" mxa>
+    <div v-if="data.functions || data.packages" bg-gray:5 mb2 p3 rounded grid="~ cols-[20px_1fr] gap-x-1 gap-y-2" items-start w="5/6" mxa>
       <template v-if="data.functions">
-        <div op50 i-carbon:function-math title="Functions" />
+        <div op50 ma i-carbon:function-math title="Functions" />
         <div flex="~ col gap-1" text-left text-sm w-max>
           <a v-for="f of data.functions" :key="f" :href="`/${f}`" target="_blank">
             <code>{{ f }}</code>
@@ -55,7 +55,7 @@ defineProps<{
         </div>
       </template>
       <template v-if="data.packages">
-        <div op50 i-carbon-cube title="Packages" />
+        <div op50 ma i-carbon-cube title="Packages" />
         <div flex="~ col gap-1" text-left text-sm w-max>
           <a v-for="f of data.packages" :key="f" href="/add-ons">
             <code>@vueuse/{{ f }}</code>
diff --git a/packages/core/useEventListener/index.test.ts b/packages/core/useEventListener/index.test.ts
index 7140ffdaf8a..a98ebe4ff90 100644
--- a/packages/core/useEventListener/index.test.ts
+++ b/packages/core/useEventListener/index.test.ts
@@ -1,3 +1,5 @@
+import type { Fn } from '@vueuse/shared'
+import type { SpyInstance } from 'vitest'
 import { noop } from '@vueuse/shared'
 import { isVue2 } from 'vue-demi'
 import type { Ref } from 'vue'
@@ -5,80 +7,224 @@ import { effectScope, nextTick, ref } from 'vue'
 import { useEventListener } from '.'
 
 describe('useEventListener', () => {
-  let target: Ref<HTMLDivElement | null>
-  let listener: () => any
+  const options = { capture: true }
+  let stop: Fn
+  let target: HTMLDivElement
+  let removeSpy: SpyInstance
+  let addSpy: SpyInstance
 
   beforeEach(() => {
-    target = ref(document.createElement('div'))
-    listener = vi.fn()
+    target = document.createElement('div')
+    removeSpy = vitest.spyOn(target, 'removeEventListener')
+    addSpy = vitest.spyOn(target, 'addEventListener')
   })
 
-  it('should not listen when target is invalid', async () => {
-    useEventListener(target, 'click', listener)
-    const el = target.value
-    target.value = null
-    await nextTick()
-    el?.dispatchEvent(new MouseEvent('click'))
-    await nextTick()
+  it('should be defined', () => {
+    expect(useEventListener).toBeDefined()
+  })
+
+  describe('given both none array', () => {
+    const listener = vitest.fn()
+    const event = 'click'
+
+    beforeEach(() => {
+      listener.mockReset()
+      stop = useEventListener(target, event, listener, options)
+    })
+
+    it('should add listener', () => {
+      expect(addSpy).toBeCalledTimes(1)
+    })
+
+    it('should trigger listener', () => {
+      expect(listener).not.toBeCalled()
+      target.dispatchEvent(new MouseEvent(event))
+      expect(listener).toBeCalledTimes(1)
+    })
+
+    it('should remove listener', () => {
+      expect(removeSpy).not.toBeCalled()
 
-    expect(listener).toHaveBeenCalledTimes(isVue2 ? 1 : 0)
-    expect(useEventListener(null, 'click', listener)).toBe(noop)
+      stop()
+
+      expect(removeSpy).toBeCalledTimes(1)
+      expect(removeSpy).toBeCalledWith(event, listener, options)
+    })
   })
 
-  function getTargetName(useTarget: boolean) {
-    return useTarget ? 'element' : 'window'
-  }
+  describe('given array of events but single listener', () => {
+    const listener = vitest.fn()
+    const events = ['click', 'scroll', 'blur', 'resize']
 
-  function getArgs(useTarget: boolean) {
-    return (useTarget ? [target, 'click', listener] : ['click', listener])
-  }
+    beforeEach(() => {
+      listener.mockReset()
+      stop = useEventListener(target, events, listener, options)
+    })
 
-  function trigger(useTarget: boolean) {
-    (useTarget ? target.value : window)!.dispatchEvent(new MouseEvent('click'))
-  }
+    it('should add listener for all events', () => {
+      events.forEach(event => expect(addSpy).toBeCalledWith(event, listener, options))
+    })
 
-  function testTarget(useTarget: boolean) {
-    it(`should ${getTargetName(useTarget)} listen event`, async () => {
-      // @ts-expect-error mock different args
-      const stop = useEventListener(...getArgs(useTarget))
+    it('should trigger listener with all events', () => {
+      expect(listener).not.toBeCalled()
+      events.forEach((event, index) => {
+        target.dispatchEvent(new Event(event))
+        expect(listener).toBeCalledTimes(index + 1)
+      })
+    })
 
-      trigger(useTarget)
+    it('should remove listener with all events', () => {
+      expect(removeSpy).not.toBeCalled()
 
-      await nextTick()
+      stop()
 
-      expect(listener).toHaveBeenCalledTimes(1)
+      expect(removeSpy).toBeCalledTimes(events.length)
+      events.forEach(event => expect(removeSpy).toBeCalledWith(event, listener, options))
     })
+  })
 
-    it(`should ${getTargetName(useTarget)} manually stop listening event`, async () => {
-      // @ts-expect-error mock different args
-      const stop = useEventListener(...getArgs(useTarget))
+  describe('given single event but array of listeners', () => {
+    const listeners = [vitest.fn(), vitest.fn(), vitest.fn()]
+    const event = 'click'
+
+    beforeEach(() => {
+      listeners.forEach(listener => listener.mockReset())
+      stop = useEventListener(target, event, listeners, options)
+    })
+
+    it('should add all listeners', () => {
+      listeners.forEach(listener => expect(addSpy).toBeCalledWith(event, listener, options))
+    })
+
+    it('should call all listeners with single click event', () => {
+      listeners.forEach(listener => expect(listener).not.toBeCalled())
+
+      target.dispatchEvent(new Event(event))
+
+      listeners.forEach(listener => expect(listener).toBeCalledTimes(1))
+    })
+
+    it('should remove listeners', () => {
+      expect(removeSpy).not.toBeCalled()
 
       stop()
 
-      trigger(useTarget)
+      expect(removeSpy).toBeCalledTimes(listeners.length)
+      listeners.forEach(listener => expect(removeSpy).toBeCalledWith(event, listener, options))
+    })
+  })
 
-      await nextTick()
+  describe('given both array of events and listeners', () => {
+    const listeners = [vitest.fn(), vitest.fn(), vitest.fn()]
+    const events = ['click', 'scroll', 'blur', 'resize', 'custom-event']
 
-      expect(listener).toHaveBeenCalledTimes(0)
+    beforeEach(() => {
+      listeners.forEach(listener => listener.mockReset())
+      stop = useEventListener(target, events, listeners, options)
     })
 
-    it(`should ${getTargetName(useTarget)} auto stop listening event`, async () => {
-      const scope = effectScope()
-      await scope.run(async () => {
-        // @ts-expect-error mock different args
-        useEventListener(...getArgs(useTarget))
+    it('should add all listeners for all events', () => {
+      listeners.forEach((listener) => {
+        events.forEach((event) => {
+          expect(addSpy).toBeCalledWith(event, listener, options)
+        })
+      })
+    })
+
+    it('should call all listeners with all events', () => {
+      events.forEach((event, index) => {
+        target.dispatchEvent(new Event(event))
+        listeners.forEach(listener => expect(listener).toBeCalledTimes(index + 1))
       })
+    })
+
+    it('should remove all listeners with all events', () => {
+      stop()
+
+      listeners.forEach((listener) => {
+        events.forEach((event) => {
+          expect(removeSpy).toBeCalledWith(event, listener, options)
+        })
+      })
+    })
+  })
 
-      await scope.stop()
+  describe('multiple events', () => {
+    let target: Ref<HTMLDivElement | null>
+    let listener: () => any
 
-      trigger(useTarget)
+    beforeEach(() => {
+      target = ref(document.createElement('div'))
+      listener = vi.fn()
+    })
 
+    it('should not listen when target is invalid', async () => {
+      useEventListener(target, 'click', listener)
+      const el = target.value
+      target.value = null
+      await nextTick()
+      el?.dispatchEvent(new MouseEvent('click'))
       await nextTick()
 
       expect(listener).toHaveBeenCalledTimes(isVue2 ? 1 : 0)
+      expect(useEventListener(null, 'click', listener)).toBe(noop)
     })
-  }
 
-  testTarget(false)
-  testTarget(true)
+    function getTargetName(useTarget: boolean) {
+      return useTarget ? 'element' : 'window'
+    }
+
+    function getArgs(useTarget: boolean) {
+      return (useTarget ? [target, 'click', listener] : ['click', listener])
+    }
+
+    function trigger(useTarget: boolean) {
+      (useTarget ? target.value : window)!.dispatchEvent(new MouseEvent('click'))
+    }
+
+    function testTarget(useTarget: boolean) {
+      it(`should ${getTargetName(useTarget)} listen event`, async () => {
+      // @ts-expect-error mock different args
+        const stop = useEventListener(...getArgs(useTarget))
+
+        trigger(useTarget)
+
+        await nextTick()
+
+        expect(listener).toHaveBeenCalledTimes(1)
+      })
+
+      it(`should ${getTargetName(useTarget)} manually stop listening event`, async () => {
+      // @ts-expect-error mock different args
+        const stop = useEventListener(...getArgs(useTarget))
+
+        stop()
+
+        trigger(useTarget)
+
+        await nextTick()
+
+        expect(listener).toHaveBeenCalledTimes(0)
+      })
+
+      it(`should ${getTargetName(useTarget)} auto stop listening event`, async () => {
+        const scope = effectScope()
+        await scope.run(async () => {
+        // @ts-expect-error mock different args
+          useEventListener(...getArgs(useTarget))
+        })
+
+        await scope.stop()
+
+        trigger(useTarget)
+
+        await nextTick()
+
+        expect(listener).toHaveBeenCalledTimes(isVue2 ? 1 : 0)
+      })
+    }
+
+    testTarget(false)
+    testTarget(true)
+  })
 })
diff --git a/packages/core/useEventListener/index.ts b/packages/core/useEventListener/index.ts
index a321ae7334e..b2ee006e1c4 100644
--- a/packages/core/useEventListener/index.ts
+++ b/packages/core/useEventListener/index.ts
@@ -1,4 +1,4 @@
-import type { Fn, MaybeComputedRef } from '@vueuse/shared'
+import type { Arrayable, Fn, MaybeComputedRef } from '@vueuse/shared'
 import { isString, noop, tryOnScopeDispose } from '@vueuse/shared'
 import { watch } from 'vue-demi'
 import type { MaybeElementRef } from '../unrefElement'
@@ -28,8 +28,8 @@ export interface GeneralEventListener<E = Event> {
  * @param options
  */
 export function useEventListener<E extends keyof WindowEventMap>(
-  event: E,
-  listener: (this: Window, ev: WindowEventMap[E]) => any,
+  event: Arrayable<E>,
+  listener: Arrayable<(this: Window, ev: WindowEventMap[E]) => any>,
   options?: boolean | AddEventListenerOptions
 ): Fn
 
@@ -46,8 +46,8 @@ export function useEventListener<E extends keyof WindowEventMap>(
  */
 export function useEventListener<E extends keyof WindowEventMap>(
   target: Window,
-  event: E,
-  listener: (this: Window, ev: WindowEventMap[E]) => any,
+  event: Arrayable<E>,
+  listener: Arrayable<(this: Window, ev: WindowEventMap[E]) => any>,
   options?: boolean | AddEventListenerOptions
 ): Fn
 
@@ -64,8 +64,8 @@ export function useEventListener<E extends keyof WindowEventMap>(
  */
 export function useEventListener<E extends keyof DocumentEventMap>(
   target: Document,
-  event: E,
-  listener: (this: Document, ev: DocumentEventMap[E]) => any,
+  event: Arrayable<E>,
+  listener: Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>,
   options?: boolean | AddEventListenerOptions
 ): Fn
 
@@ -82,8 +82,8 @@ export function useEventListener<E extends keyof DocumentEventMap>(
  */
 export function useEventListener<Names extends string, EventType = Event>(
   target: InferEventTarget<Names>,
-  event: Names,
-  listener: GeneralEventListener<EventType>,
+  event: Arrayable<Names>,
+  listener: Arrayable<GeneralEventListener<EventType>>,
   options?: boolean | AddEventListenerOptions
 ): Fn
 
@@ -100,29 +100,43 @@ export function useEventListener<Names extends string, EventType = Event>(
  */
 export function useEventListener<EventType = Event>(
   target: MaybeComputedRef<EventTarget | null | undefined>,
-  event: string,
-  listener: GeneralEventListener<EventType>,
+  event: Arrayable<string>,
+  listener: Arrayable<GeneralEventListener<EventType>>,
   options?: boolean | AddEventListenerOptions
 ): Fn
 
 export function useEventListener(...args: any[]) {
   let target: MaybeComputedRef<EventTarget> | undefined
-  let event: string
-  let listener: any
+  let events: Arrayable<string>
+  let listeners: Arrayable<Function>
   let options: any
 
-  if (isString(args[0])) {
-    [event, listener, options] = args
+  if (isString(args[0]) || Array.isArray(args[0])) {
+    [events, listeners, options] = args
     target = defaultWindow
   }
   else {
-    [target, event, listener, options] = args
+    [target, events, listeners, options] = args
   }
 
   if (!target)
     return noop
 
-  let cleanup = noop
+  if (!Array.isArray(events))
+    events = [events]
+  if (!Array.isArray(listeners))
+    listeners = [listeners]
+
+  const cleanups: Function[] = []
+  const cleanup = () => {
+    cleanups.forEach(fn => fn())
+    cleanups.length = 0
+  }
+
+  const register = (el: any, event: string, listener: any) => {
+    el.addEventListener(event, listener, options)
+    return () => el.removeEventListener(event, listener, options)
+  }
 
   const stopWatch = watch(
     () => unrefElement(target as unknown as MaybeElementRef),
@@ -131,12 +145,11 @@ export function useEventListener(...args: any[]) {
       if (!el)
         return
 
-      el.addEventListener(event, listener, options)
-
-      cleanup = () => {
-        el.removeEventListener(event, listener, options)
-        cleanup = noop
-      }
+      cleanups.push(
+        ...(events as string[]).flatMap((event) => {
+          return (listeners as Function[]).map(listener => register(el, event, listener))
+        }),
+      )
     },
     { immediate: true, flush: 'post' },
   )
diff --git a/packages/shared/utils/types.ts b/packages/shared/utils/types.ts
index 082d4241be7..db60e09ea34 100644
--- a/packages/shared/utils/types.ts
+++ b/packages/shared/utils/types.ts
@@ -60,6 +60,8 @@ export type DeepMaybeRef<T> = T extends Ref<infer V>
     ? { [K in keyof T]: DeepMaybeRef<T[K]> }
     : MaybeRef<T>
 
+export type Arrayable<T> = T[] | T
+
 /**
  * Infers the element type of an array
  */