Limit using Points and duration on demand
Hi @animir Congratulations for your library! Very complete!

I was using [Express Rate Limit](https://www.npmjs.com/package/express-rate-limit) as the rate limiter for my Express API. However, I have recently changed my app to use Nodejs' [Cluster](https://nodejs.org/api/cluster.html) module, so I had to look for another library that supported cluster features. And I found Rate Limiter Flexible.

However I don't know how to implement the same functionality I had: **some endpoints had a different limitation configuration, but limitation/blocking was global**. For example: `/login` has a limit of 10 requests per minute, and `/users/:userId` has a limit of 1000 requests per 5 minutes. If a user consumed the 10 requests in `/login`, he could not request `/user/:userId` because he had already reached a 429 error status from another endpoint (`/login`).

It was a simple middleware like:
```
// Router middleware
router.post('/login', RateLimiter.limiter(10, 1 * 60), myController) // 10 req in 1 min
router.get('/users/:userId', RateLimiter.limiter(1000, 5 * 60), myController) // 1000 req in 5 min

// Rate limiter
import rateLimit from 'express-rate-limit'
export function limiter (requests, intervalSeconds) {
  return rateLimit({
    windowMs: intervalSeconds || config.defaultIntervalSeconds,
    max: requests || config.defaultMaxRequests,
    onLimitReached, // Log the error
    keyGenerator, // Generate a key from the IP
    skip: () => !config.isEnabled
  })
}
```

However, I don't know how to implement it with Rate Limiter Flexible, as if I create two instances (one for each endpoint), if user consumes all points in one endpoint, **he can still consume points of the second endpoint**:

```
export function limiter (requests, intervalSeconds) {
  return function (req, res, next) {
    // Skip rate-limiter if not enabled
    if (config.isEnabled !== true) return next()

    const allowedRequests = requests || config.maxRequests
    const duration = intervalSeconds || config.intervalSeconds

    rateLimiter = new RateLimiterCluster({
      keyPrefix: 'rate-limiter',
      points: allowedRequests,
      duration,
      timeoutMs: 3000
    })

    return rateLimiter.consume(keyGenerator(req))
      .then(()=> {
        return next()
      })
      .catch(()=> {
        return res.status(429).json({})
      })
  }
}
```

Is there a way to achieve the same functionality in Rate Limiter Flexible? Or do you think of a way to handle this with this library?

Thank you so much.