Как положено делать паузу в JavaScript?

function sleep (ms) {
  return new Promise(resolve => setTimeout(resolve, ms))
}

const n = selectedLinks.length;
for (let i = 1; i <= n; ++n) {
    setTimeout(_ => GM_openInTab(selectedLinks[i-1].href), 1000*i);
}

(function () {
  'use strict'

  // Increase this if the browser still opens tabs too quickly.
  const TAB_OPEN_DELAY_MS = 1000

  let modifierPressed = false
  let mouseupAttached = false
  let openingController = null
  let openingInProgress = false

  document.addEventListener('keydown', handleKeyDown, true)
  document.addEventListener('keyup', handleKeyUp, true)
  document.addEventListener('mouseup', handleMouseUp, true)

  window.addEventListener('blur', resetModifier)
  window.addEventListener('pagehide', cancelOpening)

  function handleKeyDown(event) {
    if (event.key === 'Escape') {
      cancelOpening()
      return
    }

    if (!isModifierKey(event)) return

    modifierPressed = true
    mouseupAttached = true
  }

  function handleKeyUp(event) {
    if (!isModifierKey(event)) return

    modifierPressed = false
    mouseupAttached = false
  }

  function handleMouseUp(event) {
    if (!mouseupAttached) return

    if (!modifierPressed && !event.ctrlKey && !event.metaKey) {
      return
    }

    // Prevent the same mouseup from starting another opening sequence.
    mouseupAttached = false

    void openSelectedLinks()
  }

  function isModifierKey(event) {
    return event.key === 'Control' || event.key === 'Meta'
  }

  async function openSelectedLinks() {
    // Do not allow two tab-opening loops to run concurrently.
    if (openingInProgress) return

    const links = getSelectedLinks()

    if (links.length === 0) return

    openingInProgress = true
    openingController = new AbortController()

    const signal = openingController.signal

    try {
      for (const url of links) {
        if (signal.aborted) break

        GM_openInTab(url, {
          active: false,
          insert: true,
          setParent: true
        })

        // Always wait before opening the next tab.
        await delay(TAB_OPEN_DELAY_MS, signal)
      }
    } catch (error) {
      if (error?.name !== 'AbortError') {
        console.error('[Open Selected Links]', error)
      }
    } finally {
      openingController = null
      openingInProgress = false
    }
  }

  function getSelectedLinks() {
    const selection = window.getSelection()

    if (
      !selection ||
      selection.rangeCount === 0 ||
      selection.isCollapsed
    ) {
      return []
    }

    const urls = new Set()

    for (let index = 0; index < selection.rangeCount; index++) {
      const range = selection.getRangeAt(index)
      const fragment = range.cloneContents()

      fragment.querySelectorAll('a[href]').forEach(link => {
        addLink(link, urls)
      })

      addContainingLink(range.startContainer, urls)
      addContainingLink(range.endContainer, urls)
    }

    return Array.from(urls)
  }

  function addContainingLink(node, urls) {
    const element = node.nodeType === Node.ELEMENT_NODE
      ? node
      : node.parentElement

    addLink(element?.closest?.('a[href]'), urls)
  }

  function addLink(link, urls) {
    if (!link || shouldIgnoreLink(link)) return

    try {
      const url = new URL(link.getAttribute('href'), location.href)

      if (url.protocol !== 'http:' && url.protocol !== 'https:') {
        return
      }

      urls.add(url.href)
    } catch (error) {
      console.debug('[Open Selected Links] Invalid URL ignored', error)
    }
  }

  function shouldIgnoreLink(link) {
    if (!isGoogleResultsPage()) return false

    const text = link.textContent.trim().toLowerCase()

    return text === 'cached' || text === 'similar'
  }

  function isGoogleResultsPage() {
    return (
      location.hostname === 'google.com' ||
      location.hostname.startsWith('www.google.') ||
      location.hostname.includes('.google.')
    )
  }

  function delay(milliseconds, signal) {
    return new Promise((resolve, reject) => {
      if (signal.aborted) {
        reject(createAbortError())
        return
      }

      const timeout = window.setTimeout(() => {
        signal.removeEventListener('abort', handleAbort)
        resolve()
      }, milliseconds)

      function handleAbort() {
        window.clearTimeout(timeout)
        reject(createAbortError())
      }

      signal.addEventListener('abort', handleAbort, {
        once: true
      })
    })
  }

  function createAbortError() {
    return new DOMException('Tab opening cancelled', 'AbortError')
  }

  function resetModifier() {
    modifierPressed = false
    mouseupAttached = false
  }

  function cancelOpening() {
    openingController?.abort()
  }
})()