RateLimiterRedis: Block set with secDuration=0 is reset on a consume method call
Hi
Thanks for this great library, saves a lot of time. 

I have been testing the library and have a few questions about how it works for the block api method.

When a key is blocked with `secDuration=0` it correctly rejects the `.consume` call. However it resets the `msBeforeNext` to the original duration value. Once the duration has expired the key no longer rejects. Is this the expected behavior?

And if it is, what would be the best way to block the key indefinitely at runtime.

Here is a test case using `ava`.

```js
import {RateLimiterRedis} from "rate-limiter-flexible";
import test from "ava";

test(`RateLimiter blocked will reject consume but will reset "msBeforeNext" to the original duration, hence points are reset after duration`, async t => {
    const points = 5;
    const durationMs = 1000;
    const rateLimiterRedis = new RateLimiterRedis({
        storeClient: redisClient,   //ioRedis client
        points     : points,
        duration   : durationMs / 1000,
        keyPrefix  : "TestBlocking"
    });
    let res, key1 = `keyBlockedRejectsAlways_${Date.now()}`;

    // Consume a point
    res = await rateLimiterRedis.consume(key1, 1);
    t.assert(res && res.remainingPoints === points - 1);

    // Block the key
    res = await rateLimiterRedis.block(key1, 0);
    t.assert(res.remainingPoints === 0 && res.msBeforeNext === -1 && res.consumedPoints === points + 1);
    try {
        res = await rateLimiterRedis.consume(key1, 1)
        t.fail(`Consume after block should have failed. ${JSON.stringify(res)}`);
    } catch (rateLimiterRes) {
        t.assert(rateLimiterRes.remainingPoints === 0 && rateLimiterRes.msBeforeNext === durationMs && rateLimiterRes.consumedPoints === points + 2,
            `Should have rejected with expected keys. ${JSON.stringify(rateLimiterRes)}`);
    }

    // sleep for durationMs
    await sleep(durationMs + 50);
    try {
        res = await rateLimiterRedis.consume(key1, 1);
        t.fail(`Consume after block should have failed. ${JSON.stringify(res)}`);
    } catch (e) {
        t.assert(e && e.remainingPoints === 0 && e.msBeforeNext === durationMs && res.consumedPoints === points + 3);
    }
});
```

and the sleep function is a plain old promise

```js
function sleep(ms: number) {
    return new Promise((resolve) => {
        setTimeout(resolve, ms)
    })
}
```