html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/futures-util/src/stream/stream/buffered.rs

@@ -0,0 +1,118 @@
+use crate::stream::{Fuse, FusedStream, FuturesOrdered, StreamExt};
+use core::fmt;
+use core::pin::Pin;
+use futures_core::future::Future;
+use futures_core::ready;
+use futures_core::stream::Stream;
+use futures_core::task::{Context, Poll};
+#[cfg(feature = "sink")]
+use futures_sink::Sink;
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Stream for the [`buffered`](super::StreamExt::buffered) method.
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Buffered<St>
+    where
+        St: Stream,
+        St::Item: Future,
+    {
+        #[pin]
+        stream: Fuse<St>,
+        in_progress_queue: FuturesOrdered<St::Item>,
+        max: usize,
+    }
+}
+
+impl<St> fmt::Debug for Buffered<St>
+where
+    St: Stream + fmt::Debug,
+    St::Item: Future,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Buffered")
+            .field("stream", &self.stream)
+            .field("in_progress_queue", &self.in_progress_queue)
+            .field("max", &self.max)
+            .finish()
+    }
+}
+
+impl<St> Buffered<St>
+where
+    St: Stream,
+    St::Item: Future,
+{
+    pub(super) fn new(stream: St, n: usize) -> Self {
+        Self { stream: super::Fuse::new(stream), in_progress_queue: FuturesOrdered::new(), max: n }
+    }
+
+    delegate_access_inner!(stream, St, (.));
+}
+
+impl<St> Stream for Buffered<St>
+where
+    St: Stream,
+    St::Item: Future,
+{
+    type Item = <St::Item as Future>::Output;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
+        // First up, try to spawn off as many futures as possible by filling up
+        // our queue of futures.
+        while this.in_progress_queue.len() < *this.max {
+            match this.stream.as_mut().poll_next(cx) {
+                Poll::Ready(Some(fut)) => this.in_progress_queue.push_back(fut),
+                Poll::Ready(None) | Poll::Pending => break,
+            }
+        }
+
+        // Attempt to pull the next value from the in_progress_queue
+        let res = this.in_progress_queue.poll_next_unpin(cx);
+        if let Some(val) = ready!(res) {
+            return Poll::Ready(Some(val));
+        }
+
+        // If more values are still coming from the stream, we're not done yet
+        if this.stream.is_done() {
+            Poll::Ready(None)
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let queue_len = self.in_progress_queue.len();
+        let (lower, upper) = self.stream.size_hint();
+        let lower = lower.saturating_add(queue_len);
+        let upper = match upper {
+            Some(x) => x.checked_add(queue_len),
+            None => None,
+        };
+        (lower, upper)
+    }
+}
+
+impl<St> FusedStream for Buffered<St>
+where
+    St: Stream,
+    St::Item: Future,
+{
+    fn is_terminated(&self) -> bool {
+        self.stream.is_done() && self.in_progress_queue.is_terminated()
+    }
+}
+
+// Forwarding impl of Sink from the underlying stream
+#[cfg(feature = "sink")]
+impl<S, Item> Sink<Item> for Buffered<S>
+where
+    S: Stream + Sink<Item>,
+    S::Item: Future,
+{
+    type Error = S::Error;
+
+    delegate_sink!(stream, Item);
+}

data/rust-vendor/futures-util/src/stream/stream/catch_unwind.rs

@@ -0,0 +1,62 @@
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+use std::any::Any;
+use std::boxed::Box;
+use std::panic::{catch_unwind, AssertUnwindSafe, UnwindSafe};
+use std::pin::Pin;
+
+pin_project! {
+    /// Stream for the [`catch_unwind`](super::StreamExt::catch_unwind) method.
+    #[derive(Debug)]
+    #[must_use = "streams do nothing unless polled"]
+    pub struct CatchUnwind<St> {
+        #[pin]
+        stream: St,
+        caught_unwind: bool,
+    }
+}
+
+impl<St: Stream + UnwindSafe> CatchUnwind<St> {
+    pub(super) fn new(stream: St) -> Self {
+        Self { stream, caught_unwind: false }
+    }
+
+    delegate_access_inner!(stream, St, ());
+}
+
+impl<St: Stream + UnwindSafe> Stream for CatchUnwind<St> {
+    type Item = Result<St::Item, Box<dyn Any + Send>>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
+        if *this.caught_unwind {
+            Poll::Ready(None)
+        } else {
+            let res = catch_unwind(AssertUnwindSafe(|| this.stream.as_mut().poll_next(cx)));
+
+            match res {
+                Ok(poll) => poll.map(|opt| opt.map(Ok)),
+                Err(e) => {
+                    *this.caught_unwind = true;
+                    Poll::Ready(Some(Err(e)))
+                }
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.caught_unwind {
+            (0, Some(0))
+        } else {
+            self.stream.size_hint()
+        }
+    }
+}
+
+impl<St: FusedStream + UnwindSafe> FusedStream for CatchUnwind<St> {
+    fn is_terminated(&self) -> bool {
+        self.caught_unwind || self.stream.is_terminated()
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/chain.rs

@@ -0,0 +1,76 @@
+use core::pin::Pin;
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Stream for the [`chain`](super::StreamExt::chain) method.
+    #[derive(Debug)]
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Chain<St1, St2> {
+        #[pin]
+        first: Option<St1>,
+        #[pin]
+        second: St2,
+    }
+}
+
+// All interactions with `Pin<&mut Chain<..>>` happen through these methods
+impl<St1, St2> Chain<St1, St2>
+where
+    St1: Stream,
+    St2: Stream<Item = St1::Item>,
+{
+    pub(super) fn new(stream1: St1, stream2: St2) -> Self {
+        Self { first: Some(stream1), second: stream2 }
+    }
+}
+
+impl<St1, St2> FusedStream for Chain<St1, St2>
+where
+    St1: Stream,
+    St2: FusedStream<Item = St1::Item>,
+{
+    fn is_terminated(&self) -> bool {
+        self.first.is_none() && self.second.is_terminated()
+    }
+}
+
+impl<St1, St2> Stream for Chain<St1, St2>
+where
+    St1: Stream,
+    St2: Stream<Item = St1::Item>,
+{
+    type Item = St1::Item;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+        if let Some(first) = this.first.as_mut().as_pin_mut() {
+            if let Some(item) = ready!(first.poll_next(cx)) {
+                return Poll::Ready(Some(item));
+            }
+
+            this.first.set(None);
+        }
+        this.second.poll_next(cx)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let Some(first) = &self.first {
+            let (first_lower, first_upper) = first.size_hint();
+            let (second_lower, second_upper) = self.second.size_hint();
+
+            let lower = first_lower.saturating_add(second_lower);
+
+            let upper = match (first_upper, second_upper) {
+                (Some(x), Some(y)) => x.checked_add(y),
+                _ => None,
+            };
+
+            (lower, upper)
+        } else {
+            self.second.size_hint()
+        }
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/chunks.rs

@@ -0,0 +1,103 @@
+use crate::stream::Fuse;
+use alloc::vec::Vec;
+use core::mem;
+use core::pin::Pin;
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+#[cfg(feature = "sink")]
+use futures_sink::Sink;
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Stream for the [`chunks`](super::StreamExt::chunks) method.
+    #[derive(Debug)]
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Chunks<St: Stream> {
+        #[pin]
+        stream: Fuse<St>,
+        items: Vec<St::Item>,
+        cap: usize, // https://github.com/rust-lang/futures-rs/issues/1475
+    }
+}
+
+impl<St: Stream> Chunks<St> {
+    pub(super) fn new(stream: St, capacity: usize) -> Self {
+        assert!(capacity > 0);
+
+        Self {
+            stream: super::Fuse::new(stream),
+            items: Vec::with_capacity(capacity),
+            cap: capacity,
+        }
+    }
+
+    fn take(self: Pin<&mut Self>) -> Vec<St::Item> {
+        let cap = self.cap;
+        mem::replace(self.project().items, Vec::with_capacity(cap))
+    }
+
+    delegate_access_inner!(stream, St, (.));
+}
+
+impl<St: Stream> Stream for Chunks<St> {
+    type Item = Vec<St::Item>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.as_mut().project();
+        loop {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
+                // Push the item into the buffer and check whether it is full.
+                // If so, replace our buffer with a new and empty one and return
+                // the full one.
+                Some(item) => {
+                    this.items.push(item);
+                    if this.items.len() >= *this.cap {
+                        return Poll::Ready(Some(self.take()));
+                    }
+                }
+
+                // Since the underlying stream ran out of values, return what we
+                // have buffered, if we have anything.
+                None => {
+                    let last = if this.items.is_empty() {
+                        None
+                    } else {
+                        let full_buf = mem::take(this.items);
+                        Some(full_buf)
+                    };
+
+                    return Poll::Ready(last);
+                }
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let chunk_len = usize::from(!self.items.is_empty());
+        let (lower, upper) = self.stream.size_hint();
+        let lower = (lower / self.cap).saturating_add(chunk_len);
+        let upper = match upper {
+            Some(x) => x.checked_add(chunk_len),
+            None => None,
+        };
+        (lower, upper)
+    }
+}
+
+impl<St: FusedStream> FusedStream for Chunks<St> {
+    fn is_terminated(&self) -> bool {
+        self.stream.is_terminated() && self.items.is_empty()
+    }
+}
+
+// Forwarding impl of Sink from the underlying stream
+#[cfg(feature = "sink")]
+impl<S, Item> Sink<Item> for Chunks<S>
+where
+    S: Stream + Sink<Item>,
+{
+    type Error = S::Error;
+
+    delegate_sink!(stream, Item);
+}

data/rust-vendor/futures-util/src/stream/stream/collect.rs

@@ -0,0 +1,56 @@
+use core::mem;
+use core::pin::Pin;
+use futures_core::future::{FusedFuture, Future};
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Future for the [`collect`](super::StreamExt::collect) method.
+    #[derive(Debug)]
+    #[must_use = "futures do nothing unless you `.await` or poll them"]
+    pub struct Collect<St, C> {
+        #[pin]
+        stream: St,
+        collection: C,
+    }
+}
+
+impl<St: Stream, C: Default> Collect<St, C> {
+    fn finish(self: Pin<&mut Self>) -> C {
+        mem::take(self.project().collection)
+    }
+
+    pub(super) fn new(stream: St) -> Self {
+        Self { stream, collection: Default::default() }
+    }
+}
+
+impl<St, C> FusedFuture for Collect<St, C>
+where
+    St: FusedStream,
+    C: Default + Extend<St::Item>,
+{
+    fn is_terminated(&self) -> bool {
+        self.stream.is_terminated()
+    }
+}
+
+impl<St, C> Future for Collect<St, C>
+where
+    St: Stream,
+    C: Default + Extend<St::Item>,
+{
+    type Output = C;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<C> {
+        let mut this = self.as_mut().project();
+        loop {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
+                Some(e) => this.collection.extend(Some(e)),
+                None => return Poll::Ready(self.finish()),
+            }
+        }
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/concat.rs

@@ -0,0 +1,62 @@
+use core::pin::Pin;
+use futures_core::future::{FusedFuture, Future};
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Future for the [`concat`](super::StreamExt::concat) method.
+    #[derive(Debug)]
+    #[must_use = "futures do nothing unless you `.await` or poll them"]
+    pub struct Concat<St: Stream> {
+        #[pin]
+        stream: St,
+        accum: Option<St::Item>,
+    }
+}
+
+impl<St> Concat<St>
+where
+    St: Stream,
+    St::Item: Extend<<St::Item as IntoIterator>::Item> + IntoIterator + Default,
+{
+    pub(super) fn new(stream: St) -> Self {
+        Self { stream, accum: None }
+    }
+}
+
+impl<St> Future for Concat<St>
+where
+    St: Stream,
+    St::Item: Extend<<St::Item as IntoIterator>::Item> + IntoIterator + Default,
+{
+    type Output = St::Item;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+
+        loop {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
+                None => return Poll::Ready(this.accum.take().unwrap_or_default()),
+                Some(e) => {
+                    if let Some(a) = this.accum {
+                        a.extend(e)
+                    } else {
+                        *this.accum = Some(e)
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<St> FusedFuture for Concat<St>
+where
+    St: FusedStream,
+    St::Item: Extend<<St::Item as IntoIterator>::Item> + IntoIterator + Default,
+{
+    fn is_terminated(&self) -> bool {
+        self.accum.is_none() && self.stream.is_terminated()
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/count.rs

@@ -0,0 +1,53 @@
+use core::fmt;
+use core::pin::Pin;
+use futures_core::future::{FusedFuture, Future};
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Future for the [`count`](super::StreamExt::count) method.
+    #[must_use = "futures do nothing unless you `.await` or poll them"]
+    pub struct Count<St> {
+        #[pin]
+        stream: St,
+        count: usize
+    }
+}
+
+impl<St> fmt::Debug for Count<St>
+where
+    St: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Count").field("stream", &self.stream).field("count", &self.count).finish()
+    }
+}
+
+impl<St: Stream> Count<St> {
+    pub(super) fn new(stream: St) -> Self {
+        Self { stream, count: 0 }
+    }
+}
+
+impl<St: FusedStream> FusedFuture for Count<St> {
+    fn is_terminated(&self) -> bool {
+        self.stream.is_terminated()
+    }
+}
+
+impl<St: Stream> Future for Count<St> {
+    type Output = usize;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+
+        Poll::Ready(loop {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
+                Some(_) => *this.count += 1,
+                None => break *this.count,
+            }
+        })
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/cycle.rs

@@ -0,0 +1,67 @@
+use core::pin::Pin;
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Stream for the [`cycle`](super::StreamExt::cycle) method.
+    #[derive(Debug)]
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Cycle<St> {
+        orig: St,
+        #[pin]
+        stream: St,
+    }
+}
+
+impl<St> Cycle<St>
+where
+    St: Clone + Stream,
+{
+    pub(super) fn new(stream: St) -> Self {
+        Self { orig: stream.clone(), stream }
+    }
+}
+
+impl<St> Stream for Cycle<St>
+where
+    St: Clone + Stream,
+{
+    type Item = St::Item;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
+        match ready!(this.stream.as_mut().poll_next(cx)) {
+            None => {
+                this.stream.set(this.orig.clone());
+                this.stream.poll_next(cx)
+            }
+            item => Poll::Ready(item),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // the cycle stream is either empty or infinite
+        match self.orig.size_hint() {
+            size @ (0, Some(0)) => size,
+            (0, _) => (0, None),
+            _ => (usize::MAX, None),
+        }
+    }
+}
+
+impl<St> FusedStream for Cycle<St>
+where
+    St: Clone + Stream,
+{
+    fn is_terminated(&self) -> bool {
+        // the cycle stream is either empty or infinite
+        if let (0, Some(0)) = self.size_hint() {
+            true
+        } else {
+            false
+        }
+    }
+}

data/rust-vendor/futures-util/src/stream/stream/enumerate.rs

@@ -0,0 +1,64 @@
+use core::pin::Pin;
+use futures_core::ready;
+use futures_core::stream::{FusedStream, Stream};
+use futures_core::task::{Context, Poll};
+#[cfg(feature = "sink")]
+use futures_sink::Sink;
+use pin_project_lite::pin_project;
+
+pin_project! {
+    /// Stream for the [`enumerate`](super::StreamExt::enumerate) method.
+    #[derive(Debug)]
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Enumerate<St> {
+        #[pin]
+        stream: St,
+        count: usize,
+    }
+}
+
+impl<St: Stream> Enumerate<St> {
+    pub(super) fn new(stream: St) -> Self {
+        Self { stream, count: 0 }
+    }
+
+    delegate_access_inner!(stream, St, ());
+}
+
+impl<St: Stream + FusedStream> FusedStream for Enumerate<St> {
+    fn is_terminated(&self) -> bool {
+        self.stream.is_terminated()
+    }
+}
+
+impl<St: Stream> Stream for Enumerate<St> {
+    type Item = (usize, St::Item);
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.project();
+
+        match ready!(this.stream.poll_next(cx)) {
+            Some(item) => {
+                let prev_count = *this.count;
+                *this.count += 1;
+                Poll::Ready(Some((prev_count, item)))
+            }
+            None => Poll::Ready(None),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.stream.size_hint()
+    }
+}
+
+// Forwarding impl of Sink from the underlying stream
+#[cfg(feature = "sink")]
+impl<S, Item> Sink<Item> for Enumerate<S>
+where
+    S: Stream + Sink<Item>,
+{
+    type Error = S::Error;
+
+    delegate_sink!(stream, Item);
+}