Performance of multiple calls to consume
First off, thanks for making this great library!

I'm doing a spike right now to see if it's suitable for a project at work.  At a high level, we would like to achieve something along these lines:

```typescript
// Make buckets to rate limit by ip, username, and a global rate limiter for the whole route:
const rateLimitIpKey = `signin-${sha256(req.ip)}`;
const rateLimitUsernameKey = `signin-${sha256(username)}`;
const rateLimitGlobalKey = `signin-global`;

// Allow points to be consumed in an order of precedence only if the previous rate limit is not reached
// This is so that a single user is stopped from being able to consume all of our global tokens and execute a DOS attack
const rateLimitedIp = await redisLimiter.consume(rateLimitIpKey, 1);

// Check that the ip limit has not been reached. If it hasn't consume a token from the username check
const rateLimitedUsername = checkNotReachedLimit(rateLimitedIp) && await redisLimiter.consume(rateLimitUsernameKey, 1);

// Check the username limit has not been reached. If it hasn't consume a token from the global check
const rateLimitedGlobal = checkNotReachedLimit(rateLimitedUsername) && await redisLimiter.consume(rateLimitGlobalKey, 1);

// ... application code continues 
```

The main concern I have with this approach is the three calls to `consume` not being very efficient, especially as for most users we'll be making all three calls to `consume`.

Is something happening behind the scenes to batch requests with pipelining or would this approach simply not be sustainable for a high request rate?

