Test out how stack traces are formed

throws.ts

/* eslint-disable no-console */

const promise = new Promise<void>((resolve, reject) => {
  reject(new Error())
})

async function throwsFromPromiseOutside(): Promise<void> {
  return await promise
}

async function throwsFromPromiseOutsideFixed(): Promise<void> {
  try {
    await promise
  } catch (e) {
    Error.captureStackTrace(e)
    //Object.defineProperty(e, 'stack', { enumerable: true })
    console.log(JSON.stringify(e, null, 2))
    throw e
  }
}

async function throwsFromPromise(): Promise<void> {
  return await new Promise<void>((resolve, reject) => {
    reject(new Error())
  })
}

async function throwsFromAsync(): Promise<void> {
  throw new Error()
}

function throwsSync(): void {
  throw new Error()
}

async function main(): Promise<void> {
  try {
    await throwsFromPromiseOutside()
  } catch (e) {
    console.log(`throwsFromPromiseOutside`)
    console.error(e)
  }
  try {
    await throwsFromPromiseOutsideFixed()
  } catch (e) {
    console.log(`throwsFromPromiseOutsideFixed`)
    console.error(e)
  }
  try {
    await throwsFromPromise()
  } catch (e) {
    console.log(`throwsFromPromise`)
    console.error(e)
  }
  try {
    console.log(`throwsFromAsync`)
    await throwsFromAsync()
  } catch (e) {
    console.error(e)
  }
  try {
    console.log(`throwsSync`)
    await throwsSync()
  } catch (e) {
    console.error(e)
  }
}

main().catch(e => {
  console.error(e)
})