DeferErrorUntilCompletion for asynchronous sequences

DeferErrorUntilCompletion.cs

// https://stackoverflow.com/questions/73056639/how-to-chunkify-an-ienumerablet-without-losing-discarding-items-in-case-of-fa
private async static IAsyncEnumerable<TOutput> DeferErrorUntilCompletion<TInput, TOutput>(
    IAsyncEnumerable<TInput> input,
    Func<IAsyncEnumerable<TInput>, IAsyncEnumerable<TOutput>> conversion,
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    Task errorContainer = null;

    async IAsyncEnumerable<TInput> InputIterator(
        [EnumeratorCancellation] CancellationToken innerToken = default)
    {
        IAsyncEnumerator<TInput> enumerator = input.GetAsyncEnumerator(innerToken);
        await using (enumerator.ConfigureAwait(false))
        {
            while (true)
            {
                TInput item;
                try
                {
                    if (!await enumerator.MoveNextAsync().ConfigureAwait(false)) break;
                    item = enumerator.Current;
                }
                catch (OperationCanceledException oce)
                {
                    TaskCompletionSource<bool> tcs = new();
                    tcs.SetCanceled(oce.CancellationToken);
                    errorContainer = tcs.Task;
                    break;
                }
                catch (Exception ex)
                {
                    errorContainer = Task.FromException(ex);
                    break;
                }
                yield return item;
            }
        }
    }
    IAsyncEnumerable<TOutput> output = conversion(InputIterator());
    await foreach (TOutput item in output.WithCancellation(cancellationToken).ConfigureAwait(false))
        yield return item;
    errorContainer?.GetAwaiter().GetResult();
}