code: function batch(fn, ctx) {
  		// Tag the function with unique id.
  		var uid = tag(fn);
  		// Produce a wrapper that queues the function for
  		// batched execution with the given arguments.
  		return function batched() {
  			// Partially apply arguments to the handler.
  			var args = Array.prototype.slice.call(arguments);
  			function handler(elapsed) { fn.apply(ctx, args.concat(elapsed)) }
  			// We are generating a new applied function each
  			// time, tag them with the same uid so that they
  			// will all be debounced correctly.
  			tag(handler, uid); schedule(handler);
  		};
  	}
docs: Next unique id to be produced. /*
  Wraps the given function so that it will only be executed
  during frame redraws. Optionally, pass a context to bind.
  
  Arguments passed to the wrapper will be proxied to the
  wrapped function when it runs, with the time since last
  execution stitched at the end.
  
  No more than one execution of the same function will be
  allowed per frame, and subsequent calls will be ignored.
  
  When called during a frame, the call will be scheduled for
  execution in the next batch instead.