diff --git a/README.md b/README.md
index e2e5db3f..809fb9a3 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,7 @@ change the state of the checkbox.
 - [API](#api)
   - [`click(element, eventInit, options)`](#clickelement-eventinit-options)
   - [`dblClick(element, eventInit, options)`](#dblclickelement-eventinit-options)
-  - [`async type(element, text, [options])`](#async-typeelement-text-options)
+  - [`type(element, text, [options])`](#typeelement-text-options)
   - [`upload(element, file, [{ clickInit, changeInit }])`](#uploadelement-file--clickinit-changeinit-)
   - [`clear(element)`](#clearelement)
   - [`selectOptions(element, values)`](#selectoptionselement-values)
@@ -151,7 +151,7 @@ test('double click', () => {
 })
 ```
 
-### `async type(element, text, [options])`
+### `type(element, text, [options])`
 
 Writes `text` inside an `<input>` or a `<textarea>`.
 
@@ -160,17 +160,18 @@ import React from 'react'
 import {render, screen} from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 
-test('type', async () => {
+test('type', () => {
   render(<textarea />)
 
-  await userEvent.type(screen.getByRole('textbox'), 'Hello,{enter}World!')
+  userEvent.type(screen.getByRole('textbox'), 'Hello,{enter}World!')
   expect(screen.getByRole('textbox')).toHaveValue('Hello,\nWorld!')
 })
 ```
 
 `options.delay` is the number of milliseconds that pass between two characters
 are typed. By default it's 0. You can use this option if your component has a
-different behavior for fast or slow users.
+different behavior for fast or slow users. If you do this, you need to make sure
+to `await`!
 
 `type` will click the element before typing. To disable this, set the
 `skipClick` option to `true`.
@@ -433,7 +434,7 @@ test('hover', () => {
 
 Unhovers out of `element`.
 
-> See [above](#async-hoverelement) for an example
+> See [above](#hoverelement) for an example
 
 ### `paste(element, text, eventInit, options)`
 
diff --git a/src/__tests__/type-modifiers.js b/src/__tests__/type-modifiers.js
index ab33912f..09a7d404 100644
--- a/src/__tests__/type-modifiers.js
+++ b/src/__tests__/type-modifiers.js
@@ -15,10 +15,10 @@ import {setup} from './helpers/utils'
 // This also means that '{shift}a' will fire an input event with the shiftKey,
 // but will not capitalize "a".
 
-test('{esc} triggers typing the escape character', async () => {
+test('{esc} triggers typing the escape character', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{esc}')
+  userEvent.type(element, '{esc}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
@@ -41,9 +41,9 @@ test('{esc} triggers typing the escape character', async () => {
   `)
 })
 
-test('a{backspace}', async () => {
+test('a{backspace}', () => {
   const {element, getEventSnapshot} = setup('<input />')
-  await userEvent.type(element, 'a{backspace}')
+  userEvent.type(element, 'a{backspace}')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
 
@@ -72,9 +72,9 @@ test('a{backspace}', async () => {
   `)
 })
 
-test('{backspace}a', async () => {
+test('{backspace}a', () => {
   const {element, getEventSnapshot} = setup('<input />')
-  await userEvent.type(element, '{backspace}a')
+  userEvent.type(element, '{backspace}a')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
 
@@ -101,11 +101,11 @@ test('{backspace}a', async () => {
   `)
 })
 
-test('{backspace} triggers typing the backspace character and deletes the character behind the cursor', async () => {
+test('{backspace} triggers typing the backspace character and deletes the character behind the cursor', () => {
   const {element, getEventSnapshot} = setup('<input value="yo" />')
   element.setSelectionRange(1, 1)
 
-  await userEvent.type(element, '{backspace}')
+  userEvent.type(element, '{backspace}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="o"]
@@ -132,11 +132,11 @@ test('{backspace} triggers typing the backspace character and deletes the charac
   `)
 })
 
-test('{backspace} on a readOnly input', async () => {
+test('{backspace} on a readOnly input', () => {
   const {element, getEventSnapshot} = setup('<input readonly value="yo" />')
   element.setSelectionRange(1, 1)
 
-  await userEvent.type(element, '{backspace}')
+  userEvent.type(element, '{backspace}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="yo"]
@@ -160,13 +160,13 @@ test('{backspace} on a readOnly input', async () => {
   `)
 })
 
-test('{backspace} does not fire input if keydown prevents default', async () => {
+test('{backspace} does not fire input if keydown prevents default', () => {
   const {element, getEventSnapshot} = setup('<input value="yo" />', {
     eventHandlers: {keyDown: e => e.preventDefault()},
   })
   element.setSelectionRange(1, 1)
 
-  await userEvent.type(element, '{backspace}')
+  userEvent.type(element, '{backspace}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="yo"]
@@ -190,11 +190,11 @@ test('{backspace} does not fire input if keydown prevents default', async () =>
   `)
 })
 
-test('{backspace} deletes the selected range', async () => {
+test('{backspace} deletes the selected range', () => {
   const {element, getEventSnapshot} = setup('<input value="Hi there" />')
   element.setSelectionRange(1, 5)
 
-  await userEvent.type(element, '{backspace}')
+  userEvent.type(element, '{backspace}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="Here"]
@@ -221,18 +221,18 @@ test('{backspace} deletes the selected range', async () => {
   `)
 })
 
-test('{backspace} on an input type that does not support selection ranges', async () => {
+test('{backspace} on an input type that does not support selection ranges', () => {
   const {element} = setup('<input type="email" value="yo@example.com" />')
   // note: you cannot even call setSelectionRange on these kinds of elements...
-  await userEvent.type(element, '{backspace}{backspace}a')
+  userEvent.type(element, '{backspace}{backspace}a')
   // removed "m" then "o" then add "a"
   expect(element).toHaveValue('yo@example.ca')
 })
 
-test('{alt}a{/alt}', async () => {
+test('{alt}a{/alt}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{alt}a{/alt}')
+  userEvent.type(element, '{alt}a{/alt}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -260,10 +260,10 @@ test('{alt}a{/alt}', async () => {
   `)
 })
 
-test('{meta}a{/meta}', async () => {
+test('{meta}a{/meta}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{meta}a{/meta}')
+  userEvent.type(element, '{meta}a{/meta}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -291,10 +291,10 @@ test('{meta}a{/meta}', async () => {
   `)
 })
 
-test('{ctrl}a{/ctrl}', async () => {
+test('{ctrl}a{/ctrl}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{ctrl}a{/ctrl}')
+  userEvent.type(element, '{ctrl}a{/ctrl}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -322,10 +322,10 @@ test('{ctrl}a{/ctrl}', async () => {
   `)
 })
 
-test('{shift}a{/shift}', async () => {
+test('{shift}a{/shift}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{shift}a{/shift}')
+  userEvent.type(element, '{shift}a{/shift}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -353,10 +353,10 @@ test('{shift}a{/shift}', async () => {
   `)
 })
 
-test('a{enter}', async () => {
+test('a{enter}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, 'a{enter}')
+  userEvent.type(element, 'a{enter}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -385,14 +385,14 @@ test('a{enter}', async () => {
   `)
 })
 
-test('{enter} with preventDefault keydown', async () => {
+test('{enter} with preventDefault keydown', () => {
   const {element, getEventSnapshot} = setup('<input />', {
     eventHandlers: {
       keyDown: e => e.preventDefault(),
     },
   })
 
-  await userEvent.type(element, '{enter}')
+  userEvent.type(element, '{enter}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
@@ -415,10 +415,10 @@ test('{enter} with preventDefault keydown', async () => {
   `)
 })
 
-test('{enter} on a button', async () => {
+test('{enter} on a button', () => {
   const {element, getEventSnapshot} = setup('<button />')
 
-  await userEvent.type(element, '{enter}')
+  userEvent.type(element, '{enter}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: button
@@ -443,10 +443,10 @@ test('{enter} on a button', async () => {
   `)
 })
 
-test('{enter} on a textarea', async () => {
+test('{enter} on a textarea', () => {
   const {element, getEventSnapshot} = setup('<textarea></textarea>')
 
-  await userEvent.type(element, '{enter}')
+  userEvent.type(element, '{enter}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: textarea[value="\\n"]
@@ -472,10 +472,10 @@ test('{enter} on a textarea', async () => {
   `)
 })
 
-test('{meta}{enter}{/meta} on a button', async () => {
+test('{meta}{enter}{/meta} on a button', () => {
   const {element, getEventSnapshot} = setup('<button />')
 
-  await userEvent.type(element, '{meta}{enter}{/meta}')
+  userEvent.type(element, '{meta}{enter}{/meta}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: button
@@ -502,10 +502,10 @@ test('{meta}{enter}{/meta} on a button', async () => {
   `)
 })
 
-test('{meta}{alt}{ctrl}a{/ctrl}{/alt}{/meta}', async () => {
+test('{meta}{alt}{ctrl}a{/ctrl}{/alt}{/meta}', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{meta}{alt}{ctrl}a{/ctrl}{/alt}{/meta}')
+  userEvent.type(element, '{meta}{alt}{ctrl}a{/ctrl}{/alt}{/meta}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -537,7 +537,7 @@ test('{meta}{alt}{ctrl}a{/ctrl}{/alt}{/meta}', async () => {
   `)
 })
 
-test('{selectall} selects all the text', async () => {
+test('{selectall} selects all the text', () => {
   const value = 'abcdefg'
   const {element, clearEventCalls, getEventSnapshot} = setup(
     `<input value="${value}" />`,
@@ -546,7 +546,7 @@ test('{selectall} selects all the text', async () => {
 
   clearEventCalls()
 
-  await userEvent.type(element, '{selectall}')
+  userEvent.type(element, '{selectall}')
 
   expect(element.selectionStart).toBe(0)
   expect(element.selectionEnd).toBe(value.length)
@@ -570,10 +570,10 @@ test('{selectall} selects all the text', async () => {
   `)
 })
 
-test('{del} at the start of the input', async () => {
+test('{del} at the start of the input', () => {
   const {element, getEventSnapshot} = setup(`<input value="hello" />`)
 
-  await userEvent.type(element, '{del}', {
+  userEvent.type(element, '{del}', {
     initialSelectionStart: 0,
     initialSelectionEnd: 0,
   })
@@ -604,10 +604,10 @@ test('{del} at the start of the input', async () => {
   `)
 })
 
-test('{del} at end of the input', async () => {
+test('{del} at end of the input', () => {
   const {element, getEventSnapshot} = setup(`<input value="hello" />`)
 
-  await userEvent.type(element, '{del}')
+  userEvent.type(element, '{del}')
 
   expect(element.selectionStart).toBe(element.value.length)
   expect(element.selectionEnd).toBe(element.value.length)
@@ -633,10 +633,10 @@ test('{del} at end of the input', async () => {
   `)
 })
 
-test('{del} in the middle of the input', async () => {
+test('{del} in the middle of the input', () => {
   const {element, getEventSnapshot} = setup(`<input value="hello" />`)
 
-  await userEvent.type(element, '{del}', {
+  userEvent.type(element, '{del}', {
     initialSelectionStart: 2,
     initialSelectionEnd: 2,
   })
@@ -668,10 +668,10 @@ test('{del} in the middle of the input', async () => {
   `)
 })
 
-test('{del} with a selection range', async () => {
+test('{del} with a selection range', () => {
   const {element, getEventSnapshot} = setup(`<input value="hello" />`)
 
-  await userEvent.type(element, '{del}', {
+  userEvent.type(element, '{del}', {
     initialSelectionStart: 1,
     initialSelectionEnd: 3,
   })
@@ -706,20 +706,20 @@ test('{del} with a selection range', async () => {
 // TODO: eventually we'll want to support this, but currently we cannot
 // because selection ranges are (intentially) unsupported in certain input types
 // per the spec.
-test('{del} on an input that does not support selection range does not change the value', async () => {
+test('{del} on an input that does not support selection range does not change the value', () => {
   const {element, eventWasFired} = setup(`<input type="email" value="a@b.c" />`)
 
-  await userEvent.type(element, '{del}')
+  userEvent.type(element, '{del}')
   expect(element).toHaveValue('a@b.c')
   expect(eventWasFired('input')).not.toBe(true)
 })
 
-test('{del} does not delete if keydown is prevented', async () => {
+test('{del} does not delete if keydown is prevented', () => {
   const {element, eventWasFired} = setup(`<input value="hello" />`, {
     eventHandlers: {keyDown: e => e.preventDefault()},
   })
 
-  await userEvent.type(element, '{del}', {
+  userEvent.type(element, '{del}', {
     initialSelectionStart: 2,
     initialSelectionEnd: 2,
   })
@@ -729,10 +729,10 @@ test('{del} does not delete if keydown is prevented', async () => {
   expect(eventWasFired('input')).not.toBe(true)
 })
 
-test('any remaining type modifiers are automatically released at the end', async () => {
+test('any remaining type modifiers are automatically released at the end', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{meta}{alt}{ctrl}a{/alt}')
+  userEvent.type(element, '{meta}{alt}{ctrl}a{/alt}')
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
@@ -764,10 +764,10 @@ test('any remaining type modifiers are automatically released at the end', async
   `)
 })
 
-test('modifiers will not be closed if skipAutoClose is enabled', async () => {
+test('modifiers will not be closed if skipAutoClose is enabled', () => {
   const {element, getEventSnapshot} = setup('<input />')
 
-  await userEvent.type(element, '{meta}a', {skipAutoClose: true})
+  userEvent.type(element, '{meta}a', {skipAutoClose: true})
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="a"]
diff --git a/src/__tests__/type.js b/src/__tests__/type.js
index 77fdbe6d..2faefabf 100644
--- a/src/__tests__/type.js
+++ b/src/__tests__/type.js
@@ -2,9 +2,9 @@ import userEvent from '../'
 import {setup, addListeners} from './helpers/utils'
 import './helpers/custom-element'
 
-test('types text in input', async () => {
+test('types text in input', () => {
   const {element, getEventSnapshot} = setup('<input />')
-  await userEvent.type(element, 'Sup')
+  userEvent.type(element, 'Sup')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="Sup"]
 
@@ -39,11 +39,11 @@ test('types text in input', async () => {
   `)
 })
 
-test('can skip the initial click', async () => {
+test('can skip the initial click', () => {
   const {element, getEventSnapshot, clearEventCalls} = setup('<input />')
   element.focus() // users MUST focus themselves if they wish to skip the click
   clearEventCalls()
-  await userEvent.type(element, 'Sup', {skipClick: true})
+  userEvent.type(element, 'Sup', {skipClick: true})
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="Sup"]
 
@@ -65,13 +65,13 @@ test('can skip the initial click', async () => {
   `)
 })
 
-test('types text inside custom element', async () => {
+test('types text inside custom element', () => {
   const element = document.createElement('custom-el')
   document.body.append(element)
   const inputEl = element.shadowRoot.querySelector('input')
   const {getEventSnapshot} = addListeners(inputEl)
 
-  await userEvent.type(inputEl, 'Sup')
+  userEvent.type(inputEl, 'Sup')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value="Sup"]
 
@@ -106,9 +106,9 @@ test('types text inside custom element', async () => {
   `)
 })
 
-test('types text in textarea', async () => {
+test('types text in textarea', () => {
   const {element, getEventSnapshot} = setup('<textarea></textarea>')
-  await userEvent.type(element, 'Sup')
+  userEvent.type(element, 'Sup')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: textarea[value="Sup"]
 
@@ -143,12 +143,12 @@ test('types text in textarea', async () => {
   `)
 })
 
-test('does not fire input event when keypress calls prevent default', async () => {
+test('does not fire input event when keypress calls prevent default', () => {
   const {element, getEventSnapshot} = setup('<input />', {
     eventHandlers: {keyPress: e => e.preventDefault()},
   })
 
-  await userEvent.type(element, 'a')
+  userEvent.type(element, 'a')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
 
@@ -171,12 +171,12 @@ test('does not fire input event when keypress calls prevent default', async () =
   `)
 })
 
-test('does not fire keypress or input events when keydown calls prevent default', async () => {
+test('does not fire keypress or input events when keydown calls prevent default', () => {
   const {element, getEventSnapshot} = setup('<input />', {
     eventHandlers: {keyDown: e => e.preventDefault()},
   })
 
-  await userEvent.type(element, 'a')
+  userEvent.type(element, 'a')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
 
@@ -198,19 +198,19 @@ test('does not fire keypress or input events when keydown calls prevent default'
   `)
 })
 
-test('does not fire events when disabled', async () => {
+test('does not fire events when disabled', () => {
   const {element, getEventSnapshot} = setup('<input disabled />')
 
-  await userEvent.type(element, 'a')
+  userEvent.type(element, 'a')
   expect(getEventSnapshot()).toMatchInlineSnapshot(
     `No events were fired on: input[value=""]`,
   )
 })
 
-test('does not fire input when readonly', async () => {
+test('does not fire input when readonly', () => {
   const {element, getEventSnapshot} = setup('<input readonly />')
 
-  await userEvent.type(element, 'a')
+  userEvent.type(element, 'a')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: input[value=""]
 
@@ -255,9 +255,9 @@ test('should delay the typing when opts.delay is not 0', async () => {
   }
 })
 
-test('honors maxlength', async () => {
+test('honors maxlength', () => {
   const {element, getEventSnapshot} = setup('<input maxlength="2" />')
-  await userEvent.type(element, '123')
+  userEvent.type(element, '123')
 
   // NOTE: no input event when typing "3"
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
@@ -292,11 +292,11 @@ test('honors maxlength', async () => {
   `)
 })
 
-test('honors maxlength with existing text', async () => {
+test('honors maxlength with existing text', () => {
   const {element, getEventSnapshot} = setup(
     '<input value="12" maxlength="2" />',
   )
-  await userEvent.type(element, '3')
+  userEvent.type(element, '3')
 
   // NOTE: no input event when typing "3"
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
@@ -322,7 +322,7 @@ test('honors maxlength with existing text', async () => {
   `)
 })
 
-test('should fire events on the currently focused element', async () => {
+test('should fire events on the currently focused element', () => {
   const {element} = setup(`<div><input /><input /></div>`, {
     eventHandlers: {keyDown: handleKeyDown},
   })
@@ -338,27 +338,27 @@ test('should fire events on the currently focused element', async () => {
     }
   }
 
-  await userEvent.type(input1, text)
+  userEvent.type(input1, text)
 
   expect(input1).toHaveValue(text.slice(0, changeFocusLimit))
   expect(input2).toHaveValue(text.slice(changeFocusLimit))
   expect(input2).toHaveFocus()
 })
 
-test('should replace selected text', async () => {
+test('should replace selected text', () => {
   const {element} = setup('<input value="hello world" />')
   const selectionStart = 'hello world'.search('world')
   const selectionEnd = selectionStart + 'world'.length
   element.setSelectionRange(selectionStart, selectionEnd)
-  await userEvent.type(element, 'friend')
+  userEvent.type(element, 'friend')
   expect(element).toHaveValue('hello friend')
 })
 
-test('does not continue firing events when disabled during typing', async () => {
+test('does not continue firing events when disabled during typing', () => {
   const {element} = setup('<input />', {
     eventHandlers: {input: e => (e.target.disabled = true)},
   })
-  await userEvent.type(element, 'hi')
+  userEvent.type(element, 'hi')
   expect(element).toHaveValue('h')
 })
 
@@ -381,10 +381,10 @@ function setupDollarInput({initialValue = ''} = {}) {
   return returnValue
 }
 
-test('typing into a controlled input works', async () => {
+test('typing into a controlled input works', () => {
   const {element, getEventSnapshot} = setupDollarInput()
 
-  await userEvent.type(element, '23')
+  userEvent.type(element, '23')
 
   expect(element.value).toBe('$23')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
@@ -416,11 +416,11 @@ test('typing into a controlled input works', async () => {
   `)
 })
 
-test('typing in the middle of a controlled input works', async () => {
+test('typing in the middle of a controlled input works', () => {
   const {element, getEventSnapshot} = setupDollarInput({initialValue: '$23'})
   element.setSelectionRange(2, 2)
 
-  await userEvent.type(element, '1')
+  userEvent.type(element, '1')
 
   expect(element.value).toBe('$213')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
@@ -449,11 +449,11 @@ test('typing in the middle of a controlled input works', async () => {
   `)
 })
 
-test('ignored {backspace} in controlled input', async () => {
+test('ignored {backspace} in controlled input', () => {
   const {element, getEventSnapshot} = setupDollarInput({initialValue: '$23'})
   element.setSelectionRange(1, 1)
 
-  await userEvent.type(element, '{backspace}')
+  userEvent.type(element, '{backspace}')
   // this is the same behavior in the browser.
   // in our case, when you try to backspace the "$", our event handler
   // will ignore that change and React resets the value to what it was
@@ -462,7 +462,7 @@ test('ignored {backspace} in controlled input', async () => {
   // the selection start and end to the end of the input
   expect(element.selectionStart).toBe(element.value.length)
   expect(element.selectionEnd).toBe(element.value.length)
-  await userEvent.type(element, '4')
+  userEvent.type(element, '4')
 
   expect(element.value).toBe('$234')
   // the backslash in the inline snapshot is to escape the $ before {CURSOR}
@@ -507,18 +507,18 @@ test('ignored {backspace} in controlled input', async () => {
 })
 
 // https://github.com/testing-library/user-event/issues/346
-test('typing in an empty textarea', async () => {
+test('typing in an empty textarea', () => {
   const {element} = setup('<textarea></textarea>')
 
-  await userEvent.type(element, '1234')
+  userEvent.type(element, '1234')
   expect(element).toHaveValue('1234')
 })
 
 // https://github.com/testing-library/user-event/issues/321
-test('typing in a textarea with existing text', async () => {
+test('typing in a textarea with existing text', () => {
   const {element, getEventSnapshot} = setup('<textarea>Hello, </textarea>')
 
-  await userEvent.type(element, '12')
+  userEvent.type(element, '12')
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
     Events fired on: textarea[value="Hello, 12"]
 
@@ -551,11 +551,11 @@ test('typing in a textarea with existing text', async () => {
 })
 
 // https://github.com/testing-library/user-event/issues/321
-test('accepts an initialSelectionStart and initialSelectionEnd', async () => {
+test('accepts an initialSelectionStart and initialSelectionEnd', () => {
   const {element, getEventSnapshot} = setup('<textarea>Hello, </textarea>')
   element.setSelectionRange(0, 0)
 
-  await userEvent.type(element, '12', {
+  userEvent.type(element, '12', {
     initialSelectionStart: element.selectionStart,
     initialSelectionEnd: element.selectionEnd,
   })
@@ -593,18 +593,18 @@ test('accepts an initialSelectionStart and initialSelectionEnd', async () => {
 })
 
 // https://github.com/testing-library/user-event/issues/316#issuecomment-640199908
-test('can type into an input with type `email`', async () => {
+test('can type into an input with type `email`', () => {
   const {element} = setup('<input type="email" />')
   const email = 'yo@example.com'
-  await userEvent.type(element, email)
+  userEvent.type(element, email)
   expect(element).toHaveValue(email)
 })
 
 // https://github.com/testing-library/user-event/issues/336
-test('can type "-" into number inputs', async () => {
+test('can type "-" into number inputs', () => {
   const {element, getEventSnapshot} = setup('<input type="number" />')
   const negativeNumber = '-3'
-  await userEvent.type(element, negativeNumber)
+  userEvent.type(element, negativeNumber)
   expect(element).toHaveValue(-3)
 
   // NOTE: the input event here does not actually change the value thanks to
@@ -639,9 +639,9 @@ test('can type "-" into number inputs', async () => {
 })
 
 // https://github.com/testing-library/user-event/issues/336
-test('can type "." into number inputs', async () => {
+test('can type "." into number inputs', () => {
   const {element, getEventSnapshot} = setup('<input type="number" />')
-  await userEvent.type(element, '0.3')
+  userEvent.type(element, '0.3')
   expect(element).toHaveValue(0.3)
 
   expect(getEventSnapshot()).toMatchInlineSnapshot(`
@@ -678,23 +678,23 @@ test('can type "." into number inputs', async () => {
   `)
 })
 
-test('-{backspace}3', async () => {
+test('-{backspace}3', () => {
   const {element} = setup('<input type="number" />')
   const negativeNumber = '-{backspace}3'
-  await userEvent.type(element, negativeNumber)
+  userEvent.type(element, negativeNumber)
   expect(element).toHaveValue(3)
 })
 
-test('-a3', async () => {
+test('-a3', () => {
   const {element} = setup('<input type="number" />')
   const negativeNumber = '-a3'
-  await userEvent.type(element, negativeNumber)
+  userEvent.type(element, negativeNumber)
   expect(element).toHaveValue(-3)
 })
 
-test('typing an invalid input value', async () => {
+test('typing an invalid input value', () => {
   const {element} = setup('<input type="number" />')
-  await userEvent.type(element, '3-3')
+  userEvent.type(element, '3-3')
 
   // TODO: fix this bug
   // THIS IS A BUG! It should be expect(element.value).toBe('')
diff --git a/src/type.js b/src/type.js
index 98b5b977..4d06a20c 100644
--- a/src/type.js
+++ b/src/type.js
@@ -29,7 +29,7 @@ async function typeImpl(
   {
     skipClick = false,
     skipAutoClose = false,
-    delay,
+    delay = 0,
     initialSelectionStart,
     initialSelectionEnd,
   } = {},