claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/base/common/async.js

@@ -0,0 +1,832 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CancellationTokenSource } from './cancellation.js';
+import { CancellationError } from './errors.js';
+import { Emitter, Event } from './event.js';
+import { toDisposable } from './lifecycle.js';
+import { setTimeout0 } from './platform.js';
+import { MicrotaskDelay } from './symbols.js';
+export function isThenable(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
+export function createCancelablePromise(callback) {
+    const source = new CancellationTokenSource();
+    const thenable = callback(source.token);
+    const promise = new Promise((resolve, reject) => {
+        const subscription = source.token.onCancellationRequested(() => {
+            subscription.dispose();
+            source.dispose();
+            reject(new CancellationError());
+        });
+        Promise.resolve(thenable).then(value => {
+            subscription.dispose();
+            source.dispose();
+            resolve(value);
+        }, err => {
+            subscription.dispose();
+            source.dispose();
+            reject(err);
+        });
+    });
+    return new class {
+        cancel() {
+            source.cancel();
+        }
+        then(resolve, reject) {
+            return promise.then(resolve, reject);
+        }
+        catch(reject) {
+            return this.then(undefined, reject);
+        }
+        finally(onfinally) {
+            return promise.finally(onfinally);
+        }
+    };
+}
+export 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());
+    });
+}
+/**
+ * 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);
+ * 		}
+ */
+export 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;
+    }
+}
+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(); });
+ * 		}
+ */
+export 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 = () => {
+            var _a;
+            this.deferred = null;
+            (_a = this.doResolve) === null || _a === void 0 ? void 0 : _a.call(this, null);
+        };
+        this.deferred = delay === MicrotaskDelay ? microtaskDeferred(fn) : timeoutDeferred(delay, fn);
+        return this.completionPromise;
+    }
+    isTriggered() {
+        var _a;
+        return !!((_a = this.deferred) === null || _a === void 0 ? void 0 : _a.isTriggered());
+    }
+    cancel() {
+        var _a;
+        this.cancelTimeout();
+        if (this.completionPromise) {
+            (_a = this.doReject) === null || _a === void 0 ? void 0 : _a.call(this, new CancellationError());
+            this.completionPromise = null;
+        }
+    }
+    cancelTimeout() {
+        var _a;
+        (_a = this.deferred) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.deferred = null;
+    }
+    dispose() {
+        this.cancel();
+    }
+}
+/**
+ * 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.
+ */
+export 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);
+    }
+    cancel() {
+        this.delayer.cancel();
+    }
+    dispose() {
+        this.delayer.dispose();
+        this.throttler.dispose();
+    }
+}
+export 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 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();
+ * }
+ */
+export function disposableTimeout(handler, timeout = 0, store) {
+    const timer = setTimeout(() => {
+        handler();
+        if (store) {
+            disposable.dispose();
+        }
+    }, timeout);
+    const disposable = toDisposable(() => {
+        clearTimeout(timer);
+        store === null || store === void 0 ? void 0 : store.deleteAndLeak(disposable);
+    });
+    store === null || store === void 0 ? void 0 : store.add(disposable);
+    return disposable;
+}
+export 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();
+}
+export class TimeoutTimer {
+    constructor(runner, timeout) {
+        this._token = -1;
+        if (typeof runner === 'function' && typeof timeout === 'number') {
+            this.setIfNotSet(runner, timeout);
+        }
+    }
+    dispose() {
+        this.cancel();
+    }
+    cancel() {
+        if (this._token !== -1) {
+            clearTimeout(this._token);
+            this._token = -1;
+        }
+    }
+    cancelAndSet(runner, timeout) {
+        this.cancel();
+        this._token = setTimeout(() => {
+            this._token = -1;
+            runner();
+        }, timeout);
+    }
+    setIfNotSet(runner, timeout) {
+        if (this._token !== -1) {
+            // timer is already set
+            return;
+        }
+        this._token = setTimeout(() => {
+            this._token = -1;
+            runner();
+        }, timeout);
+    }
+}
+export class IntervalTimer {
+    constructor() {
+        this.disposable = undefined;
+    }
+    cancel() {
+        var _a;
+        (_a = this.disposable) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.disposable = undefined;
+    }
+    cancelAndSet(runner, interval, context = globalThis) {
+        this.cancel();
+        const handle = context.setInterval(() => {
+            runner();
+        }, interval);
+        this.disposable = toDisposable(() => {
+            context.clearInterval(handle);
+            this.disposable = undefined;
+        });
+    }
+    dispose() {
+        this.cancel();
+    }
+}
+export class RunOnceScheduler {
+    constructor(runner, delay) {
+        this.timeoutToken = -1;
+        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 = -1;
+        }
+    }
+    /**
+     * 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 !== -1;
+    }
+    onTimeout() {
+        this.timeoutToken = -1;
+        if (this.runner) {
+            this.doRun();
+        }
+    }
+    doRun() {
+        var _a;
+        (_a = this.runner) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+}
+/**
+ * Execute the callback the next time the browser is idle, returning an
+ * {@link IDisposable} that will cancel the callback when disposed. This wraps
+ * [requestIdleCallback] so it will fallback to [setTimeout] if the environment
+ * doesn't support it.
+ *
+ * @param callback The callback to run when idle, this includes an
+ * [IdleDeadline] that provides the time alloted for the idle callback by the
+ * browser. Not respecting this deadline will result in a degraded user
+ * experience.
+ * @param timeout A timeout at which point to queue no longer wait for an idle
+ * callback but queue it on the regular event loop (like setTimeout). Typically
+ * this should not be used.
+ *
+ * [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline
+ * [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback
+ * [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout
+ *
+ * **Note** that there is `dom.ts#runWhenWindowIdle` which is better suited when running inside a browser
+ * context
+ */
+export let runWhenGlobalIdle;
+export let _runWhenIdle;
+(function () {
+    if (typeof globalThis.requestIdleCallback !== 'function' || typeof globalThis.cancelIdleCallback !== 'function') {
+        _runWhenIdle = (_targetWindow, runner) => {
+            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 {
+        _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);
+                }
+            };
+        };
+    }
+    runWhenGlobalIdle = (runner) => _runWhenIdle(globalThis, runner);
+})();
+export 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 = _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;
+    }
+}
+/**
+ * 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
+ */
+export class GlobalIdleValue extends AbstractIdleValue {
+    constructor(executor) {
+        super(globalThis, executor);
+    }
+}
+/**
+ * Creates a promise whose resolution or rejection can be controlled imperatively.
+ */
+export class DeferredPromise {
+    get isRejected() {
+        var _a;
+        return ((_a = this.outcome) === null || _a === void 0 ? void 0 : _a.outcome) === 1 /* DeferredOutcome.Rejected */;
+    }
+    get isSettled() {
+        return !!this.outcome;
+    }
+    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();
+        });
+    }
+    cancel() {
+        return this.error(new CancellationError());
+    }
+}
+//#endregion
+//#region Promises
+export 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 || (Promises = {}));
+/**
+ * A rich implementation for an `AsyncIterable<T>`.
+ */
+export 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 fromPromises(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);
+                }
+            }));
+        });
+    }
+    constructor(executor) {
+        this._state = 0 /* AsyncIterableSourceState.Initial */;
+        this._results = [];
+        this._error = null;
+        this._onStateChanged = new 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.toPromise(this._onStateChanged.event);
+                } while (true);
+            }
+        };
+    }
+    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();
+    }
+}
+AsyncIterableObject.EMPTY = AsyncIterableObject.fromArray([]);
+export class CancelableAsyncIterableObject extends AsyncIterableObject {
+    constructor(_source, executor) {
+        super(executor);
+        this._source = _source;
+    }
+    cancel() {
+        this._source.cancel();
+    }
+}
+export function createCancelableAsyncIterable(callback) {
+    const source = new CancellationTokenSource();
+    const innerIterable = callback(source.token);
+    return new CancelableAsyncIterableObject(source, async (emitter) => {
+        const subscription = source.token.onCancellationRequested(() => {
+            subscription.dispose();
+            source.dispose();
+            emitter.reject(new 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);
+        }
+    });
+}
+//#endregion