怎样避免深递归导致栈溢出？实现蹦床函数、大数阶乘和迭代版数组扁平化。

const THUNK = Symbol('thunk')
const thunk = fn => Object.assign(fn, { [THUNK]: true })

function trampoline(fn) {
  return function (...args) {
    let result = fn.apply(this, args)
    while (typeof result === 'function' && result[THUNK]) result = result()
    return result
  }
}

const sumTo = trampoline(function sum(n, acc = 0) {
  return n === 0 ? acc : thunk(() => sum(n - 1, acc + n))
})

function factorial(n) {
  if (!Number.isInteger(n) || n < 0) throw new RangeError('n 必须是非负整数')
  let result = 1n
  for (let i = 2n; i <= BigInt(n); i++) result *= i
  return result
}

function flattenDeep(input) {
  const result = []
  const active = new Set([input])
  const stack = [{ array: input, index: 0 }]
  while (stack.length) {
    const frame = stack[stack.length - 1]
    if (frame.index >= frame.array.length) {
      active.delete(frame.array)
      stack.pop()
      continue
    }
    const index = frame.index++
    if (!(index in frame.array)) continue
    const item = frame.array[index]
    if (Array.isArray(item)) {
      if (active.has(item)) throw new TypeError('数组存在循环引用')
      active.add(item)
      stack.push({ array: item, index: 0 })
    } else {
      result.push(item)
    }
  }
  return result
}