faastjs/dist/src/throttle.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsyncOrderedQueue = exports.AsyncIterableQueue = exports.AsyncQueue = exports.throttle = exports.cacheFn = exports.memoizeFn = exports.RateLimiter = exports.Pump = exports.Funnel = exports.retryOp = exports.DeferredWorker = exports.Deferred = void 0;
const assert = require("assert");
const crypto_1 = require("crypto");
const error_1 = require("./error");
const serialize_1 = require("./serialize");
const shared_1 = require("./shared");
class Deferred {
    constructor() {
        this.promise = new Promise((resolve, reject) => {
            this.resolve = resolve;
            this.reject = reject;
        });
    }
}
exports.Deferred = Deferred;
class DeferredWorker extends Deferred {
    constructor(worker, cancel) {
        super();
        this.worker = worker;
        this.cancel = cancel;
    }
    async execute() {
        const cancelMessage = this.cancel?.();
        if (cancelMessage) {
            this.reject(new error_1.FaastError({ name: error_1.FaastErrorNames.ECANCEL }, cancelMessage));
        }
        else {
            try {
                const rv = await this.worker();
                this.resolve(rv);
            }
            catch (err) {
                this.reject(err);
            }
        }
    }
}
exports.DeferredWorker = DeferredWorker;
function popFirst(set) {
    let firstElem;
    for (const elem of set) {
        firstElem = elem;
        break;
    }
    if (firstElem) {
        set.delete(firstElem);
    }
    return firstElem;
}
async function retryOp(retryN, fn) {
    const retryTest = typeof retryN === "function" ? retryN : (_, i) => i < retryN;
    for (let i = 0; true; i++) {
        try {
            return await fn(i);
        }
        catch (err) {
            if (!retryTest(err, i)) {
                throw err;
            }
            await (0, shared_1.sleep)(Math.min(30 * 1000, 1000 * (1 + Math.random()) * 2 ** i) + Math.random());
        }
    }
}
exports.retryOp = retryOp;
class Funnel {
    constructor(concurrency = 0, shouldRetry) {
        this.concurrency = concurrency;
        this.shouldRetry = shouldRetry;
        this.pendingQueue = new Set();
        this.executingQueue = new Set();
        this.processed = 0;
        this.errors = 0;
    }
    push(worker, shouldRetry, cancel) {
        const retryTest = shouldRetry || this.shouldRetry || 0;
        const retryWorker = () => retryOp(retryTest, worker);
        const future = new DeferredWorker(retryWorker, cancel);
        this.pendingQueue.add(future);
        setImmediate(() => this.doWork());
        return future.promise;
    }
    clear() {
        this.pendingQueue.clear();
        this.executingQueue.clear();
    }
    promises() {
        return [...this.executingQueue, ...this.pendingQueue].map(p => p.promise);
    }
    all() {
        return Promise.all(this.promises().map(p => p.catch(_ => { })));
    }
    size() {
        return this.pendingQueue.size + this.executingQueue.size;
    }
    setMaxConcurrency(maxConcurrency) {
        this.concurrency = maxConcurrency;
    }
    getConcurrency() {
        return this.executingQueue.size;
    }
    doWork() {
        const { pendingQueue } = this;
        while (pendingQueue.size > 0 &&
            (!this.concurrency || this.executingQueue.size < this.concurrency)) {
            const worker = popFirst(pendingQueue);
            this.executingQueue.add(worker);
            worker.promise
                .then(_ => this.processed++)
                .catch(_ => this.errors++)
                .then(_ => {
                this.executingQueue.delete(worker);
                this.doWork();
            });
            worker.execute();
        }
    }
}
exports.Funnel = Funnel;
/**
 * @internal
 */
class Pump extends Funnel {
    constructor(options, worker) {
        super(options.concurrency);
        this.options = options;
        this.worker = worker;
        this.stopped = false;
        options.verbose = options.verbose ?? true;
    }
    start() {
        const restart = () => {
            if (this.stopped) {
                return;
            }
            while (this.executingQueue.size + this.pendingQueue.size < this.concurrency) {
                this.push(async () => {
                    try {
                        return await this.worker();
                    }
                    catch (err) {
                        this.options.verbose && console.error(err);
                        return;
                    }
                    finally {
                        setImmediate(restart);
                    }
                });
            }
        };
        this.stopped = false;
        restart();
    }
    stop() {
        this.stopped = true;
    }
    drain() {
        this.stop();
        return this.all();
    }
    setMaxConcurrency(concurrency) {
        super.setMaxConcurrency(concurrency);
        if (!this.stopped) {
            this.start();
        }
    }
}
exports.Pump = Pump;
class RateLimiter {
    constructor(targetRequestsPerSecond, burst = 1) {
        this.targetRequestsPerSecond = targetRequestsPerSecond;
        this.burst = burst;
        this.lastTick = 0;
        this.bucket = 0;
        this.queue = new Set();
        assert(targetRequestsPerSecond > 0);
        assert(this.burst >= 1);
    }
    push(worker, cancel) {
        this.updateBucket();
        if (this.queue.size === 0 && this.bucket <= this.burst - 1) {
            this.bucket++;
            return worker();
        }
        const future = new DeferredWorker(worker, cancel);
        this.queue.add(future);
        if (this.queue.size === 1) {
            this.drainQueue();
        }
        return future.promise;
    }
    updateBucket() {
        const now = Date.now();
        const secondsElapsed = (now - this.lastTick) / 1000;
        this.bucket -= secondsElapsed * this.targetRequestsPerSecond;
        this.bucket = Math.max(this.bucket, 0);
        this.lastTick = now;
    }
    async drainQueue() {
        const requestAmountToDrain = 1 - (this.burst - this.bucket);
        const secondsToDrain = requestAmountToDrain / this.targetRequestsPerSecond;
        if (secondsToDrain > 0) {
            await (0, shared_1.sleep)(Math.ceil(secondsToDrain * 1000));
        }
        this.updateBucket();
        while (this.bucket <= this.burst - 1) {
            const next = popFirst(this.queue);
            if (!next) {
                break;
            }
            this.bucket++;
            next.execute();
        }
        if (this.queue.size > 0) {
            this.drainQueue();
        }
    }
    clear() {
        this.queue.clear();
    }
}
exports.RateLimiter = RateLimiter;
function memoizeFn(fn, cache = new Map()) {
    return (...args) => {
        const key = JSON.stringify(args);
        const prev = cache.get(key);
        if (prev) {
            return prev;
        }
        const value = fn(...args);
        cache.set(key, value);
        return value;
    };
}
exports.memoizeFn = memoizeFn;
function cacheFn(cache, fn) {
    return async (...args) => {
        const key = (0, serialize_1.serialize)(args, true);
        const hasher = (0, crypto_1.createHash)("sha256");
        hasher.update(key);
        const cacheKey = hasher.digest("hex");
        const prev = await cache.get(cacheKey);
        if (prev) {
            const str = prev.toString();
            if (str === "undefined") {
                return undefined;
            }
            return (0, serialize_1.deserialize)(str);
        }
        const value = await fn(...args);
        await cache.set(cacheKey, (0, serialize_1.serialize)(value, true));
        return value;
    };
}
exports.cacheFn = cacheFn;
/**
 * A decorator for rate limiting, concurrency limiting, retry, memoization, and
 * on-disk caching. See {@link Limits}.
 * @remarks
 * When programming against cloud services, databases, and other resources, it
 * is often necessary to control the rate of request issuance to avoid
 * overwhelming the service provider. In many cases the provider has built-in
 * safeguards against abuse, which automatically fail requests if they are
 * coming in too fast. Some systems don't have safeguards and precipitously
 * degrade their service level or fail outright when faced with excessive load.
 *
 * With faast.js it becomes very easy to (accidentally) generate requests from
 * thousands of cloud functions. The `throttle` function can help manage request
 * flow without resorting to setting up a separate service. This is in keeping
 * with faast.js' zero-ops philosophy.
 *
 * Usage is simple:
 *
 * ```typescript
 * async function operation() { ... }
 * const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);
 * for(let i = 0; i < 100; i++) {
 *     // at most 10 concurrent executions at a rate of 5 invocations per second.
 *     throttledOperation();
 * }
 * ```
 *
 * Note that each invocation to `throttle` creates a separate function with a
 * separate limits. Therefore it is likely that you want to use `throttle` in a
 * global context, not within a dynamic context:
 *
 * ```typescript
 * async function operation() { ... }
 * for(let i = 0; i < 100; i++) {
 *     // WRONG - each iteration creates a separate throttled function that's only called once.
 *     const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);
 *     throttledOperation();
 * }
 * ```
 *
 * A better way to use throttle avoids creating a named `operation` function
 * altogether, ensuring it cannot be accidentally called without throttling:
 *
 * ```typescript
 * const operation = throttle({ concurrency: 10, rate: 5 }, async () => {
 *     ...
 * });
 * ```
 *
 * Throttle supports functions with arguments automatically infers the correct
 * type for the returned function:
 *
 * ```typescript
 * // `operation` inferred to have type (str: string) => Promise<string>
 * const operation = throttle({ concurrency: 10, rate: 5 }, async (str: string) => {
 *     return string;
 * });
 * ```
 *
 * In addition to limiting concurrency and invocation rate, `throttle` also
 * supports retrying failed invocations, memoizing calls, and on-disk caching.
 * See {@link Limits} for details.
 *
 * @param limits - see {@link Limits}.
 * @param fn - The function to throttle. It can take any arguments, but must
 * return a Promise (which includes `async` functions).
 * @returns Returns a throttled function with the same signature as the argument
 * `fn`.
 * @public
 */
function throttle(limits, fn) {
    const { concurrency, retry, rate, burst, memoize, cache, cancel } = limits;
    const funnel = new Funnel(concurrency, retry);
    const cancellationQueue = [() => funnel.clear()];
    let conditionedFunc;
    if (rate) {
        const rateLimiter = new RateLimiter(rate, burst);
        cancellationQueue.push(() => rateLimiter.clear());
        conditionedFunc = (...args) => funnel.push(() => rateLimiter.push(() => fn(...args)));
    }
    else {
        conditionedFunc = (...args) => funnel.push(() => fn(...args));
    }
    if (cache) {
        conditionedFunc = cacheFn(cache, conditionedFunc);
    }
    if (memoize) {
        const mcache = new Map();
        cancellationQueue.push(() => mcache.clear());
        conditionedFunc = memoizeFn(conditionedFunc, mcache);
    }
    cancel?.then(() => cancellationQueue.forEach(cleanupFn => cleanupFn()));
    return conditionedFunc;
}
exports.throttle = throttle;
function iteratorResult(value) {
    return Promise.resolve(value).then(v => ({ done: false, value: v }));
}
const done = Promise.resolve({ done: true, value: undefined });
class AsyncQueue {
    constructor() {
        this.deferred = [];
        this.enqueued = [];
    }
    enqueue(value) {
        if (this.deferred.length > 0) {
            const d = this.deferred.shift();
            d.resolve(value);
        }
        else {
            this.enqueued.push(Promise.resolve(value));
        }
    }
    next() {
        if (this.enqueued.length > 0) {
            return this.enqueued.shift();
        }
        const d = new Deferred();
        this.deferred.push(d);
        return d.promise;
    }
    clear() {
        this.deferred = [];
        this.enqueued = [];
    }
}
exports.AsyncQueue = AsyncQueue;
class AsyncIterableQueue extends AsyncQueue {
    push(value) {
        super.enqueue(iteratorResult(value));
    }
    done() {
        super.enqueue(done);
    }
    [Symbol.asyncIterator]() {
        return this;
    }
}
exports.AsyncIterableQueue = AsyncIterableQueue;
class AsyncOrderedQueue {
    constructor() {
        this.queue = new AsyncQueue();
        this.arrived = new Map();
        this.current = 0;
    }
    push(value, sequence) {
        this.enqueue(Promise.resolve(value), sequence);
    }
    pushImmediate(value) {
        this.queue.enqueue(value);
    }
    enqueue(value, sequence) {
        if (sequence < this.current) {
            return;
        }
        if (!this.arrived.has(sequence)) {
            this.arrived.set(sequence, value);
        }
        while (this.arrived.has(this.current)) {
            this.queue.enqueue(this.arrived.get(this.current));
            this.arrived.delete(this.current);
            this.current++;
        }
    }
    next() {
        return this.queue.next();
    }
    clear() {
        this.arrived.clear();
        this.queue.clear();
        this.current = 0;
    }
}
exports.AsyncOrderedQueue = AsyncOrderedQueue;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"throttle.js","sourceRoot":"","sources":["../../src/throttle.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from \"assert\";\nimport { createHash } from \"crypto\";\nimport { PersistentCache } from \"./cache\";\nimport { FaastError, FaastErrorNames } from \"./error\";\nimport { deserialize, serialize } from \"./serialize\";\nimport { sleep } from \"./shared\";\n\nexport class Deferred<T = void> {\n    promise: Promise<T>;\n    resolve!: (arg: T | PromiseLike<T>) => void;\n    reject!: (err?: any) => void;\n    constructor() {\n        this.promise = new Promise<T>((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n    }\n}\n\nexport class DeferredWorker<T = void> extends Deferred<T> {\n    constructor(\n        private worker: () => Promise<T>,\n        private cancel?: () => string | undefined\n    ) {\n        super();\n    }\n    async execute() {\n        const cancelMessage = this.cancel?.();\n        if (cancelMessage) {\n            this.reject(new FaastError({ name: FaastErrorNames.ECANCEL }, cancelMessage));\n        } else {\n            try {\n                const rv = await this.worker();\n                this.resolve(rv);\n            } catch (err: any) {\n                this.reject(err);\n            }\n        }\n    }\n}\n\nfunction popFirst<T>(set: Set<T>): T | undefined {\n    let firstElem: T | undefined;\n    for (const elem of set) {\n        firstElem = elem;\n        break;\n    }\n    if (firstElem) {\n        set.delete(firstElem);\n    }\n    return firstElem;\n}\n\nexport type RetryType = number | ((err: any, retries: number) => boolean);\n\nexport async function retryOp<T>(retryN: RetryType, fn: (retries: number) => Promise<T>) {\n    const retryTest =\n        typeof retryN === \"function\" ? retryN : (_: any, i: number) => i < retryN;\n    for (let i = 0; true; i++) {\n        try {\n            return await fn(i);\n        } catch (err: any) {\n            if (!retryTest(err, i)) {\n                throw err;\n            }\n            await sleep(\n                Math.min(30 * 1000, 1000 * (1 + Math.random()) * 2 ** i) + Math.random()\n            );\n        }\n    }\n}\n\nexport class Funnel<T = void> {\n    protected pendingQueue: Set<DeferredWorker<T>> = new Set();\n    protected executingQueue: Set<DeferredWorker<T>> = new Set();\n    public processed = 0;\n    public errors = 0;\n\n    constructor(public concurrency: number = 0, protected shouldRetry?: RetryType) {}\n\n    push(\n        worker: () => Promise<T>,\n        shouldRetry?: RetryType,\n        cancel?: () => string | undefined\n    ) {\n        const retryTest = shouldRetry || this.shouldRetry || 0;\n        const retryWorker = () => retryOp(retryTest, worker);\n        const future = new DeferredWorker(retryWorker, cancel);\n        this.pendingQueue.add(future);\n        setImmediate(() => this.doWork());\n        return future.promise;\n    }\n\n    clear() {\n        this.pendingQueue.clear();\n        this.executingQueue.clear();\n    }\n\n    promises() {\n        return [...this.executingQueue, ...this.pendingQueue].map(p => p.promise);\n    }\n\n    all() {\n        return Promise.all(this.promises().map(p => p.catch(_ => {})));\n    }\n\n    size() {\n        return this.pendingQueue.size + this.executingQueue.size;\n    }\n\n    setMaxConcurrency(maxConcurrency: number) {\n        this.concurrency = maxConcurrency;\n    }\n\n    getConcurrency() {\n        return this.executingQueue.size;\n    }\n\n    protected doWork() {\n        const { pendingQueue } = this;\n        while (\n            pendingQueue.size > 0 &&\n            (!this.concurrency || this.executingQueue.size < this.concurrency)\n        ) {\n            const worker = popFirst(pendingQueue)!;\n            this.executingQueue.add(worker);\n\n            worker.promise\n                .then(_ => this.processed++)\n                .catch(_ => this.errors++)\n                .then(_ => {\n                    this.executingQueue.delete(worker);\n                    this.doWork();\n                });\n            worker.execute();\n        }\n    }\n}\n\n/**\n * @internal\n */\nexport interface PumpOptions {\n    concurrency: number;\n    verbose?: boolean;\n}\n\n/**\n * @internal\n */\nexport class Pump<T = void> extends Funnel<T | void> {\n    stopped: boolean = false;\n    constructor(protected options: PumpOptions, protected worker: () => Promise<T>) {\n        super(options.concurrency);\n        options.verbose = options.verbose ?? true;\n    }\n\n    start() {\n        const restart = () => {\n            if (this.stopped) {\n                return;\n            }\n            while (this.executingQueue.size + this.pendingQueue.size < this.concurrency) {\n                this.push(async () => {\n                    try {\n                        return await this.worker();\n                    } catch (err: any) {\n                        this.options.verbose && console.error(err);\n                        return;\n                    } finally {\n                        setImmediate(restart);\n                    }\n                });\n            }\n        };\n        this.stopped = false;\n        restart();\n    }\n\n    stop() {\n        this.stopped = true;\n    }\n\n    drain() {\n        this.stop();\n        return this.all();\n    }\n\n    setMaxConcurrency(concurrency: number) {\n        super.setMaxConcurrency(concurrency);\n        if (!this.stopped) {\n            this.start();\n        }\n    }\n}\n\nexport class RateLimiter<T = void> {\n    protected lastTick = 0;\n    protected bucket = 0;\n    protected queue: Set<DeferredWorker<T>> = new Set();\n\n    constructor(protected targetRequestsPerSecond: number, protected burst: number = 1) {\n        assert(targetRequestsPerSecond > 0);\n        assert(this.burst >= 1);\n    }\n\n    push(worker: () => Promise<T>, cancel?: () => string | undefined) {\n        this.updateBucket();\n        if (this.queue.size === 0 && this.bucket <= this.burst - 1) {\n            this.bucket++;\n            return worker();\n        }\n\n        const future = new DeferredWorker(worker, cancel);\n        this.queue.add(future);\n        if (this.queue.size === 1) {\n            this.drainQueue();\n        }\n        return future.promise;\n    }\n\n    protected updateBucket() {\n        const now = Date.now();\n        const secondsElapsed = (now - this.lastTick) / 1000;\n        this.bucket -= secondsElapsed * this.targetRequestsPerSecond;\n        this.bucket = Math.max(this.bucket, 0);\n        this.lastTick = now;\n    }\n\n    protected async drainQueue() {\n        const requestAmountToDrain = 1 - (this.burst - this.bucket);\n        const secondsToDrain = requestAmountToDrain / this.targetRequestsPerSecond;\n        if (secondsToDrain > 0) {\n            await sleep(Math.ceil(secondsToDrain * 1000));\n        }\n        this.updateBucket();\n        while (this.bucket <= this.burst - 1) {\n            const next = popFirst(this.queue);\n            if (!next) {\n                break;\n            }\n            this.bucket++;\n            next.execute();\n        }\n        if (this.queue.size > 0) {\n            this.drainQueue();\n        }\n    }\n\n    clear() {\n        this.queue.clear();\n    }\n}\n\n/**\n * Specify {@link throttle} limits. These limits shape the way throttle invokes\n * the underlying function.\n * @public\n */\nexport interface Limits {\n    /**\n     * The maximum number of concurrent executions of the underlying function to\n     * allow. Must be supplied, there is no default. Specifying `0` or\n     * `Infinity` is allowed and means there is no concurrency limit.\n     */\n    concurrency: number;\n    /**\n     * The maximum number of calls per second to allow to the underlying\n     * function. Default: no rate limit.\n     */\n    rate?: number;\n    /**\n     * The maximum number of calls to the underlying function to \"burst\" -- e.g.\n     * the number that can be issued immediately as long as the rate limit is\n     * not exceeded. For example, if rate is 5 and burst is 5, and 10 calls are\n     * made to the throttled function, 5 calls are made immediately and then\n     * after 1 second, another 5 calls are made immediately. Setting burst to 1\n     * means calls are issued uniformly every `1/rate` seconds. If `rate` is not\n     * specified, then `burst` does not apply. Default: 1.\n     */\n    burst?: number;\n    /**\n     * Retry if the throttled function returns a rejected promise. `retry` can\n     * be a number or a function. If it is a number `N`, then up to `N`\n     * additional attempts are made in addition to the initial call. If retry is\n     * a function, it should return `true` if another retry attempt should be\n     * made, otherwise `false`. The first argument will be the value of the\n     * rejected promise from the previous call attempt, and the second argument\n     * will be the number of previous retry attempts (e.g. the first call will\n     * have value 0). Default: 0 (no retry attempts).\n     */\n    retry?: number | ((err: any, retries: number) => boolean);\n    /**\n     * If `memoize` is `true`, then every call to the throttled function will be\n     * saved as an entry in a map from arguments to return value. If same\n     * arguments are seen again in a future call, the return value is retrieved\n     * from the Map rather than calling the function again. This can be useful\n     * for avoiding redundant calls that are expected to return the same results\n     * given the same arguments.\n     *\n     * The arguments will be captured with `JSON.stringify`, therefore types\n     * that do not stringify uniquely won't be distinguished from each other.\n     * Care must be taken when specifying `memoize` to ensure avoid incorrect\n     * results.\n     */\n    memoize?: boolean;\n    /**\n     * Similar to `memoize` except the map from function arguments to results is\n     * stored in a persistent cache on disk. This is useful to prevent redundant\n     * calls to APIs which are expected to return the same results for the same\n     * arguments, and which are likely to be called across many faast.js module\n     * instantiations. This is used internally by faast.js for caching cloud\n     * prices for AWS and Google, and for saving the last garbage collection\n     * date for AWS. Persistent cache entries expire after a period of time. See\n     * {@link PersistentCache}.\n     */\n    cache?: PersistentCache;\n    /**\n     * A promise that, if resolved, causes cancellation of pending throttled\n     * invocations. This is typically created using `Deferred`. The idea is to\n     * use the resolving of the promise as an asynchronous signal that any\n     * pending invocations in this throttled function should be cleared.\n     * @internal\n     */\n    cancel?: Promise<void>;\n}\n\nexport function memoizeFn<A extends any[], R>(\n    fn: (...args: A) => R,\n    cache: Map<string, R> = new Map()\n) {\n    return (...args: A) => {\n        const key = JSON.stringify(args);\n        const prev = cache.get(key);\n        if (prev) {\n            return prev;\n        }\n        const value = fn(...args);\n        cache.set(key, value);\n        return value;\n    };\n}\n\nexport function cacheFn<A extends any[], R>(\n    cache: PersistentCache,\n    fn: (...args: A) => Promise<R>\n) {\n    return async (...args: A) => {\n        const key = serialize(args, true);\n        const hasher = createHash(\"sha256\");\n        hasher.update(key);\n        const cacheKey = hasher.digest(\"hex\");\n        const prev = await cache.get(cacheKey);\n        if (prev) {\n            const str = prev.toString();\n            if (str === \"undefined\") {\n                return undefined;\n            }\n            return deserialize(str);\n        }\n        const value = await fn(...args);\n        await cache.set(cacheKey, serialize(value, true));\n        return value;\n    };\n}\n\n/**\n * A decorator for rate limiting, concurrency limiting, retry, memoization, and\n * on-disk caching. See {@link Limits}.\n * @remarks\n * When programming against cloud services, databases, and other resources, it\n * is often necessary to control the rate of request issuance to avoid\n * overwhelming the service provider. In many cases the provider has built-in\n * safeguards against abuse, which automatically fail requests if they are\n * coming in too fast. Some systems don't have safeguards and precipitously\n * degrade their service level or fail outright when faced with excessive load.\n *\n * With faast.js it becomes very easy to (accidentally) generate requests from\n * thousands of cloud functions. The `throttle` function can help manage request\n * flow without resorting to setting up a separate service. This is in keeping\n * with faast.js' zero-ops philosophy.\n *\n * Usage is simple:\n *\n * ```typescript\n * async function operation() { ... }\n * const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);\n * for(let i = 0; i < 100; i++) {\n *     // at most 10 concurrent executions at a rate of 5 invocations per second.\n *     throttledOperation();\n * }\n * ```\n *\n * Note that each invocation to `throttle` creates a separate function with a\n * separate limits. Therefore it is likely that you want to use `throttle` in a\n * global context, not within a dynamic context:\n *\n * ```typescript\n * async function operation() { ... }\n * for(let i = 0; i < 100; i++) {\n *     // WRONG - each iteration creates a separate throttled function that's only called once.\n *     const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);\n *     throttledOperation();\n * }\n * ```\n *\n * A better way to use throttle avoids creating a named `operation` function\n * altogether, ensuring it cannot be accidentally called without throttling:\n *\n * ```typescript\n * const operation = throttle({ concurrency: 10, rate: 5 }, async () => {\n *     ...\n * });\n * ```\n *\n * Throttle supports functions with arguments automatically infers the correct\n * type for the returned function:\n *\n * ```typescript\n * // `operation` inferred to have type (str: string) => Promise<string>\n * const operation = throttle({ concurrency: 10, rate: 5 }, async (str: string) => {\n *     return string;\n * });\n * ```\n *\n * In addition to limiting concurrency and invocation rate, `throttle` also\n * supports retrying failed invocations, memoizing calls, and on-disk caching.\n * See {@link Limits} for details.\n *\n * @param limits - see {@link Limits}.\n * @param fn - The function to throttle. It can take any arguments, but must\n * return a Promise (which includes `async` functions).\n * @returns Returns a throttled function with the same signature as the argument\n * `fn`.\n * @public\n */\nexport function throttle<A extends any[], R>(\n    limits: Limits,\n    fn: (...args: A) => Promise<R>\n): (...args: A) => Promise<R> {\n    const { concurrency, retry, rate, burst, memoize, cache, cancel } = limits;\n    const funnel = new Funnel<R>(concurrency, retry);\n    const cancellationQueue = [() => funnel.clear()];\n\n    let conditionedFunc: (...args: A) => Promise<R>;\n\n    if (rate) {\n        const rateLimiter = new RateLimiter<R>(rate, burst);\n        cancellationQueue.push(() => rateLimiter.clear());\n        conditionedFunc = (...args: A) =>\n            funnel.push(() => rateLimiter.push(() => fn(...args)));\n    } else {\n        conditionedFunc = (...args: A) => funnel.push(() => fn(...args));\n    }\n\n    if (cache) {\n        conditionedFunc = cacheFn(cache, conditionedFunc);\n    }\n    if (memoize) {\n        const mcache = new Map<string, Promise<R>>();\n        cancellationQueue.push(() => mcache.clear());\n        conditionedFunc = memoizeFn(conditionedFunc, mcache);\n    }\n    cancel?.then(() => cancellationQueue.forEach(cleanupFn => cleanupFn()));\n    return conditionedFunc;\n}\n\nfunction iteratorResult<T>(value: T | Promise<T>) {\n    return Promise.resolve(value).then(v => ({ done: false, value: v } as const));\n}\n\nconst done = Promise.resolve({ done: true, value: undefined } as const);\n\nexport class AsyncQueue<T> {\n    protected deferred: Array<Deferred<T>> = [];\n    protected enqueued: Promise<T>[] = [];\n\n    enqueue(value: T | Promise<T>) {\n        if (this.deferred.length > 0) {\n            const d = this.deferred.shift();\n            d!.resolve(value);\n        } else {\n            this.enqueued.push(Promise.resolve(value));\n        }\n    }\n\n    next(): Promise<T> {\n        if (this.enqueued.length > 0) {\n            return this.enqueued.shift()!;\n        }\n        const d = new Deferred<T>();\n        this.deferred.push(d);\n        return d.promise;\n    }\n\n    clear() {\n        this.deferred = [];\n        this.enqueued = [];\n    }\n}\n\nexport class AsyncIterableQueue<T> extends AsyncQueue<IteratorResult<T>> {\n    push(value: T | Promise<T>) {\n        super.enqueue(iteratorResult(value));\n    }\n\n    done() {\n        super.enqueue(done);\n    }\n\n    [Symbol.asyncIterator]() {\n        return this;\n    }\n}\n\nexport class AsyncOrderedQueue<T> {\n    protected queue = new AsyncQueue<T>();\n    protected arrived: Map<number, Promise<T>> = new Map();\n    protected current = 0;\n\n    push(value: T | Promise<T>, sequence: number) {\n        this.enqueue(Promise.resolve(value), sequence);\n    }\n\n    pushImmediate(value: T | Promise<T>) {\n        this.queue.enqueue(value);\n    }\n\n    enqueue(value: Promise<T>, sequence: number) {\n        if (sequence < this.current) {\n            return;\n        }\n        if (!this.arrived.has(sequence)) {\n            this.arrived.set(sequence, value);\n        }\n        while (this.arrived.has(this.current)) {\n            this.queue.enqueue(this.arrived.get(this.current)!);\n            this.arrived.delete(this.current);\n            this.current++;\n        }\n    }\n\n    next(): Promise<T> {\n        return this.queue.next();\n    }\n\n    clear() {\n        this.arrived.clear();\n        this.queue.clear();\n        this.current = 0;\n    }\n}\n"]}