Function throttle

async/unstable_throttle.ts:103–168

(
  fn: (this: ThrottledFunction<T>, ...args: T) => void,
  timeframe: number | ((previousDuration: number) => number),
  options?: ThrottleOptions,
)

 */
// deno-lint-ignore no-explicit-any
export function throttle<T extends Array<any>>(
  fn: (this: ThrottledFunction<T>, ...args: T) => void,
  timeframe: number | ((previousDuration: number) => number),
  options?: ThrottleOptions,
): ThrottledFunction<T> {
  const ensureLast = Boolean(options?.ensureLastCall);
  let timeout: ReturnType<typeof setTimeout> | undefined;

  let lastExecution = -Infinity;
  let flush: (() => void) | null = null;
  let throttlingAsync = false;

  let tf = typeof timeframe === "function" ? 0 : timeframe;

  const throttled = ((...args: T) => {
    flush = () => {
      const start = Date.now();
      let result: unknown;
      const done = () => {
        throttlingAsync = false;
        lastExecution = Date.now();
        if (typeof timeframe === "function") {
          tf = timeframe(lastExecution - start);
        }
      };
      try {
        clearTimeout(timeout);
        result = fn.call(throttled, ...args);
      } finally {
        if (isPromiseLike(result)) {
          throttlingAsync = true;
          Promise.resolve(result).finally(done);
        } else {
          done();
        }
        flush = null;
      }
    };
    if (throttled.throttling) {
      if (ensureLast) {
        clearTimeout(timeout);
        timeout = setTimeout(() => flush?.(), tf);
      }
      return;
    }
    flush?.();
  }) as ThrottledFunction<T>;

  throttled.clear = () => {
    throttlingAsync = false;
    lastExecution = -Infinity;
  };

  throttled.flush = () => {
    flush?.();
  };

  Object.defineProperties(throttled, {