async function promiseFinally (fn, finalFn) {
  let result
  try {
    if (typeof fn === 'function') {
      result = await fn()
    } else {
      result = await fn
    }
  } finally {
    finalFn()
  }
  return result
}

export const timeout = function timeout (fn, ms, msg) {
  let timerId
  const warpPromise = promiseFinally(fn, () => clearTimeout(timerId))
  const timerPromise = new Promise((resolve, reject) => {
    timerId = setTimeout(() => reject(new Error(msg)), ms)
  })
  return Promise.race([warpPromise, timerPromise])
}

export const waitFor = function waitFor (ms) {
  return new Promise(resolve => setTimeout(resolve, ms || 0))
}
export class Timer {
  constructor () {
    this._times = new Map()
  }

  start (name, description) {
    const time = {
      name,
      description,
      start: this.hrtime()
    }
    this._times.set(name, time)
    return time
  }

  end (name) {
    if (this._times.has(name)) {
      const time = this._times.get(name)
      time.duration = this.hrtime(time.start)
      this._times.delete(name)
      return time
    }
  }

  hrtime (start) {
    const useBigInt = typeof process.hrtime.bigint === 'function'
    if (start) {
      const end = useBigInt ? process.hrtime.bigint() : process.hrtime(start)
      return useBigInt
        ? (end - start) / BigInt(1000000)
        : (end[0] * 1e3) + (end[1] * 1e-6)
    }
    return useBigInt ? process.hrtime.bigint() : process.hrtime()
  }

  clear () {
    this._times.clear()
  }
}