Debouncing is a pattern for limiting how frequently a function executes by postponing its run until there has been a quiet period with no new calls for a given amount of time. When a JavaScript function is wrapped with a debounce and given a delay of X milliseconds, the actual execution must be pushed back until X milliseconds have passed since the most recent call to the debounced function.

A real‑world analogy is an elevator door: as long as someone keeps pressing the “Door open” button, the door remains open and the “close” action is repeatedly rescheduled. Only after nobody touches the button for X milliseconds does the door finally close, mirroring how the debounced callback eventually runs after a period of inactivity.

Write a debounce utility that takes a callback function and a wait time in milliseconds. The debounce() function should return a new function that, when invoked repeatedly, delays calling the original callback until there have been no further invocations for the full wait duration, following the behavior described above.

Examples

let executions = 0;

function track() {
  executions++;
  console.log('Executed:', executions);
}

const delayedTrack = debounce(track, 200);

// t = 0ms
delayedTrack(); // executions = 0

// t = 100ms
delayedTrack(); // executions = 0

// t = 300ms
// track() runs once after 200ms from the last call
// executions = 1

delayedTrack() is called multiple times.

let saveCount = 0;

function autoSave() {
  saveCount++;
}

const debouncedAutoSave = debounce(autoSave, 300);

// t = 0ms: User starts typing
debouncedAutoSave(); // saveCount = 0

// t = 120ms: User types again
debouncedAutoSave(); // saveCount = 0

// t = 220ms: Another keystroke
debouncedAutoSave(); // saveCount = 0

// t = 520ms:
// 300ms have passed since the last call at t = 220ms
// autoSave runs once → saveCount = 1