@vscode/chat-lib 0.0.1

package/dist/src/_internal/util/vs/base/common/async.js

@@ -0,0 +1,2037 @@
+"use strict";
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncReader = exports.AsyncReaderEndOfStream = exports.CancelableAsyncIterableProducer = exports.AsyncIterableProducer = exports.AsyncIterableSource = exports.AsyncIterableObject = exports.LazyStatefulPromise = exports.StatefulPromise = exports.Promises = exports.DeferredPromise = exports.IntervalCounter = exports.TaskSequentializer = exports.GlobalIdleValue = exports.AbstractIdleValue = exports._runWhenIdle = exports.runWhenGlobalIdle = exports.ThrottledWorker = exports.RunOnceWorker = exports.ProcessTimeRunOnceScheduler = exports.RunOnceScheduler = exports.IntervalTimer = exports.TimeoutTimer = exports.TaskQueue = exports.ResourceQueue = exports.LimitedQueue = exports.Queue = exports.Limiter = exports.AutoOpenBarrier = exports.Barrier = exports.ThrottledDelayer = exports.Delayer = exports.SequencerByKey = exports.Sequencer = exports.Throttler = void 0;
+exports.isThenable = isThenable;
+exports.createCancelablePromise = createCancelablePromise;
+exports.raceCancellation = raceCancellation;
+exports.raceCancellationError = raceCancellationError;
+exports.notCancellablePromise = notCancellablePromise;
+exports.raceCancellablePromises = raceCancellablePromises;
+exports.raceTimeout = raceTimeout;
+exports.asPromise = asPromise;
+exports.promiseWithResolvers = promiseWithResolvers;
+exports.timeout = timeout;
+exports.disposableTimeout = disposableTimeout;
+exports.sequence = sequence;
+exports.first = first;
+exports.firstParallel = firstParallel;
+exports.retry = retry;
+exports.createCancelableAsyncIterableProducer = createCancelableAsyncIterableProducer;
+exports.cancellableIterable = cancellableIterable;
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const cancellation_1 = require("./cancellation");
+const errors_1 = require("./errors");
+const event_1 = require("./event");
+const lifecycle_1 = require("./lifecycle");
+const resources_1 = require("./resources");
+const platform_1 = require("./platform");
+const symbols_1 = require("./symbols");
+const lazy_1 = require("./lazy");
+function isThenable(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
+/**
+ * Returns a promise that can be cancelled using the provided cancellation token.
+ *
+ * @remarks When cancellation is requested, the promise will be rejected with a {@link CancellationError}.
+ * If the promise resolves to a disposable object, it will be automatically disposed when cancellation
+ * is requested.
+ *
+ * @param callback A function that accepts a cancellation token and returns a promise
+ * @returns A promise that can be cancelled
+ */
+function createCancelablePromise(callback) {
+    const source = new cancellation_1.CancellationTokenSource();
+    const thenable = callback(source.token);
+    let isCancelled = false;
+    const promise = new Promise((resolve, reject) => {
+        const subscription = source.token.onCancellationRequested(() => {
+            isCancelled = true;
+            subscription.dispose();
+            reject(new errors_1.CancellationError());
+        });
+        Promise.resolve(thenable).then(value => {
+            subscription.dispose();
+            source.dispose();
+            if (!isCancelled) {
+                resolve(value);
+            }
+            else if ((0, lifecycle_1.isDisposable)(value)) {
+                // promise has been cancelled, result is disposable and will
+                // be cleaned up
+                value.dispose();
+            }
+        }, err => {
+            subscription.dispose();
+            source.dispose();
+            reject(err);
+        });
+    });
+    return new class {
+        cancel() {
+            source.cancel();
+            source.dispose();
+        }
+        then(resolve, reject) {
+            return promise.then(resolve, reject);
+        }
+        catch(reject) {
+            return this.then(undefined, reject);
+        }
+        finally(onfinally) {
+            return promise.finally(onfinally);
+        }
+    };
+}
+function raceCancellation(promise, token, defaultValue) {
+    return new Promise((resolve, reject) => {
+        const ref = token.onCancellationRequested(() => {
+            ref.dispose();
+            resolve(defaultValue);
+        });
+        promise.then(resolve, reject).finally(() => ref.dispose());
+    });
+}
+/**
+ * Returns a promise that rejects with an {@CancellationError} as soon as the passed token is cancelled.
+ * @see {@link raceCancellation}
+ */
+function raceCancellationError(promise, token) {
+    return new Promise((resolve, reject) => {
+        const ref = token.onCancellationRequested(() => {
+            ref.dispose();
+            reject(new errors_1.CancellationError());
+        });
+        promise.then(resolve, reject).finally(() => ref.dispose());
+    });
+}
+/**
+ * Wraps a cancellable promise such that it is no cancellable. Can be used to
+ * avoid issues with shared promises that would normally be returned as
+ * cancellable to consumers.
+ */
+function notCancellablePromise(promise) {
+    return new Promise((resolve, reject) => {
+        promise.then(resolve, reject);
+    });
+}
+/**
+ * Returns as soon as one of the promises resolves or rejects and cancels remaining promises
+ */
+function raceCancellablePromises(cancellablePromises) {
+    let resolvedPromiseIndex = -1;
+    const promises = cancellablePromises.map((promise, index) => promise.then(result => { resolvedPromiseIndex = index; return result; }));
+    const promise = Promise.race(promises);
+    promise.cancel = () => {
+        cancellablePromises.forEach((cancellablePromise, index) => {
+            if (index !== resolvedPromiseIndex && cancellablePromise.cancel) {
+                cancellablePromise.cancel();
+            }
+        });
+    };
+    promise.finally(() => {
+        promise.cancel();
+    });
+    return promise;
+}
+function raceTimeout(promise, timeout, onTimeout) {
+    let promiseResolve = undefined;
+    const timer = setTimeout(() => {
+        promiseResolve?.(undefined);
+        onTimeout?.();
+    }, timeout);
+    return Promise.race([
+        promise.finally(() => clearTimeout(timer)),
+        new Promise(resolve => promiseResolve = resolve)
+    ]);
+}
+function asPromise(callback) {
+    return new Promise((resolve, reject) => {
+        const item = callback();
+        if (isThenable(item)) {
+            item.then(resolve, reject);
+        }
+        else {
+            resolve(item);
+        }
+    });
+}
+/**
+ * Creates and returns a new promise, plus its `resolve` and `reject` callbacks.
+ *
+ * Replace with standardized [`Promise.withResolvers`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) once it is supported
+ */
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve: resolve, reject: reject };
+}
+/**
+ * A helper to prevent accumulation of sequential async tasks.
+ *
+ * Imagine a mail man with the sole task of delivering letters. As soon as
+ * a letter submitted for delivery, he drives to the destination, delivers it
+ * and returns to his base. Imagine that during the trip, N more letters were submitted.
+ * When the mail man returns, he picks those N letters and delivers them all in a
+ * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
+ *
+ * The throttler implements this via the queue() method, by providing it a task
+ * factory. Following the example:
+ *
+ * 		const throttler = new Throttler();
+ * 		const letters = [];
+ *
+ * 		function deliver() {
+ * 			const lettersToDeliver = letters;
+ * 			letters = [];
+ * 			return makeTheTrip(lettersToDeliver);
+ * 		}
+ *
+ * 		function onLetterReceived(l) {
+ * 			letters.push(l);
+ * 			throttler.queue(deliver);
+ * 		}
+ */
+class Throttler {
+    constructor() {
+        this.isDisposed = false;
+        this.activePromise = null;
+        this.queuedPromise = null;
+        this.queuedPromiseFactory = null;
+    }
+    queue(promiseFactory) {
+        if (this.isDisposed) {
+            return Promise.reject(new Error('Throttler is disposed'));
+        }
+        if (this.activePromise) {
+            this.queuedPromiseFactory = promiseFactory;
+            if (!this.queuedPromise) {
+                const onComplete = () => {
+                    this.queuedPromise = null;
+                    if (this.isDisposed) {
+                        return;
+                    }
+                    const result = this.queue(this.queuedPromiseFactory);
+                    this.queuedPromiseFactory = null;
+                    return result;
+                };
+                this.queuedPromise = new Promise(resolve => {
+                    this.activePromise.then(onComplete, onComplete).then(resolve);
+                });
+            }
+            return new Promise((resolve, reject) => {
+                this.queuedPromise.then(resolve, reject);
+            });
+        }
+        this.activePromise = promiseFactory();
+        return new Promise((resolve, reject) => {
+            this.activePromise.then((result) => {
+                this.activePromise = null;
+                resolve(result);
+            }, (err) => {
+                this.activePromise = null;
+                reject(err);
+            });
+        });
+    }
+    dispose() {
+        this.isDisposed = true;
+    }
+}
+exports.Throttler = Throttler;
+class Sequencer {
+    constructor() {
+        this.current = Promise.resolve(null);
+    }
+    queue(promiseTask) {
+        return this.current = this.current.then(() => promiseTask(), () => promiseTask());
+    }
+}
+exports.Sequencer = Sequencer;
+class SequencerByKey {
+    constructor() {
+        this.promiseMap = new Map();
+    }
+    queue(key, promiseTask) {
+        const runningPromise = this.promiseMap.get(key) ?? Promise.resolve();
+        const newPromise = runningPromise
+            .catch(() => { })
+            .then(promiseTask)
+            .finally(() => {
+            if (this.promiseMap.get(key) === newPromise) {
+                this.promiseMap.delete(key);
+            }
+        });
+        this.promiseMap.set(key, newPromise);
+        return newPromise;
+    }
+    keys() {
+        return this.promiseMap.keys();
+    }
+}
+exports.SequencerByKey = SequencerByKey;
+const timeoutDeferred = (timeout, fn) => {
+    let scheduled = true;
+    const handle = setTimeout(() => {
+        scheduled = false;
+        fn();
+    }, timeout);
+    return {
+        isTriggered: () => scheduled,
+        dispose: () => {
+            clearTimeout(handle);
+            scheduled = false;
+        },
+    };
+};
+const microtaskDeferred = (fn) => {
+    let scheduled = true;
+    queueMicrotask(() => {
+        if (scheduled) {
+            scheduled = false;
+            fn();
+        }
+    });
+    return {
+        isTriggered: () => scheduled,
+        dispose: () => { scheduled = false; },
+    };
+};
+/**
+ * A helper to delay (debounce) execution of a task that is being requested often.
+ *
+ * Following the throttler, now imagine the mail man wants to optimize the number of
+ * trips proactively. The trip itself can be long, so he decides not to make the trip
+ * as soon as a letter is submitted. Instead he waits a while, in case more
+ * letters are submitted. After said waiting period, if no letters were submitted, he
+ * decides to make the trip. Imagine that N more letters were submitted after the first
+ * one, all within a short period of time between each other. Even though N+1
+ * submissions occurred, only 1 delivery was made.
+ *
+ * The delayer offers this behavior via the trigger() method, into which both the task
+ * to be executed and the waiting period (delay) must be passed in as arguments. Following
+ * the example:
+ *
+ * 		const delayer = new Delayer(WAITING_PERIOD);
+ * 		const letters = [];
+ *
+ * 		function letterReceived(l) {
+ * 			letters.push(l);
+ * 			delayer.trigger(() => { return makeTheTrip(); });
+ * 		}
+ */
+class Delayer {
+    constructor(defaultDelay) {
+        this.defaultDelay = defaultDelay;
+        this.deferred = null;
+        this.completionPromise = null;
+        this.doResolve = null;
+        this.doReject = null;
+        this.task = null;
+    }
+    trigger(task, delay = this.defaultDelay) {
+        this.task = task;
+        this.cancelTimeout();
+        if (!this.completionPromise) {
+            this.completionPromise = new Promise((resolve, reject) => {
+                this.doResolve = resolve;
+                this.doReject = reject;
+            }).then(() => {
+                this.completionPromise = null;
+                this.doResolve = null;
+                if (this.task) {
+                    const task = this.task;
+                    this.task = null;
+                    return task();
+                }
+                return undefined;
+            });
+        }
+        const fn = () => {
+            this.deferred = null;
+            this.doResolve?.(null);
+        };
+        this.deferred = delay === symbols_1.MicrotaskDelay ? microtaskDeferred(fn) : timeoutDeferred(delay, fn);
+        return this.completionPromise;
+    }
+    isTriggered() {
+        return !!this.deferred?.isTriggered();
+    }
+    cancel() {
+        this.cancelTimeout();
+        if (this.completionPromise) {
+            this.doReject?.(new errors_1.CancellationError());
+            this.completionPromise = null;
+        }
+    }
+    cancelTimeout() {
+        this.deferred?.dispose();
+        this.deferred = null;
+    }
+    dispose() {
+        this.cancel();
+    }
+}
+exports.Delayer = Delayer;
+/**
+ * A helper to delay execution of a task that is being requested often, while
+ * preventing accumulation of consecutive executions, while the task runs.
+ *
+ * The mail man is clever and waits for a certain amount of time, before going
+ * out to deliver letters. While the mail man is going out, more letters arrive
+ * and can only be delivered once he is back. Once he is back the mail man will
+ * do one more trip to deliver the letters that have accumulated while he was out.
+ */
+class ThrottledDelayer {
+    constructor(defaultDelay) {
+        this.delayer = new Delayer(defaultDelay);
+        this.throttler = new Throttler();
+    }
+    trigger(promiseFactory, delay) {
+        return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay);
+    }
+    isTriggered() {
+        return this.delayer.isTriggered();
+    }
+    cancel() {
+        this.delayer.cancel();
+    }
+    dispose() {
+        this.delayer.dispose();
+        this.throttler.dispose();
+    }
+}
+exports.ThrottledDelayer = ThrottledDelayer;
+/**
+ * A barrier that is initially closed and then becomes opened permanently.
+ */
+class Barrier {
+    constructor() {
+        this._isOpen = false;
+        this._promise = new Promise((c, e) => {
+            this._completePromise = c;
+        });
+    }
+    isOpen() {
+        return this._isOpen;
+    }
+    open() {
+        this._isOpen = true;
+        this._completePromise(true);
+    }
+    wait() {
+        return this._promise;
+    }
+}
+exports.Barrier = Barrier;
+/**
+ * A barrier that is initially closed and then becomes opened permanently after a certain period of
+ * time or when open is called explicitly
+ */
+class AutoOpenBarrier extends Barrier {
+    constructor(autoOpenTimeMs) {
+        super();
+        this._timeout = setTimeout(() => this.open(), autoOpenTimeMs);
+    }
+    open() {
+        clearTimeout(this._timeout);
+        super.open();
+    }
+}
+exports.AutoOpenBarrier = AutoOpenBarrier;
+function timeout(millis, token) {
+    if (!token) {
+        return createCancelablePromise(token => timeout(millis, token));
+    }
+    return new Promise((resolve, reject) => {
+        const handle = setTimeout(() => {
+            disposable.dispose();
+            resolve();
+        }, millis);
+        const disposable = token.onCancellationRequested(() => {
+            clearTimeout(handle);
+            disposable.dispose();
+            reject(new errors_1.CancellationError());
+        });
+    });
+}
+/**
+ * Creates a timeout that can be disposed using its returned value.
+ * @param handler The timeout handler.
+ * @param timeout An optional timeout in milliseconds.
+ * @param store An optional {@link DisposableStore} that will have the timeout disposable managed automatically.
+ *
+ * @example
+ * const store = new DisposableStore;
+ * // Call the timeout after 1000ms at which point it will be automatically
+ * // evicted from the store.
+ * const timeoutDisposable = disposableTimeout(() => {}, 1000, store);
+ *
+ * if (foo) {
+ *   // Cancel the timeout and evict it from store.
+ *   timeoutDisposable.dispose();
+ * }
+ */
+function disposableTimeout(handler, timeout = 0, store) {
+    const timer = setTimeout(() => {
+        handler();
+        if (store) {
+            disposable.dispose();
+        }
+    }, timeout);
+    const disposable = (0, lifecycle_1.toDisposable)(() => {
+        clearTimeout(timer);
+        store?.delete(disposable);
+    });
+    store?.add(disposable);
+    return disposable;
+}
+/**
+ * Runs the provided list of promise factories in sequential order. The returned
+ * promise will complete to an array of results from each promise.
+ */
+function sequence(promiseFactories) {
+    const results = [];
+    let index = 0;
+    const len = promiseFactories.length;
+    function next() {
+        return index < len ? promiseFactories[index++]() : null;
+    }
+    function thenHandler(result) {
+        if (result !== undefined && result !== null) {
+            results.push(result);
+        }
+        const n = next();
+        if (n) {
+            return n.then(thenHandler);
+        }
+        return Promise.resolve(results);
+    }
+    return Promise.resolve(null).then(thenHandler);
+}
+function first(promiseFactories, shouldStop = t => !!t, defaultValue = null) {
+    let index = 0;
+    const len = promiseFactories.length;
+    const loop = () => {
+        if (index >= len) {
+            return Promise.resolve(defaultValue);
+        }
+        const factory = promiseFactories[index++];
+        const promise = Promise.resolve(factory());
+        return promise.then(result => {
+            if (shouldStop(result)) {
+                return Promise.resolve(result);
+            }
+            return loop();
+        });
+    };
+    return loop();
+}
+function firstParallel(promiseList, shouldStop = t => !!t, defaultValue = null) {
+    if (promiseList.length === 0) {
+        return Promise.resolve(defaultValue);
+    }
+    let todo = promiseList.length;
+    const finish = () => {
+        todo = -1;
+        for (const promise of promiseList) {
+            promise.cancel?.();
+        }
+    };
+    return new Promise((resolve, reject) => {
+        for (const promise of promiseList) {
+            promise.then(result => {
+                if (--todo >= 0 && shouldStop(result)) {
+                    finish();
+                    resolve(result);
+                }
+                else if (todo === 0) {
+                    resolve(defaultValue);
+                }
+            })
+                .catch(err => {
+                if (--todo >= 0) {
+                    finish();
+                    reject(err);
+                }
+            });
+        }
+    });
+}
+/**
+ * A helper to queue N promises and run them all with a max degree of parallelism. The helper
+ * ensures that at any time no more than M promises are running at the same time.
+ */
+class Limiter {
+    constructor(maxDegreeOfParalellism) {
+        this._size = 0;
+        this._isDisposed = false;
+        this.maxDegreeOfParalellism = maxDegreeOfParalellism;
+        this.outstandingPromises = [];
+        this.runningPromises = 0;
+        this._onDrained = new event_1.Emitter();
+    }
+    /**
+     *
+     * @returns A promise that resolved when all work is done (onDrained) or when
+     * there is nothing to do
+     */
+    whenIdle() {
+        return this.size > 0
+            ? event_1.Event.toPromise(this.onDrained)
+            : Promise.resolve();
+    }
+    get onDrained() {
+        return this._onDrained.event;
+    }
+    get size() {
+        return this._size;
+    }
+    queue(factory) {
+        if (this._isDisposed) {
+            throw new Error('Object has been disposed');
+        }
+        this._size++;
+        return new Promise((c, e) => {
+            this.outstandingPromises.push({ factory, c, e });
+            this.consume();
+        });
+    }
+    consume() {
+        while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
+            const iLimitedTask = this.outstandingPromises.shift();
+            this.runningPromises++;
+            const promise = iLimitedTask.factory();
+            promise.then(iLimitedTask.c, iLimitedTask.e);
+            promise.then(() => this.consumed(), () => this.consumed());
+        }
+    }
+    consumed() {
+        if (this._isDisposed) {
+            return;
+        }
+        this.runningPromises--;
+        if (--this._size === 0) {
+            this._onDrained.fire();
+        }
+        if (this.outstandingPromises.length > 0) {
+            this.consume();
+        }
+    }
+    clear() {
+        if (this._isDisposed) {
+            throw new Error('Object has been disposed');
+        }
+        this.outstandingPromises.length = 0;
+        this._size = this.runningPromises;
+    }
+    dispose() {
+        this._isDisposed = true;
+        this.outstandingPromises.length = 0; // stop further processing
+        this._size = 0;
+        this._onDrained.dispose();
+    }
+}
+exports.Limiter = Limiter;
+/**
+ * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
+ */
+class Queue extends Limiter {
+    constructor() {
+        super(1);
+    }
+}
+exports.Queue = Queue;
+/**
+ * Same as `Queue`, ensures that only 1 task is executed at the same time. The difference to `Queue` is that
+ * there is only 1 task about to be scheduled next. As such, calling `queue` while a task is executing will
+ * replace the currently queued task until it executes.
+ *
+ * As such, the returned promise may not be from the factory that is passed in but from the next factory that
+ * is running after having called `queue`.
+ */
+class LimitedQueue {
+    constructor() {
+        this.sequentializer = new TaskSequentializer();
+        this.tasks = 0;
+    }
+    queue(factory) {
+        if (!this.sequentializer.isRunning()) {
+            return this.sequentializer.run(this.tasks++, factory());
+        }
+        return this.sequentializer.queue(() => {
+            return this.sequentializer.run(this.tasks++, factory());
+        });
+    }
+}
+exports.LimitedQueue = LimitedQueue;
+/**
+ * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource
+ * by disposing them once the queue is empty.
+ */
+class ResourceQueue {
+    constructor() {
+        this.queues = new Map();
+        this.drainers = new Set();
+        this.drainListeners = undefined;
+        this.drainListenerCount = 0;
+    }
+    async whenDrained() {
+        if (this.isDrained()) {
+            return;
+        }
+        const promise = new DeferredPromise();
+        this.drainers.add(promise);
+        return promise.p;
+    }
+    isDrained() {
+        for (const [, queue] of this.queues) {
+            if (queue.size > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    queueSize(resource, extUri = resources_1.extUri) {
+        const key = extUri.getComparisonKey(resource);
+        return this.queues.get(key)?.size ?? 0;
+    }
+    queueFor(resource, factory, extUri = resources_1.extUri) {
+        const key = extUri.getComparisonKey(resource);
+        let queue = this.queues.get(key);
+        if (!queue) {
+            queue = new Queue();
+            const drainListenerId = this.drainListenerCount++;
+            const drainListener = event_1.Event.once(queue.onDrained)(() => {
+                queue?.dispose();
+                this.queues.delete(key);
+                this.onDidQueueDrain();
+                this.drainListeners?.deleteAndDispose(drainListenerId);
+                if (this.drainListeners?.size === 0) {
+                    this.drainListeners.dispose();
+                    this.drainListeners = undefined;
+                }
+            });
+            if (!this.drainListeners) {
+                this.drainListeners = new lifecycle_1.DisposableMap();
+            }
+            this.drainListeners.set(drainListenerId, drainListener);
+            this.queues.set(key, queue);
+        }
+        return queue.queue(factory);
+    }
+    onDidQueueDrain() {
+        if (!this.isDrained()) {
+            return; // not done yet
+        }
+        this.releaseDrainers();
+    }
+    releaseDrainers() {
+        for (const drainer of this.drainers) {
+            drainer.complete();
+        }
+        this.drainers.clear();
+    }
+    dispose() {
+        for (const [, queue] of this.queues) {
+            queue.dispose();
+        }
+        this.queues.clear();
+        // Even though we might still have pending
+        // tasks queued, after the queues have been
+        // disposed, we can no longer track them, so
+        // we release drainers to prevent hanging
+        // promises when the resource queue is being
+        // disposed.
+        this.releaseDrainers();
+        this.drainListeners?.dispose();
+    }
+}
+exports.ResourceQueue = ResourceQueue;
+/**
+ * Processes tasks in the order they were scheduled.
+*/
+class TaskQueue {
+    constructor() {
+        this._runningTask = undefined;
+        this._pendingTasks = [];
+    }
+    /**
+     * Waits for the current and pending tasks to finish, then runs and awaits the given task.
+     * If the task is skipped because of clearPending, the promise is rejected with a CancellationError.
+    */
+    schedule(task) {
+        const deferred = new DeferredPromise();
+        this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: false });
+        this._runIfNotRunning();
+        return deferred.p;
+    }
+    /**
+     * Waits for the current and pending tasks to finish, then runs and awaits the given task.
+     * If the task is skipped because of clearPending, the promise is resolved with undefined.
+    */
+    scheduleSkipIfCleared(task) {
+        const deferred = new DeferredPromise();
+        this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: true });
+        this._runIfNotRunning();
+        return deferred.p;
+    }
+    _runIfNotRunning() {
+        if (this._runningTask === undefined) {
+            this._processQueue();
+        }
+    }
+    async _processQueue() {
+        if (this._pendingTasks.length === 0) {
+            return;
+        }
+        const next = this._pendingTasks.shift();
+        if (!next) {
+            return;
+        }
+        if (this._runningTask) {
+            throw new errors_1.BugIndicatingError();
+        }
+        this._runningTask = next.task;
+        try {
+            const result = await next.task();
+            next.deferred.complete(result);
+        }
+        catch (e) {
+            next.deferred.error(e);
+        }
+        finally {
+            this._runningTask = undefined;
+            this._processQueue();
+        }
+    }
+    /**
+     * Clears all pending tasks. Does not cancel the currently running task.
+    */
+    clearPending() {
+        const tasks = this._pendingTasks;
+        this._pendingTasks = [];
+        for (const task of tasks) {
+            if (task.setUndefinedWhenCleared) {
+                task.deferred.complete(undefined);
+            }
+            else {
+                task.deferred.error(new errors_1.CancellationError());
+            }
+        }
+    }
+}
+exports.TaskQueue = TaskQueue;
+class TimeoutTimer {
+    constructor(runner, timeout) {
+        this._isDisposed = false;
+        this._token = undefined;
+        if (typeof runner === 'function' && typeof timeout === 'number') {
+            this.setIfNotSet(runner, timeout);
+        }
+    }
+    dispose() {
+        this.cancel();
+        this._isDisposed = true;
+    }
+    cancel() {
+        if (this._token !== undefined) {
+            clearTimeout(this._token);
+            this._token = undefined;
+        }
+    }
+    cancelAndSet(runner, timeout) {
+        if (this._isDisposed) {
+            throw new errors_1.BugIndicatingError(`Calling 'cancelAndSet' on a disposed TimeoutTimer`);
+        }
+        this.cancel();
+        this._token = setTimeout(() => {
+            this._token = undefined;
+            runner();
+        }, timeout);
+    }
+    setIfNotSet(runner, timeout) {
+        if (this._isDisposed) {
+            throw new errors_1.BugIndicatingError(`Calling 'setIfNotSet' on a disposed TimeoutTimer`);
+        }
+        if (this._token !== undefined) {
+            // timer is already set
+            return;
+        }
+        this._token = setTimeout(() => {
+            this._token = undefined;
+            runner();
+        }, timeout);
+    }
+}
+exports.TimeoutTimer = TimeoutTimer;
+class IntervalTimer {
+    constructor() {
+        this.disposable = undefined;
+        this.isDisposed = false;
+    }
+    cancel() {
+        this.disposable?.dispose();
+        this.disposable = undefined;
+    }
+    cancelAndSet(runner, interval, context = globalThis) {
+        if (this.isDisposed) {
+            throw new errors_1.BugIndicatingError(`Calling 'cancelAndSet' on a disposed IntervalTimer`);
+        }
+        this.cancel();
+        const handle = context.setInterval(() => {
+            runner();
+        }, interval);
+        this.disposable = (0, lifecycle_1.toDisposable)(() => {
+            context.clearInterval(handle);
+            this.disposable = undefined;
+        });
+    }
+    dispose() {
+        this.cancel();
+        this.isDisposed = true;
+    }
+}
+exports.IntervalTimer = IntervalTimer;
+class RunOnceScheduler {
+    constructor(runner, delay) {
+        this.timeoutToken = undefined;
+        this.runner = runner;
+        this.timeout = delay;
+        this.timeoutHandler = this.onTimeout.bind(this);
+    }
+    /**
+     * Dispose RunOnceScheduler
+     */
+    dispose() {
+        this.cancel();
+        this.runner = null;
+    }
+    /**
+     * Cancel current scheduled runner (if any).
+     */
+    cancel() {
+        if (this.isScheduled()) {
+            clearTimeout(this.timeoutToken);
+            this.timeoutToken = undefined;
+        }
+    }
+    /**
+     * Cancel previous runner (if any) & schedule a new runner.
+     */
+    schedule(delay = this.timeout) {
+        this.cancel();
+        this.timeoutToken = setTimeout(this.timeoutHandler, delay);
+    }
+    get delay() {
+        return this.timeout;
+    }
+    set delay(value) {
+        this.timeout = value;
+    }
+    /**
+     * Returns true if scheduled.
+     */
+    isScheduled() {
+        return this.timeoutToken !== undefined;
+    }
+    flush() {
+        if (this.isScheduled()) {
+            this.cancel();
+            this.doRun();
+        }
+    }
+    onTimeout() {
+        this.timeoutToken = undefined;
+        if (this.runner) {
+            this.doRun();
+        }
+    }
+    doRun() {
+        this.runner?.();
+    }
+}
+exports.RunOnceScheduler = RunOnceScheduler;
+/**
+ * Same as `RunOnceScheduler`, but doesn't count the time spent in sleep mode.
+ * > **NOTE**: Only offers 1s resolution.
+ *
+ * When calling `setTimeout` with 3hrs, and putting the computer immediately to sleep
+ * for 8hrs, `setTimeout` will fire **as soon as the computer wakes from sleep**. But
+ * this scheduler will execute 3hrs **after waking the computer from sleep**.
+ */
+class ProcessTimeRunOnceScheduler {
+    constructor(runner, delay) {
+        if (delay % 1000 !== 0) {
+            console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);
+        }
+        this.runner = runner;
+        this.timeout = delay;
+        this.counter = 0;
+        this.intervalToken = undefined;
+        this.intervalHandler = this.onInterval.bind(this);
+    }
+    dispose() {
+        this.cancel();
+        this.runner = null;
+    }
+    cancel() {
+        if (this.isScheduled()) {
+            clearInterval(this.intervalToken);
+            this.intervalToken = undefined;
+        }
+    }
+    /**
+     * Cancel previous runner (if any) & schedule a new runner.
+     */
+    schedule(delay = this.timeout) {
+        if (delay % 1000 !== 0) {
+            console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);
+        }
+        this.cancel();
+        this.counter = Math.ceil(delay / 1000);
+        this.intervalToken = setInterval(this.intervalHandler, 1000);
+    }
+    /**
+     * Returns true if scheduled.
+     */
+    isScheduled() {
+        return this.intervalToken !== undefined;
+    }
+    onInterval() {
+        this.counter--;
+        if (this.counter > 0) {
+            // still need to wait
+            return;
+        }
+        // time elapsed
+        clearInterval(this.intervalToken);
+        this.intervalToken = undefined;
+        this.runner?.();
+    }
+}
+exports.ProcessTimeRunOnceScheduler = ProcessTimeRunOnceScheduler;
+class RunOnceWorker extends RunOnceScheduler {
+    constructor(runner, timeout) {
+        super(runner, timeout);
+        this.units = [];
+    }
+    work(unit) {
+        this.units.push(unit);
+        if (!this.isScheduled()) {
+            this.schedule();
+        }
+    }
+    doRun() {
+        const units = this.units;
+        this.units = [];
+        this.runner?.(units);
+    }
+    dispose() {
+        this.units = [];
+        super.dispose();
+    }
+}
+exports.RunOnceWorker = RunOnceWorker;
+/**
+ * The `ThrottledWorker` will accept units of work `T`
+ * to handle. The contract is:
+ * * there is a maximum of units the worker can handle at once (via `maxWorkChunkSize`)
+ * * there is a maximum of units the worker will keep in memory for processing (via `maxBufferedWork`)
+ * * after having handled `maxWorkChunkSize` units, the worker needs to rest (via `throttleDelay`)
+ */
+class ThrottledWorker extends lifecycle_1.Disposable {
+    constructor(options, handler) {
+        super();
+        this.options = options;
+        this.handler = handler;
+        this.pendingWork = [];
+        this.throttler = this._register(new lifecycle_1.MutableDisposable());
+        this.disposed = false;
+        this.lastExecutionTime = 0;
+    }
+    /**
+     * The number of work units that are pending to be processed.
+     */
+    get pending() { return this.pendingWork.length; }
+    /**
+     * Add units to be worked on. Use `pending` to figure out
+     * how many units are not yet processed after this method
+     * was called.
+     *
+     * @returns whether the work was accepted or not. If the
+     * worker is disposed, it will not accept any more work.
+     * If the number of pending units would become larger
+     * than `maxPendingWork`, more work will also not be accepted.
+     */
+    work(units) {
+        if (this.disposed) {
+            return false; // work not accepted: disposed
+        }
+        // Check for reaching maximum of pending work
+        if (typeof this.options.maxBufferedWork === 'number') {
+            // Throttled: simple check if pending + units exceeds max pending
+            if (this.throttler.value) {
+                if (this.pending + units.length > this.options.maxBufferedWork) {
+                    return false; // work not accepted: too much pending work
+                }
+            }
+            // Unthrottled: same as throttled, but account for max chunk getting
+            // worked on directly without being pending
+            else {
+                if (this.pending + units.length - this.options.maxWorkChunkSize > this.options.maxBufferedWork) {
+                    return false; // work not accepted: too much pending work
+                }
+            }
+        }
+        // Add to pending units first
+        for (const unit of units) {
+            this.pendingWork.push(unit);
+        }
+        const timeSinceLastExecution = Date.now() - this.lastExecutionTime;
+        if (!this.throttler.value && (!this.options.waitThrottleDelayBetweenWorkUnits || timeSinceLastExecution >= this.options.throttleDelay)) {
+            // Work directly if we are not throttling and we are not
+            // enforced to throttle between `work()` calls.
+            this.doWork();
+        }
+        else if (!this.throttler.value && this.options.waitThrottleDelayBetweenWorkUnits) {
+            // Otherwise, schedule the throttler to work.
+            this.scheduleThrottler(Math.max(this.options.throttleDelay - timeSinceLastExecution, 0));
+        }
+        else {
+            // Otherwise, our work will be picked up by the running throttler
+        }
+        return true; // work accepted
+    }
+    doWork() {
+        this.lastExecutionTime = Date.now();
+        // Extract chunk to handle and handle it
+        this.handler(this.pendingWork.splice(0, this.options.maxWorkChunkSize));
+        // If we have remaining work, schedule it after a delay
+        if (this.pendingWork.length > 0) {
+            this.scheduleThrottler();
+        }
+    }
+    scheduleThrottler(delay = this.options.throttleDelay) {
+        this.throttler.value = new RunOnceScheduler(() => {
+            this.throttler.clear();
+            this.doWork();
+        }, delay);
+        this.throttler.value.schedule();
+    }
+    dispose() {
+        super.dispose();
+        this.pendingWork.length = 0;
+        this.disposed = true;
+    }
+}
+exports.ThrottledWorker = ThrottledWorker;
+(function () {
+    const safeGlobal = globalThis;
+    if (typeof safeGlobal.requestIdleCallback !== 'function' || typeof safeGlobal.cancelIdleCallback !== 'function') {
+        exports._runWhenIdle = (_targetWindow, runner, timeout) => {
+            (0, platform_1.setTimeout0)(() => {
+                if (disposed) {
+                    return;
+                }
+                const end = Date.now() + 15; // one frame at 64fps
+                const deadline = {
+                    didTimeout: true,
+                    timeRemaining() {
+                        return Math.max(0, end - Date.now());
+                    }
+                };
+                runner(Object.freeze(deadline));
+            });
+            let disposed = false;
+            return {
+                dispose() {
+                    if (disposed) {
+                        return;
+                    }
+                    disposed = true;
+                }
+            };
+        };
+    }
+    else {
+        exports._runWhenIdle = (targetWindow, runner, timeout) => {
+            const handle = targetWindow.requestIdleCallback(runner, typeof timeout === 'number' ? { timeout } : undefined);
+            let disposed = false;
+            return {
+                dispose() {
+                    if (disposed) {
+                        return;
+                    }
+                    disposed = true;
+                    targetWindow.cancelIdleCallback(handle);
+                }
+            };
+        };
+    }
+    exports.runWhenGlobalIdle = (runner, timeout) => (0, exports._runWhenIdle)(globalThis, runner, timeout);
+})();
+class AbstractIdleValue {
+    constructor(targetWindow, executor) {
+        this._didRun = false;
+        this._executor = () => {
+            try {
+                this._value = executor();
+            }
+            catch (err) {
+                this._error = err;
+            }
+            finally {
+                this._didRun = true;
+            }
+        };
+        this._handle = (0, exports._runWhenIdle)(targetWindow, () => this._executor());
+    }
+    dispose() {
+        this._handle.dispose();
+    }
+    get value() {
+        if (!this._didRun) {
+            this._handle.dispose();
+            this._executor();
+        }
+        if (this._error) {
+            throw this._error;
+        }
+        return this._value;
+    }
+    get isInitialized() {
+        return this._didRun;
+    }
+}
+exports.AbstractIdleValue = AbstractIdleValue;
+/**
+ * An `IdleValue` that always uses the current window (which might be throttled or inactive)
+ *
+ * **Note** that there is `dom.ts#WindowIdleValue` which is better suited when running inside a browser
+ * context
+ */
+class GlobalIdleValue extends AbstractIdleValue {
+    constructor(executor) {
+        super(globalThis, executor);
+    }
+}
+exports.GlobalIdleValue = GlobalIdleValue;
+//#endregion
+async function retry(task, delay, retries) {
+    let lastError;
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await task();
+        }
+        catch (error) {
+            lastError = error;
+            await timeout(delay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * @deprecated use `LimitedQueue` instead for an easier to use API
+ */
+class TaskSequentializer {
+    isRunning(taskId) {
+        if (typeof taskId === 'number') {
+            return this._running?.taskId === taskId;
+        }
+        return !!this._running;
+    }
+    get running() {
+        return this._running?.promise;
+    }
+    cancelRunning() {
+        this._running?.cancel();
+    }
+    run(taskId, promise, onCancel) {
+        this._running = { taskId, cancel: () => onCancel?.(), promise };
+        promise.then(() => this.doneRunning(taskId), () => this.doneRunning(taskId));
+        return promise;
+    }
+    doneRunning(taskId) {
+        if (this._running && taskId === this._running.taskId) {
+            // only set running to done if the promise finished that is associated with that taskId
+            this._running = undefined;
+            // schedule the queued task now that we are free if we have any
+            this.runQueued();
+        }
+    }
+    runQueued() {
+        if (this._queued) {
+            const queued = this._queued;
+            this._queued = undefined;
+            // Run queued task and complete on the associated promise
+            queued.run().then(queued.promiseResolve, queued.promiseReject);
+        }
+    }
+    /**
+     * Note: the promise to schedule as next run MUST itself call `run`.
+     *       Otherwise, this sequentializer will report `false` for `isRunning`
+     *       even when this task is running. Missing this detail means that
+     *       suddenly multiple tasks will run in parallel.
+     */
+    queue(run) {
+        // this is our first queued task, so we create associated promise with it
+        // so that we can return a promise that completes when the task has
+        // completed.
+        if (!this._queued) {
+            const { promise, resolve: promiseResolve, reject: promiseReject } = promiseWithResolvers();
+            this._queued = {
+                run,
+                promise,
+                promiseResolve: promiseResolve,
+                promiseReject: promiseReject
+            };
+        }
+        // we have a previous queued task, just overwrite it
+        else {
+            this._queued.run = run;
+        }
+        return this._queued.promise;
+    }
+    hasQueued() {
+        return !!this._queued;
+    }
+    async join() {
+        return this._queued?.promise ?? this._running?.promise;
+    }
+}
+exports.TaskSequentializer = TaskSequentializer;
+//#endregion
+//#region
+/**
+ * The `IntervalCounter` allows to count the number
+ * of calls to `increment()` over a duration of
+ * `interval`. This utility can be used to conditionally
+ * throttle a frequent task when a certain threshold
+ * is reached.
+ */
+class IntervalCounter {
+    constructor(interval, nowFn = () => Date.now()) {
+        this.interval = interval;
+        this.nowFn = nowFn;
+        this.lastIncrementTime = 0;
+        this.value = 0;
+    }
+    increment() {
+        const now = this.nowFn();
+        // We are outside of the range of `interval` and as such
+        // start counting from 0 and remember the time
+        if (now - this.lastIncrementTime > this.interval) {
+            this.lastIncrementTime = now;
+            this.value = 0;
+        }
+        this.value++;
+        return this.value;
+    }
+}
+exports.IntervalCounter = IntervalCounter;
+/**
+ * Creates a promise whose resolution or rejection can be controlled imperatively.
+ */
+class DeferredPromise {
+    get isRejected() {
+        return this.outcome?.outcome === 1 /* DeferredOutcome.Rejected */;
+    }
+    get isResolved() {
+        return this.outcome?.outcome === 0 /* DeferredOutcome.Resolved */;
+    }
+    get isSettled() {
+        return !!this.outcome;
+    }
+    get value() {
+        return this.outcome?.outcome === 0 /* DeferredOutcome.Resolved */ ? this.outcome?.value : undefined;
+    }
+    constructor() {
+        this.p = new Promise((c, e) => {
+            this.completeCallback = c;
+            this.errorCallback = e;
+        });
+    }
+    complete(value) {
+        return new Promise(resolve => {
+            this.completeCallback(value);
+            this.outcome = { outcome: 0 /* DeferredOutcome.Resolved */, value };
+            resolve();
+        });
+    }
+    error(err) {
+        return new Promise(resolve => {
+            this.errorCallback(err);
+            this.outcome = { outcome: 1 /* DeferredOutcome.Rejected */, value: err };
+            resolve();
+        });
+    }
+    settleWith(promise) {
+        return promise.then(value => this.complete(value), error => this.error(error));
+    }
+    cancel() {
+        return this.error(new errors_1.CancellationError());
+    }
+}
+exports.DeferredPromise = DeferredPromise;
+//#endregion
+//#region Promises
+var Promises;
+(function (Promises) {
+    /**
+     * A drop-in replacement for `Promise.all` with the only difference
+     * that the method awaits every promise to either fulfill or reject.
+     *
+     * Similar to `Promise.all`, only the first error will be returned
+     * if any.
+     */
+    async function settled(promises) {
+        let firstError = undefined;
+        const result = await Promise.all(promises.map(promise => promise.then(value => value, error => {
+            if (!firstError) {
+                firstError = error;
+            }
+            return undefined; // do not rethrow so that other promises can settle
+        })));
+        if (typeof firstError !== 'undefined') {
+            throw firstError;
+        }
+        return result; // cast is needed and protected by the `throw` above
+    }
+    Promises.settled = settled;
+    /**
+     * A helper to create a new `Promise<T>` with a body that is a promise
+     * itself. By default, an error that raises from the async body will
+     * end up as a unhandled rejection, so this utility properly awaits the
+     * body and rejects the promise as a normal promise does without async
+     * body.
+     *
+     * This method should only be used in rare cases where otherwise `async`
+     * cannot be used (e.g. when callbacks are involved that require this).
+     */
+    function withAsyncBody(bodyFn) {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                await bodyFn(resolve, reject);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    Promises.withAsyncBody = withAsyncBody;
+})(Promises || (exports.Promises = Promises = {}));
+class StatefulPromise {
+    get value() { return this._value; }
+    get error() { return this._error; }
+    get isResolved() { return this._isResolved; }
+    constructor(promise) {
+        this._value = undefined;
+        this._error = undefined;
+        this._isResolved = false;
+        this.promise = promise.then(value => {
+            this._value = value;
+            this._isResolved = true;
+            return value;
+        }, error => {
+            this._error = error;
+            this._isResolved = true;
+            throw error;
+        });
+    }
+    /**
+     * Returns the resolved value.
+     * Throws if the promise is not resolved yet.
+     */
+    requireValue() {
+        if (!this._isResolved) {
+            throw new errors_1.BugIndicatingError('Promise is not resolved yet');
+        }
+        if (this._error) {
+            throw this._error;
+        }
+        return this._value;
+    }
+}
+exports.StatefulPromise = StatefulPromise;
+class LazyStatefulPromise {
+    constructor(_compute) {
+        this._compute = _compute;
+        this._promise = new lazy_1.Lazy(() => new StatefulPromise(this._compute()));
+    }
+    /**
+     * Returns the resolved value.
+     * Throws if the promise is not resolved yet.
+     */
+    requireValue() {
+        return this._promise.value.requireValue();
+    }
+    /**
+     * Returns the promise (and triggers a computation of the promise if not yet done so).
+     */
+    getPromise() {
+        return this._promise.value.promise;
+    }
+    /**
+     * Reads the current value without triggering a computation of the promise.
+     */
+    get currentValue() {
+        return this._promise.rawValue?.value;
+    }
+}
+exports.LazyStatefulPromise = LazyStatefulPromise;
+/**
+ * A rich implementation for an `AsyncIterable<T>`.
+ */
+class AsyncIterableObject {
+    static fromArray(items) {
+        return new AsyncIterableObject((writer) => {
+            writer.emitMany(items);
+        });
+    }
+    static fromPromise(promise) {
+        return new AsyncIterableObject(async (emitter) => {
+            emitter.emitMany(await promise);
+        });
+    }
+    static fromPromisesResolveOrder(promises) {
+        return new AsyncIterableObject(async (emitter) => {
+            await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
+        });
+    }
+    static merge(iterables) {
+        return new AsyncIterableObject(async (emitter) => {
+            await Promise.all(iterables.map(async (iterable) => {
+                for await (const item of iterable) {
+                    emitter.emitOne(item);
+                }
+            }));
+        });
+    }
+    static { this.EMPTY = AsyncIterableObject.fromArray([]); }
+    constructor(executor, onReturn) {
+        this._state = 0 /* AsyncIterableSourceState.Initial */;
+        this._results = [];
+        this._error = null;
+        this._onReturn = onReturn;
+        this._onStateChanged = new event_1.Emitter();
+        queueMicrotask(async () => {
+            const writer = {
+                emitOne: (item) => this.emitOne(item),
+                emitMany: (items) => this.emitMany(items),
+                reject: (error) => this.reject(error)
+            };
+            try {
+                await Promise.resolve(executor(writer));
+                this.resolve();
+            }
+            catch (err) {
+                this.reject(err);
+            }
+            finally {
+                writer.emitOne = undefined;
+                writer.emitMany = undefined;
+                writer.reject = undefined;
+            }
+        });
+    }
+    [Symbol.asyncIterator]() {
+        let i = 0;
+        return {
+            next: async () => {
+                do {
+                    if (this._state === 2 /* AsyncIterableSourceState.DoneError */) {
+                        throw this._error;
+                    }
+                    if (i < this._results.length) {
+                        return { done: false, value: this._results[i++] };
+                    }
+                    if (this._state === 1 /* AsyncIterableSourceState.DoneOK */) {
+                        return { done: true, value: undefined };
+                    }
+                    await event_1.Event.toPromise(this._onStateChanged.event);
+                } while (true);
+            },
+            return: async () => {
+                this._onReturn?.();
+                return { done: true, value: undefined };
+            }
+        };
+    }
+    static map(iterable, mapFn) {
+        return new AsyncIterableObject(async (emitter) => {
+            for await (const item of iterable) {
+                emitter.emitOne(mapFn(item));
+            }
+        });
+    }
+    map(mapFn) {
+        return AsyncIterableObject.map(this, mapFn);
+    }
+    static filter(iterable, filterFn) {
+        return new AsyncIterableObject(async (emitter) => {
+            for await (const item of iterable) {
+                if (filterFn(item)) {
+                    emitter.emitOne(item);
+                }
+            }
+        });
+    }
+    filter(filterFn) {
+        return AsyncIterableObject.filter(this, filterFn);
+    }
+    static coalesce(iterable) {
+        return AsyncIterableObject.filter(iterable, item => !!item);
+    }
+    coalesce() {
+        return AsyncIterableObject.coalesce(this);
+    }
+    static async toPromise(iterable) {
+        const result = [];
+        for await (const item of iterable) {
+            result.push(item);
+        }
+        return result;
+    }
+    toPromise() {
+        return AsyncIterableObject.toPromise(this);
+    }
+    /**
+     * The value will be appended at the end.
+     *
+     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
+     */
+    emitOne(value) {
+        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
+            return;
+        }
+        // it is important to add new values at the end,
+        // as we may have iterators already running on the array
+        this._results.push(value);
+        this._onStateChanged.fire();
+    }
+    /**
+     * The values will be appended at the end.
+     *
+     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
+     */
+    emitMany(values) {
+        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
+            return;
+        }
+        // it is important to add new values at the end,
+        // as we may have iterators already running on the array
+        this._results = this._results.concat(values);
+        this._onStateChanged.fire();
+    }
+    /**
+     * Calling `resolve()` will mark the result array as complete.
+     *
+     * **NOTE** `resolve()` must be called, otherwise all consumers of this iterable will hang indefinitely, similar to a non-resolved promise.
+     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
+     */
+    resolve() {
+        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
+            return;
+        }
+        this._state = 1 /* AsyncIterableSourceState.DoneOK */;
+        this._onStateChanged.fire();
+    }
+    /**
+     * Writing an error will permanently invalidate this iterable.
+     * The current users will receive an error thrown, as will all future users.
+     *
+     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
+     */
+    reject(error) {
+        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
+            return;
+        }
+        this._state = 2 /* AsyncIterableSourceState.DoneError */;
+        this._error = error;
+        this._onStateChanged.fire();
+    }
+}
+exports.AsyncIterableObject = AsyncIterableObject;
+function createCancelableAsyncIterableProducer(callback) {
+    const source = new cancellation_1.CancellationTokenSource();
+    const innerIterable = callback(source.token);
+    return new CancelableAsyncIterableProducer(source, async (emitter) => {
+        const subscription = source.token.onCancellationRequested(() => {
+            subscription.dispose();
+            source.dispose();
+            emitter.reject(new errors_1.CancellationError());
+        });
+        try {
+            for await (const item of innerIterable) {
+                if (source.token.isCancellationRequested) {
+                    // canceled in the meantime
+                    return;
+                }
+                emitter.emitOne(item);
+            }
+            subscription.dispose();
+            source.dispose();
+        }
+        catch (err) {
+            subscription.dispose();
+            source.dispose();
+            emitter.reject(err);
+        }
+    });
+}
+class AsyncIterableSource {
+    /**
+     *
+     * @param onReturn A function that will be called when consuming the async iterable
+     * has finished by the consumer, e.g the for-await-loop has be existed (break, return) early.
+     * This is NOT called when resolving this source by its owner.
+     */
+    constructor(onReturn) {
+        this._deferred = new DeferredPromise();
+        this._asyncIterable = new AsyncIterableObject(emitter => {
+            if (earlyError) {
+                emitter.reject(earlyError);
+                return;
+            }
+            if (earlyItems) {
+                emitter.emitMany(earlyItems);
+            }
+            this._errorFn = (error) => emitter.reject(error);
+            this._emitOneFn = (item) => emitter.emitOne(item);
+            this._emitManyFn = (items) => emitter.emitMany(items);
+            return this._deferred.p;
+        }, onReturn);
+        let earlyError;
+        let earlyItems;
+        this._errorFn = (error) => {
+            if (!earlyError) {
+                earlyError = error;
+            }
+        };
+        this._emitOneFn = (item) => {
+            if (!earlyItems) {
+                earlyItems = [];
+            }
+            earlyItems.push(item);
+        };
+        this._emitManyFn = (items) => {
+            if (!earlyItems) {
+                earlyItems = items.slice();
+            }
+            else {
+                items.forEach(item => earlyItems.push(item));
+            }
+        };
+    }
+    get asyncIterable() {
+        return this._asyncIterable;
+    }
+    resolve() {
+        this._deferred.complete();
+    }
+    reject(error) {
+        this._errorFn(error);
+        this._deferred.complete();
+    }
+    emitOne(item) {
+        this._emitOneFn(item);
+    }
+    emitMany(items) {
+        this._emitManyFn(items);
+    }
+}
+exports.AsyncIterableSource = AsyncIterableSource;
+function cancellableIterable(iterableOrIterator, token) {
+    const iterator = Symbol.asyncIterator in iterableOrIterator ? iterableOrIterator[Symbol.asyncIterator]() : iterableOrIterator;
+    return {
+        async next() {
+            if (token.isCancellationRequested) {
+                return { done: true, value: undefined };
+            }
+            const result = await raceCancellation(iterator.next(), token);
+            return result || { done: true, value: undefined };
+        },
+        throw: iterator.throw?.bind(iterator),
+        return: iterator.return?.bind(iterator),
+        [Symbol.asyncIterator]() {
+            return this;
+        }
+    };
+}
+class ProducerConsumer {
+    constructor() {
+        this._unsatisfiedConsumers = [];
+        this._unconsumedValues = [];
+    }
+    get hasFinalValue() {
+        return !!this._finalValue;
+    }
+    produce(value) {
+        this._ensureNoFinalValue();
+        if (this._unsatisfiedConsumers.length > 0) {
+            const deferred = this._unsatisfiedConsumers.shift();
+            this._resolveOrRejectDeferred(deferred, value);
+        }
+        else {
+            this._unconsumedValues.push(value);
+        }
+    }
+    produceFinal(value) {
+        this._ensureNoFinalValue();
+        this._finalValue = value;
+        for (const deferred of this._unsatisfiedConsumers) {
+            this._resolveOrRejectDeferred(deferred, value);
+        }
+        this._unsatisfiedConsumers.length = 0;
+    }
+    _ensureNoFinalValue() {
+        if (this._finalValue) {
+            throw new errors_1.BugIndicatingError('ProducerConsumer: cannot produce after final value has been set');
+        }
+    }
+    _resolveOrRejectDeferred(deferred, value) {
+        if (value.ok) {
+            deferred.complete(value.value);
+        }
+        else {
+            deferred.error(value.error);
+        }
+    }
+    consume() {
+        if (this._unconsumedValues.length > 0 || this._finalValue) {
+            const value = this._unconsumedValues.length > 0 ? this._unconsumedValues.shift() : this._finalValue;
+            if (value.ok) {
+                return Promise.resolve(value.value);
+            }
+            else {
+                return Promise.reject(value.error);
+            }
+        }
+        else {
+            const deferred = new DeferredPromise();
+            this._unsatisfiedConsumers.push(deferred);
+            return deferred.p;
+        }
+    }
+}
+/**
+ * Important difference to AsyncIterableObject:
+ * If it is iterated two times, the second iterator will not see the values emitted by the first iterator.
+ */
+class AsyncIterableProducer {
+    constructor(executor, _onReturn) {
+        this._onReturn = _onReturn;
+        this._producerConsumer = new ProducerConsumer();
+        this._iterator = {
+            next: () => this._producerConsumer.consume(),
+            return: () => {
+                this._onReturn?.();
+                return Promise.resolve({ done: true, value: undefined });
+            },
+            throw: async (e) => {
+                this._finishError(e);
+                return { done: true, value: undefined };
+            },
+        };
+        queueMicrotask(async () => {
+            const p = executor({
+                emitOne: value => this._producerConsumer.produce({ ok: true, value: { done: false, value: value } }),
+                emitMany: values => {
+                    for (const value of values) {
+                        this._producerConsumer.produce({ ok: true, value: { done: false, value: value } });
+                    }
+                },
+                reject: error => this._finishError(error),
+            });
+            if (!this._producerConsumer.hasFinalValue) {
+                try {
+                    await p;
+                    this._finishOk();
+                }
+                catch (error) {
+                    this._finishError(error);
+                }
+            }
+        });
+    }
+    static fromArray(items) {
+        return new AsyncIterableProducer((writer) => {
+            writer.emitMany(items);
+        });
+    }
+    static fromPromise(promise) {
+        return new AsyncIterableProducer(async (emitter) => {
+            emitter.emitMany(await promise);
+        });
+    }
+    static fromPromisesResolveOrder(promises) {
+        return new AsyncIterableProducer(async (emitter) => {
+            await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
+        });
+    }
+    static merge(iterables) {
+        return new AsyncIterableProducer(async (emitter) => {
+            await Promise.all(iterables.map(async (iterable) => {
+                for await (const item of iterable) {
+                    emitter.emitOne(item);
+                }
+            }));
+        });
+    }
+    static { this.EMPTY = AsyncIterableProducer.fromArray([]); }
+    static map(iterable, mapFn) {
+        return new AsyncIterableProducer(async (emitter) => {
+            for await (const item of iterable) {
+                emitter.emitOne(mapFn(item));
+            }
+        });
+    }
+    map(mapFn) {
+        return AsyncIterableProducer.map(this, mapFn);
+    }
+    static coalesce(iterable) {
+        return AsyncIterableProducer.filter(iterable, item => !!item);
+    }
+    coalesce() {
+        return AsyncIterableProducer.coalesce(this);
+    }
+    static filter(iterable, filterFn) {
+        return new AsyncIterableProducer(async (emitter) => {
+            for await (const item of iterable) {
+                if (filterFn(item)) {
+                    emitter.emitOne(item);
+                }
+            }
+        });
+    }
+    filter(filterFn) {
+        return AsyncIterableProducer.filter(this, filterFn);
+    }
+    _finishOk() {
+        if (!this._producerConsumer.hasFinalValue) {
+            this._producerConsumer.produceFinal({ ok: true, value: { done: true, value: undefined } });
+        }
+    }
+    _finishError(error) {
+        if (!this._producerConsumer.hasFinalValue) {
+            this._producerConsumer.produceFinal({ ok: false, error: error });
+        }
+        // Warning: this can cause to dropped errors.
+    }
+    [Symbol.asyncIterator]() {
+        return this._iterator;
+    }
+}
+exports.AsyncIterableProducer = AsyncIterableProducer;
+class CancelableAsyncIterableProducer extends AsyncIterableProducer {
+    constructor(_source, executor) {
+        super(executor);
+        this._source = _source;
+    }
+    cancel() {
+        this._source.cancel();
+    }
+}
+exports.CancelableAsyncIterableProducer = CancelableAsyncIterableProducer;
+//#endregion
+exports.AsyncReaderEndOfStream = Symbol('AsyncReaderEndOfStream');
+class AsyncReader {
+    get endOfStream() { return this._buffer.length === 0 && this._atEnd; }
+    constructor(_source) {
+        this._source = _source;
+        this._buffer = [];
+        this._atEnd = false;
+    }
+    async read() {
+        if (this._buffer.length === 0 && !this._atEnd) {
+            await this._extendBuffer();
+        }
+        if (this._buffer.length === 0) {
+            return exports.AsyncReaderEndOfStream;
+        }
+        return this._buffer.shift();
+    }
+    async readWhile(predicate, callback) {
+        do {
+            const piece = await this.peek();
+            if (piece === exports.AsyncReaderEndOfStream) {
+                break;
+            }
+            if (!predicate(piece)) {
+                break;
+            }
+            await this.read(); // consume
+            await callback(piece);
+        } while (true);
+    }
+    readBufferedOrThrow() {
+        const value = this.peekBufferedOrThrow();
+        this._buffer.shift();
+        return value;
+    }
+    async consumeToEnd() {
+        while (!this.endOfStream) {
+            await this.read();
+        }
+    }
+    async peek() {
+        if (this._buffer.length === 0 && !this._atEnd) {
+            await this._extendBuffer();
+        }
+        if (this._buffer.length === 0) {
+            return exports.AsyncReaderEndOfStream;
+        }
+        return this._buffer[0];
+    }
+    peekBufferedOrThrow() {
+        if (this._buffer.length === 0) {
+            if (this._atEnd) {
+                return exports.AsyncReaderEndOfStream;
+            }
+            throw new errors_1.BugIndicatingError('No buffered elements');
+        }
+        return this._buffer[0];
+    }
+    async peekTimeout(timeoutMs) {
+        if (this._buffer.length === 0 && !this._atEnd) {
+            await raceTimeout(this._extendBuffer(), timeoutMs);
+        }
+        if (this._atEnd) {
+            return exports.AsyncReaderEndOfStream;
+        }
+        if (this._buffer.length === 0) {
+            return undefined;
+        }
+        return this._buffer[0];
+    }
+    _extendBuffer() {
+        if (this._atEnd) {
+            return Promise.resolve();
+        }
+        if (!this._extendBufferPromise) {
+            this._extendBufferPromise = (async () => {
+                const { value, done } = await this._source.next();
+                this._extendBufferPromise = undefined;
+                if (done) {
+                    this._atEnd = true;
+                }
+                else {
+                    this._buffer.push(value);
+                }
+            })();
+        }
+        return this._extendBufferPromise;
+    }
+}
+exports.AsyncReader = AsyncReader;
+//# sourceMappingURL=async.js.map