Deleted vendor folder

11 files changed, 0 insertions, 5494 deletions

diff --git a/vendor/indicatif/src/draw_target.rs b/vendor/indicatif/src/draw_target.rs
deleted file mode 100644
index a2c055f..0000000
--- a/vendor/indicatif/src/draw_target.rs
+++ /dev/null
@@ -1,561 +0,0 @@
-use std::io;
-use std::sync::{Arc, RwLock, RwLockWriteGuard};
-use std::thread::panicking;
-use std::time::Duration;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-
-use console::Term;
-#[cfg(target_arch = "wasm32")]
-use instant::Instant;
-
-use crate::multi::{MultiProgressAlignment, MultiState};
-use crate::TermLike;
-
-/// Target for draw operations
-///
-/// This tells a progress bar or a multi progress object where to paint to.
-/// The draw target is a stateful wrapper over a drawing destination and
-/// internally optimizes how often the state is painted to the output
-/// device.
-#[derive(Debug)]
-pub struct ProgressDrawTarget {
-    kind: TargetKind,
-}
-
-impl ProgressDrawTarget {
-    /// Draw to a buffered stdout terminal at a max of 20 times a second.
-    ///
-    /// For more information see [`ProgressDrawTarget::term`].
-    pub fn stdout() -> Self {
-        Self::term(Term::buffered_stdout(), 20)
-    }
-
-    /// Draw to a buffered stderr terminal at a max of 20 times a second.
-    ///
-    /// This is the default draw target for progress bars.  For more
-    /// information see [`ProgressDrawTarget::term`].
-    pub fn stderr() -> Self {
-        Self::term(Term::buffered_stderr(), 20)
-    }
-
-    /// Draw to a buffered stdout terminal at a max of `refresh_rate` times a second.
-    ///
-    /// For more information see [`ProgressDrawTarget::term`].
-    pub fn stdout_with_hz(refresh_rate: u8) -> Self {
-        Self::term(Term::buffered_stdout(), refresh_rate)
-    }
-
-    /// Draw to a buffered stderr terminal at a max of `refresh_rate` times a second.
-    ///
-    /// For more information see [`ProgressDrawTarget::term`].
-    pub fn stderr_with_hz(refresh_rate: u8) -> Self {
-        Self::term(Term::buffered_stderr(), refresh_rate)
-    }
-
-    pub(crate) fn new_remote(state: Arc<RwLock<MultiState>>, idx: usize) -> Self {
-        Self {
-            kind: TargetKind::Multi { state, idx },
-        }
-    }
-
-    /// Draw to a terminal, with a specific refresh rate.
-    ///
-    /// Progress bars are by default drawn to terminals however if the
-    /// terminal is not user attended the entire progress bar will be
-    /// hidden.  This is done so that piping to a file will not produce
-    /// useless escape codes in that file.
-    ///
-    /// Will panic if refresh_rate is `0`.
-    pub fn term(term: Term, refresh_rate: u8) -> Self {
-        Self {
-            kind: TargetKind::Term {
-                term,
-                last_line_count: 0,
-                rate_limiter: RateLimiter::new(refresh_rate),
-                draw_state: DrawState::default(),
-            },
-        }
-    }
-
-    /// Draw to a boxed object that implements the [`TermLike`] trait.
-    pub fn term_like(term_like: Box<dyn TermLike>) -> Self {
-        Self {
-            kind: TargetKind::TermLike {
-                inner: term_like,
-                last_line_count: 0,
-                rate_limiter: None,
-                draw_state: DrawState::default(),
-            },
-        }
-    }
-
-    /// Draw to a boxed object that implements the [`TermLike`] trait,
-    /// with a specific refresh rate.
-    pub fn term_like_with_hz(term_like: Box<dyn TermLike>, refresh_rate: u8) -> Self {
-        Self {
-            kind: TargetKind::TermLike {
-                inner: term_like,
-                last_line_count: 0,
-                rate_limiter: Option::from(RateLimiter::new(refresh_rate)),
-                draw_state: DrawState::default(),
-            },
-        }
-    }
-
-    /// A hidden draw target.
-    ///
-    /// This forces a progress bar to be not rendered at all.
-    pub fn hidden() -> Self {
-        Self {
-            kind: TargetKind::Hidden,
-        }
-    }
-
-    /// Returns true if the draw target is hidden.
-    ///
-    /// This is internally used in progress bars to figure out if overhead
-    /// from drawing can be prevented.
-    pub fn is_hidden(&self) -> bool {
-        match self.kind {
-            TargetKind::Hidden => true,
-            TargetKind::Term { ref term, .. } => !term.is_term(),
-            TargetKind::Multi { ref state, .. } => state.read().unwrap().is_hidden(),
-            _ => false,
-        }
-    }
-
-    /// Returns the current width of the draw target.
-    pub(crate) fn width(&self) -> u16 {
-        match self.kind {
-            TargetKind::Term { ref term, .. } => term.size().1,
-            TargetKind::Multi { ref state, .. } => state.read().unwrap().width(),
-            TargetKind::Hidden => 0,
-            TargetKind::TermLike { ref inner, .. } => inner.width(),
-        }
-    }
-
-    /// Notifies the backing `MultiProgress` (if applicable) that the associated progress bar should
-    /// be marked a zombie.
-    pub(crate) fn mark_zombie(&self) {
-        if let TargetKind::Multi { idx, state } = &self.kind {
-            state.write().unwrap().mark_zombie(*idx);
-        }
-    }
-
-    /// Apply the given draw state (draws it).
-    pub(crate) fn drawable(&mut self, force_draw: bool, now: Instant) -> Option<Drawable<'_>> {
-        match &mut self.kind {
-            TargetKind::Term {
-                term,
-                last_line_count,
-                rate_limiter,
-                draw_state,
-            } => {
-                if !term.is_term() {
-                    return None;
-                }
-
-                match force_draw || rate_limiter.allow(now) {
-                    true => Some(Drawable::Term {
-                        term,
-                        last_line_count,
-                        draw_state,
-                    }),
-                    false => None, // rate limited
-                }
-            }
-            TargetKind::Multi { idx, state, .. } => {
-                let state = state.write().unwrap();
-                Some(Drawable::Multi {
-                    idx: *idx,
-                    state,
-                    force_draw,
-                    now,
-                })
-            }
-            TargetKind::TermLike {
-                inner,
-                last_line_count,
-                rate_limiter,
-                draw_state,
-            } => match force_draw || rate_limiter.as_mut().map_or(true, |r| r.allow(now)) {
-                true => Some(Drawable::TermLike {
-                    term_like: &**inner,
-                    last_line_count,
-                    draw_state,
-                }),
-                false => None, // rate limited
-            },
-            // Hidden, finished, or no need to refresh yet
-            _ => None,
-        }
-    }
-
-    /// Properly disconnects from the draw target
-    pub(crate) fn disconnect(&self, now: Instant) {
-        match self.kind {
-            TargetKind::Term { .. } => {}
-            TargetKind::Multi { idx, ref state, .. } => {
-                let state = state.write().unwrap();
-                let _ = Drawable::Multi {
-                    state,
-                    idx,
-                    force_draw: true,
-                    now,
-                }
-                .clear();
-            }
-            TargetKind::Hidden => {}
-            TargetKind::TermLike { .. } => {}
-        };
-    }
-
-    pub(crate) fn remote(&self) -> Option<(&Arc<RwLock<MultiState>>, usize)> {
-        match &self.kind {
-            TargetKind::Multi { state, idx } => Some((state, *idx)),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
-        self.kind.adjust_last_line_count(adjust);
-    }
-}
-
-#[derive(Debug)]
-enum TargetKind {
-    Term {
-        term: Term,
-        last_line_count: usize,
-        rate_limiter: RateLimiter,
-        draw_state: DrawState,
-    },
-    Multi {
-        state: Arc<RwLock<MultiState>>,
-        idx: usize,
-    },
-    Hidden,
-    TermLike {
-        inner: Box<dyn TermLike>,
-        last_line_count: usize,
-        rate_limiter: Option<RateLimiter>,
-        draw_state: DrawState,
-    },
-}
-
-impl TargetKind {
-    /// Adjust `last_line_count` such that the next draw operation keeps/clears additional lines
-    fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
-        let last_line_count: &mut usize = match self {
-            Self::Term {
-                last_line_count, ..
-            } => last_line_count,
-            Self::TermLike {
-                last_line_count, ..
-            } => last_line_count,
-            _ => return,
-        };
-
-        match adjust {
-            LineAdjust::Clear(count) => *last_line_count = last_line_count.saturating_add(count),
-            LineAdjust::Keep(count) => *last_line_count = last_line_count.saturating_sub(count),
-        }
-    }
-}
-
-pub(crate) enum Drawable<'a> {
-    Term {
-        term: &'a Term,
-        last_line_count: &'a mut usize,
-        draw_state: &'a mut DrawState,
-    },
-    Multi {
-        state: RwLockWriteGuard<'a, MultiState>,
-        idx: usize,
-        force_draw: bool,
-        now: Instant,
-    },
-    TermLike {
-        term_like: &'a dyn TermLike,
-        last_line_count: &'a mut usize,
-        draw_state: &'a mut DrawState,
-    },
-}
-
-impl<'a> Drawable<'a> {
-    /// Adjust `last_line_count` such that the next draw operation keeps/clears additional lines
-    pub(crate) fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
-        let last_line_count: &mut usize = match self {
-            Drawable::Term {
-                last_line_count, ..
-            } => last_line_count,
-            Drawable::TermLike {
-                last_line_count, ..
-            } => last_line_count,
-            _ => return,
-        };
-
-        match adjust {
-            LineAdjust::Clear(count) => *last_line_count = last_line_count.saturating_add(count),
-            LineAdjust::Keep(count) => *last_line_count = last_line_count.saturating_sub(count),
-        }
-    }
-
-    pub(crate) fn state(&mut self) -> DrawStateWrapper<'_> {
-        let mut state = match self {
-            Drawable::Term { draw_state, .. } => DrawStateWrapper::for_term(draw_state),
-            Drawable::Multi { state, idx, .. } => state.draw_state(*idx),
-            Drawable::TermLike { draw_state, .. } => DrawStateWrapper::for_term(draw_state),
-        };
-
-        state.reset();
-        state
-    }
-
-    pub(crate) fn clear(mut self) -> io::Result<()> {
-        let state = self.state();
-        drop(state);
-        self.draw()
-    }
-
-    pub(crate) fn draw(self) -> io::Result<()> {
-        match self {
-            Drawable::Term {
-                term,
-                last_line_count,
-                draw_state,
-            } => draw_state.draw_to_term(term, last_line_count),
-            Drawable::Multi {
-                mut state,
-                force_draw,
-                now,
-                ..
-            } => state.draw(force_draw, None, now),
-            Drawable::TermLike {
-                term_like,
-                last_line_count,
-                draw_state,
-            } => draw_state.draw_to_term(term_like, last_line_count),
-        }
-    }
-}
-
-pub(crate) enum LineAdjust {
-    /// Adds to `last_line_count` so that the next draw also clears those lines
-    Clear(usize),
-    /// Subtracts from `last_line_count` so that the next draw retains those lines
-    Keep(usize),
-}
-
-pub(crate) struct DrawStateWrapper<'a> {
-    state: &'a mut DrawState,
-    orphan_lines: Option<&'a mut Vec<String>>,
-}
-
-impl<'a> DrawStateWrapper<'a> {
-    pub(crate) fn for_term(state: &'a mut DrawState) -> Self {
-        Self {
-            state,
-            orphan_lines: None,
-        }
-    }
-
-    pub(crate) fn for_multi(state: &'a mut DrawState, orphan_lines: &'a mut Vec<String>) -> Self {
-        Self {
-            state,
-            orphan_lines: Some(orphan_lines),
-        }
-    }
-}
-
-impl std::ops::Deref for DrawStateWrapper<'_> {
-    type Target = DrawState;
-
-    fn deref(&self) -> &Self::Target {
-        self.state
-    }
-}
-
-impl std::ops::DerefMut for DrawStateWrapper<'_> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.state
-    }
-}
-
-impl Drop for DrawStateWrapper<'_> {
-    fn drop(&mut self) {
-        if let Some(orphaned) = &mut self.orphan_lines {
-            orphaned.extend(self.state.lines.drain(..self.state.orphan_lines_count));
-            self.state.orphan_lines_count = 0;
-        }
-    }
-}
-
-#[derive(Debug)]
-struct RateLimiter {
-    interval: u16, // in milliseconds
-    capacity: u8,
-    prev: Instant,
-}
-
-/// Rate limit but allow occasional bursts above desired rate
-impl RateLimiter {
-    fn new(rate: u8) -> Self {
-        Self {
-            interval: 1000 / (rate as u16), // between 3 and 1000 milliseconds
-            capacity: MAX_BURST,
-            prev: Instant::now(),
-        }
-    }
-
-    fn allow(&mut self, now: Instant) -> bool {
-        if now < self.prev {
-            return false;
-        }
-
-        let elapsed = now - self.prev;
-        // If `capacity` is 0 and not enough time (`self.interval` ms) has passed since
-        // `self.prev` to add new capacity, return `false`. The goal of this method is to
-        // make this decision as efficient as possible.
-        if self.capacity == 0 && elapsed < Duration::from_millis(self.interval as u64) {
-            return false;
-        }
-
-        // We now calculate `new`, the number of ms, since we last returned `true`,
-        // and `remainder`, which represents a number of ns less than 1ms which we cannot
-        // convert into capacity now, so we're saving it for later.
-        let (new, remainder) = (
-            elapsed.as_millis() / self.interval as u128,
-            elapsed.as_nanos() % (self.interval as u128 * 1_000_000),
-        );
-
-        // We add `new` to `capacity`, subtract one for returning `true` from here,
-        // then make sure it does not exceed a maximum of `MAX_BURST`, then store it.
-        self.capacity = Ord::min(MAX_BURST as u128, (self.capacity as u128) + new - 1) as u8;
-        // Store `prev` for the next iteration after subtracting the `remainder`.
-        // Just use `unwrap` here because it shouldn't be possible for this to underflow.
-        self.prev = now
-            .checked_sub(Duration::from_nanos(remainder as u64))
-            .unwrap();
-        true
-    }
-}
-
-const MAX_BURST: u8 = 20;
-
-/// The drawn state of an element.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct DrawState {
-    /// The lines to print (can contain ANSI codes)
-    pub(crate) lines: Vec<String>,
-    /// The number of lines that shouldn't be reaped by the next tick.
-    pub(crate) orphan_lines_count: usize,
-    /// True if we should move the cursor up when possible instead of clearing lines.
-    pub(crate) move_cursor: bool,
-    /// Controls how the multi progress is aligned if some of its progress bars get removed, default is `Top`
-    pub(crate) alignment: MultiProgressAlignment,
-}
-
-impl DrawState {
-    fn draw_to_term(
-        &mut self,
-        term: &(impl TermLike + ?Sized),
-        last_line_count: &mut usize,
-    ) -> io::Result<()> {
-        if panicking() {
-            return Ok(());
-        }
-
-        if !self.lines.is_empty() && self.move_cursor {
-            term.move_cursor_up(*last_line_count)?;
-        } else {
-            // Fork of console::clear_last_lines that assumes that the last line doesn't contain a '\n'
-            let n = *last_line_count;
-            term.move_cursor_up(n.saturating_sub(1))?;
-            for i in 0..n {
-                term.clear_line()?;
-                if i + 1 != n {
-                    term.move_cursor_down(1)?;
-                }
-            }
-            term.move_cursor_up(n.saturating_sub(1))?;
-        }
-
-        let shift = match self.alignment {
-            MultiProgressAlignment::Bottom if self.lines.len() < *last_line_count => {
-                let shift = *last_line_count - self.lines.len();
-                for _ in 0..shift {
-                    term.write_line("")?;
-                }
-                shift
-            }
-            _ => 0,
-        };
-
-        let term_height = term.height() as usize;
-        let term_width = term.width() as usize;
-        let len = self.lines.len();
-        let mut real_len = 0;
-        let mut last_line_filler = 0;
-        debug_assert!(self.orphan_lines_count <= self.lines.len());
-        for (idx, line) in self.lines.iter().enumerate() {
-            let line_width = console::measure_text_width(line);
-            let diff = if line.is_empty() {
-                // Empty line are new line
-                1
-            } else {
-                // Calculate real length based on terminal width
-                // This take in account linewrap from terminal
-                let terminal_len = (line_width as f64 / term_width as f64).ceil() as usize;
-
-                // If the line is effectively empty (for example when it consists
-                // solely of ANSI color code sequences, count it the same as a
-                // new line. If the line is measured to be len = 0, we will
-                // subtract with overflow later.
-                usize::max(terminal_len, 1)
-            };
-            // Don't consider orphan lines when comparing to terminal height.
-            debug_assert!(idx <= real_len);
-            if self.orphan_lines_count <= idx
-                && real_len - self.orphan_lines_count + diff > term_height
-            {
-                break;
-            }
-            real_len += diff;
-            if idx != 0 {
-                term.write_line("")?;
-            }
-            term.write_str(line)?;
-            if idx + 1 == len {
-                // Keep the cursor on the right terminal side
-                // So that next user writes/prints will happen on the next line
-                last_line_filler = term_width.saturating_sub(line_width);
-            }
-        }
-        term.write_str(&" ".repeat(last_line_filler))?;
-
-        term.flush()?;
-        *last_line_count = real_len - self.orphan_lines_count + shift;
-        Ok(())
-    }
-
-    fn reset(&mut self) {
-        self.lines.clear();
-        self.orphan_lines_count = 0;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{MultiProgress, ProgressBar, ProgressDrawTarget};
-
-    #[test]
-    fn multi_is_hidden() {
-        let mp = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
-
-        let pb = mp.add(ProgressBar::new(100));
-        assert!(mp.is_hidden());
-        assert!(pb.is_hidden());
-    }
-}
diff --git a/vendor/indicatif/src/format.rs b/vendor/indicatif/src/format.rs
deleted file mode 100644
index 7475a25..0000000
--- a/vendor/indicatif/src/format.rs
+++ /dev/null
@@ -1,337 +0,0 @@
-use std::fmt;
-use std::time::Duration;
-
-use number_prefix::NumberPrefix;
-
-const SECOND: Duration = Duration::from_secs(1);
-const MINUTE: Duration = Duration::from_secs(60);
-const HOUR: Duration = Duration::from_secs(60 * 60);
-const DAY: Duration = Duration::from_secs(24 * 60 * 60);
-const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);
-const YEAR: Duration = Duration::from_secs(365 * 24 * 60 * 60);
-
-/// Wraps an std duration for human basic formatting.
-#[derive(Debug)]
-pub struct FormattedDuration(pub Duration);
-
-/// Wraps an std duration for human readable formatting.
-#[derive(Debug)]
-pub struct HumanDuration(pub Duration);
-
-/// Formats bytes for human readability
-#[derive(Debug)]
-pub struct HumanBytes(pub u64);
-
-/// Formats bytes for human readability using SI prefixes
-#[derive(Debug)]
-pub struct DecimalBytes(pub u64);
-
-/// Formats bytes for human readability using ISO/IEC prefixes
-#[derive(Debug)]
-pub struct BinaryBytes(pub u64);
-
-/// Formats counts for human readability using commas
-#[derive(Debug)]
-pub struct HumanCount(pub u64);
-
-/// Formats counts for human readability using commas for floats
-#[derive(Debug)]
-pub struct HumanFloatCount(pub f64);
-
-impl fmt::Display for FormattedDuration {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut t = self.0.as_secs();
-        let seconds = t % 60;
-        t /= 60;
-        let minutes = t % 60;
-        t /= 60;
-        let hours = t % 24;
-        t /= 24;
-        if t > 0 {
-            let days = t;
-            write!(f, "{days}d {hours:02}:{minutes:02}:{seconds:02}")
-        } else {
-            write!(f, "{hours:02}:{minutes:02}:{seconds:02}")
-        }
-    }
-}
-
-// `HumanDuration` should be as intuitively understandable as possible.
-// So we want to round, not truncate: otherwise 1 hour and 59 minutes
-// would display an ETA of "1 hour" which underestimates the time
-// remaining by a factor 2.
-//
-// To make the precision more uniform, we avoid displaying "1 unit"
-// (except for seconds), because it would be displayed for a relatively
-// long duration compared to the unit itself. Instead, when we arrive
-// around 1.5 unit, we change from "2 units" to the next smaller unit
-// (e.g. "89 seconds").
-//
-// Formally:
-// * for n >= 2, we go from "n+1 units" to "n units" exactly at (n + 1/2) units
-// * we switch from "2 units" to the next smaller unit at (1.5 unit minus half of the next smaller unit)
-
-impl fmt::Display for HumanDuration {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut idx = 0;
-        for (i, &(cur, _, _)) in UNITS.iter().enumerate() {
-            idx = i;
-            match UNITS.get(i + 1) {
-                Some(&next) if self.0.saturating_add(next.0 / 2) >= cur + cur / 2 => break,
-                _ => continue,
-            }
-        }
-
-        let (unit, name, alt) = UNITS[idx];
-        // FIXME when `div_duration_f64` is stable
-        let mut t = (self.0.as_secs_f64() / unit.as_secs_f64()).round() as usize;
-        if idx < UNITS.len() - 1 {
-            t = Ord::max(t, 2);
-        }
-
-        match (f.alternate(), t) {
-            (true, _) => write!(f, "{t}{alt}"),
-            (false, 1) => write!(f, "{t} {name}"),
-            (false, _) => write!(f, "{t} {name}s"),
-        }
-    }
-}
-
-const UNITS: &[(Duration, &str, &str)] = &[
-    (YEAR, "year", "y"),
-    (WEEK, "week", "w"),
-    (DAY, "day", "d"),
-    (HOUR, "hour", "h"),
-    (MINUTE, "minute", "m"),
-    (SECOND, "second", "s"),
-];
-
-impl fmt::Display for HumanBytes {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match NumberPrefix::binary(self.0 as f64) {
-            NumberPrefix::Standalone(number) => write!(f, "{number:.0} B"),
-            NumberPrefix::Prefixed(prefix, number) => write!(f, "{number:.2} {prefix}B"),
-        }
-    }
-}
-
-impl fmt::Display for DecimalBytes {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match NumberPrefix::decimal(self.0 as f64) {
-            NumberPrefix::Standalone(number) => write!(f, "{number:.0} B"),
-            NumberPrefix::Prefixed(prefix, number) => write!(f, "{number:.2} {prefix}B"),
-        }
-    }
-}
-
-impl fmt::Display for BinaryBytes {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match NumberPrefix::binary(self.0 as f64) {
-            NumberPrefix::Standalone(number) => write!(f, "{number:.0} B"),
-            NumberPrefix::Prefixed(prefix, number) => write!(f, "{number:.2} {prefix}B"),
-        }
-    }
-}
-
-impl fmt::Display for HumanCount {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use fmt::Write;
-
-        let num = self.0.to_string();
-        let len = num.len();
-        for (idx, c) in num.chars().enumerate() {
-            let pos = len - idx - 1;
-            f.write_char(c)?;
-            if pos > 0 && pos % 3 == 0 {
-                f.write_char(',')?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for HumanFloatCount {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use fmt::Write;
-
-        let num = format!("{:.4}", self.0);
-        let (int_part, frac_part) = match num.split_once('.') {
-            Some((int_str, fract_str)) => (int_str.to_string(), fract_str),
-            None => (self.0.trunc().to_string(), ""),
-        };
-        let len = int_part.len();
-        for (idx, c) in int_part.chars().enumerate() {
-            let pos = len - idx - 1;
-            f.write_char(c)?;
-            if pos > 0 && pos % 3 == 0 {
-                f.write_char(',')?;
-            }
-        }
-        let frac_trimmed = frac_part.trim_end_matches('0');
-        if !frac_trimmed.is_empty() {
-            f.write_char('.')?;
-            f.write_str(frac_trimmed)?;
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const MILLI: Duration = Duration::from_millis(1);
-
-    #[test]
-    fn human_duration_alternate() {
-        for (unit, _, alt) in UNITS {
-            assert_eq!(format!("2{alt}"), format!("{:#}", HumanDuration(2 * *unit)));
-        }
-    }
-
-    #[test]
-    fn human_duration_less_than_one_second() {
-        assert_eq!(
-            "0 seconds",
-            format!("{}", HumanDuration(Duration::from_secs(0)))
-        );
-        assert_eq!("0 seconds", format!("{}", HumanDuration(MILLI)));
-        assert_eq!("0 seconds", format!("{}", HumanDuration(499 * MILLI)));
-        assert_eq!("1 second", format!("{}", HumanDuration(500 * MILLI)));
-        assert_eq!("1 second", format!("{}", HumanDuration(999 * MILLI)));
-    }
-
-    #[test]
-    fn human_duration_less_than_two_seconds() {
-        assert_eq!("1 second", format!("{}", HumanDuration(1499 * MILLI)));
-        assert_eq!("2 seconds", format!("{}", HumanDuration(1500 * MILLI)));
-        assert_eq!("2 seconds", format!("{}", HumanDuration(1999 * MILLI)));
-    }
-
-    #[test]
-    fn human_duration_one_unit() {
-        assert_eq!("1 second", format!("{}", HumanDuration(SECOND)));
-        assert_eq!("60 seconds", format!("{}", HumanDuration(MINUTE)));
-        assert_eq!("60 minutes", format!("{}", HumanDuration(HOUR)));
-        assert_eq!("24 hours", format!("{}", HumanDuration(DAY)));
-        assert_eq!("7 days", format!("{}", HumanDuration(WEEK)));
-        assert_eq!("52 weeks", format!("{}", HumanDuration(YEAR)));
-    }
-
-    #[test]
-    fn human_duration_less_than_one_and_a_half_unit() {
-        // this one is actually done at 1.5 unit - half of the next smaller unit - epsilon
-        // and should display the next smaller unit
-        let d = HumanDuration(MINUTE + MINUTE / 2 - SECOND / 2 - MILLI);
-        assert_eq!("89 seconds", format!("{d}"));
-        let d = HumanDuration(HOUR + HOUR / 2 - MINUTE / 2 - MILLI);
-        assert_eq!("89 minutes", format!("{d}"));
-        let d = HumanDuration(DAY + DAY / 2 - HOUR / 2 - MILLI);
-        assert_eq!("35 hours", format!("{d}"));
-        let d = HumanDuration(WEEK + WEEK / 2 - DAY / 2 - MILLI);
-        assert_eq!("10 days", format!("{d}"));
-        let d = HumanDuration(YEAR + YEAR / 2 - WEEK / 2 - MILLI);
-        assert_eq!("78 weeks", format!("{d}"));
-    }
-
-    #[test]
-    fn human_duration_one_and_a_half_unit() {
-        // this one is actually done at 1.5 unit - half of the next smaller unit
-        // and should still display "2 units"
-        let d = HumanDuration(MINUTE + MINUTE / 2 - SECOND / 2);
-        assert_eq!("2 minutes", format!("{d}"));
-        let d = HumanDuration(HOUR + HOUR / 2 - MINUTE / 2);
-        assert_eq!("2 hours", format!("{d}"));
-        let d = HumanDuration(DAY + DAY / 2 - HOUR / 2);
-        assert_eq!("2 days", format!("{d}"));
-        let d = HumanDuration(WEEK + WEEK / 2 - DAY / 2);
-        assert_eq!("2 weeks", format!("{d}"));
-        let d = HumanDuration(YEAR + YEAR / 2 - WEEK / 2);
-        assert_eq!("2 years", format!("{d}"));
-    }
-
-    #[test]
-    fn human_duration_two_units() {
-        assert_eq!("2 seconds", format!("{}", HumanDuration(2 * SECOND)));
-        assert_eq!("2 minutes", format!("{}", HumanDuration(2 * MINUTE)));
-        assert_eq!("2 hours", format!("{}", HumanDuration(2 * HOUR)));
-        assert_eq!("2 days", format!("{}", HumanDuration(2 * DAY)));
-        assert_eq!("2 weeks", format!("{}", HumanDuration(2 * WEEK)));
-        assert_eq!("2 years", format!("{}", HumanDuration(2 * YEAR)));
-    }
-
-    #[test]
-    fn human_duration_less_than_two_and_a_half_units() {
-        let d = HumanDuration(2 * SECOND + SECOND / 2 - MILLI);
-        assert_eq!("2 seconds", format!("{d}"));
-        let d = HumanDuration(2 * MINUTE + MINUTE / 2 - MILLI);
-        assert_eq!("2 minutes", format!("{d}"));
-        let d = HumanDuration(2 * HOUR + HOUR / 2 - MILLI);
-        assert_eq!("2 hours", format!("{d}"));
-        let d = HumanDuration(2 * DAY + DAY / 2 - MILLI);
-        assert_eq!("2 days", format!("{d}"));
-        let d = HumanDuration(2 * WEEK + WEEK / 2 - MILLI);
-        assert_eq!("2 weeks", format!("{d}"));
-        let d = HumanDuration(2 * YEAR + YEAR / 2 - MILLI);
-        assert_eq!("2 years", format!("{d}"));
-    }
-
-    #[test]
-    fn human_duration_two_and_a_half_units() {
-        let d = HumanDuration(2 * SECOND + SECOND / 2);
-        assert_eq!("3 seconds", format!("{d}"));
-        let d = HumanDuration(2 * MINUTE + MINUTE / 2);
-        assert_eq!("3 minutes", format!("{d}"));
-        let d = HumanDuration(2 * HOUR + HOUR / 2);
-        assert_eq!("3 hours", format!("{d}"));
-        let d = HumanDuration(2 * DAY + DAY / 2);
-        assert_eq!("3 days", format!("{d}"));
-        let d = HumanDuration(2 * WEEK + WEEK / 2);
-        assert_eq!("3 weeks", format!("{d}"));
-        let d = HumanDuration(2 * YEAR + YEAR / 2);
-        assert_eq!("3 years", format!("{d}"));
-    }
-
-    #[test]
-    fn human_duration_three_units() {
-        assert_eq!("3 seconds", format!("{}", HumanDuration(3 * SECOND)));
-        assert_eq!("3 minutes", format!("{}", HumanDuration(3 * MINUTE)));
-        assert_eq!("3 hours", format!("{}", HumanDuration(3 * HOUR)));
-        assert_eq!("3 days", format!("{}", HumanDuration(3 * DAY)));
-        assert_eq!("3 weeks", format!("{}", HumanDuration(3 * WEEK)));
-        assert_eq!("3 years", format!("{}", HumanDuration(3 * YEAR)));
-    }
-
-    #[test]
-    fn human_count() {
-        assert_eq!("42", format!("{}", HumanCount(42)));
-        assert_eq!("7,654", format!("{}", HumanCount(7654)));
-        assert_eq!("12,345", format!("{}", HumanCount(12345)));
-        assert_eq!("1,234,567,890", format!("{}", HumanCount(1234567890)));
-    }
-
-    #[test]
-    fn human_float_count() {
-        assert_eq!("42", format!("{}", HumanFloatCount(42.0)));
-        assert_eq!("7,654", format!("{}", HumanFloatCount(7654.0)));
-        assert_eq!("12,345", format!("{}", HumanFloatCount(12345.0)));
-        assert_eq!(
-            "1,234,567,890",
-            format!("{}", HumanFloatCount(1234567890.0))
-        );
-        assert_eq!("42.5", format!("{}", HumanFloatCount(42.5)));
-        assert_eq!("42.5", format!("{}", HumanFloatCount(42.500012345)));
-        assert_eq!("42.502", format!("{}", HumanFloatCount(42.502012345)));
-        assert_eq!("7,654.321", format!("{}", HumanFloatCount(7654.321)));
-        assert_eq!("7,654.321", format!("{}", HumanFloatCount(7654.3210123456)));
-        assert_eq!("12,345.6789", format!("{}", HumanFloatCount(12345.6789)));
-        assert_eq!(
-            "1,234,567,890.1235",
-            format!("{}", HumanFloatCount(1234567890.1234567))
-        );
-        assert_eq!(
-            "1,234,567,890.1234",
-            format!("{}", HumanFloatCount(1234567890.1234321))
-        );
-    }
-}
diff --git a/vendor/indicatif/src/in_memory.rs b/vendor/indicatif/src/in_memory.rs
deleted file mode 100644
index 046ae14..0000000
--- a/vendor/indicatif/src/in_memory.rs
+++ /dev/null
@@ -1,399 +0,0 @@
-use std::fmt::{Debug, Formatter, Write as _};
-use std::io::Write as _;
-use std::sync::{Arc, Mutex};
-
-use vt100::Parser;
-
-use crate::TermLike;
-
-/// A thin wrapper around [`vt100::Parser`].
-///
-/// This is just an [`Arc`] around its internal state, so it can be freely cloned.
-#[cfg_attr(docsrs, doc(cfg(feature = "in_memory")))]
-#[derive(Debug, Clone)]
-pub struct InMemoryTerm {
-    state: Arc<Mutex<InMemoryTermState>>,
-}
-
-impl InMemoryTerm {
-    pub fn new(rows: u16, cols: u16) -> InMemoryTerm {
-        assert!(rows > 0, "rows must be > 0");
-        assert!(cols > 0, "cols must be > 0");
-        InMemoryTerm {
-            state: Arc::new(Mutex::new(InMemoryTermState::new(rows, cols))),
-        }
-    }
-
-    pub fn reset(&self) {
-        let mut state = self.state.lock().unwrap();
-        *state = InMemoryTermState::new(state.height, state.width);
-    }
-
-    pub fn contents(&self) -> String {
-        let state = self.state.lock().unwrap();
-
-        // For some reason, the `Screen::contents` method doesn't include newlines in what it
-        // returns, making it useless for our purposes. So we need to manually reconstruct the
-        // contents by iterating over the rows in the terminal buffer.
-        let mut rows = state
-            .parser
-            .screen()
-            .rows(0, state.width)
-            .collect::<Vec<_>>();
-
-        // Reverse the rows and trim empty lines from the end
-        rows = rows
-            .into_iter()
-            .rev()
-            .skip_while(|line| line.is_empty())
-            .map(|line| line.trim_end().to_string())
-            .collect();
-
-        // Un-reverse the rows and join them up with newlines
-        rows.reverse();
-        rows.join("\n")
-    }
-
-    pub fn contents_formatted(&self) -> Vec<u8> {
-        let state = self.state.lock().unwrap();
-
-        // For some reason, the `Screen::contents` method doesn't include newlines in what it
-        // returns, making it useless for our purposes. So we need to manually reconstruct the
-        // contents by iterating over the rows in the terminal buffer.
-        let mut rows = state
-            .parser
-            .screen()
-            .rows_formatted(0, state.width)
-            .collect::<Vec<_>>();
-
-        // Reverse the rows and trim empty lines from the end
-        rows = rows
-            .into_iter()
-            .rev()
-            .skip_while(|line| line.is_empty())
-            .collect();
-
-        // Un-reverse the rows
-        rows.reverse();
-
-        // Calculate buffer size
-        let reset = b"";
-        let len = rows.iter().map(|line| line.len() + reset.len() + 1).sum();
-
-        // Join rows up with reset codes and newlines
-        let mut contents = rows.iter().fold(Vec::with_capacity(len), |mut acc, cur| {
-            acc.extend_from_slice(cur);
-            acc.extend_from_slice(reset);
-            acc.push(b'\n');
-            acc
-        });
-
-        // Remove last newline again, but leave the reset code
-        contents.truncate(len.saturating_sub(1));
-        contents
-    }
-
-    pub fn moves_since_last_check(&self) -> String {
-        let mut s = String::new();
-        for line in std::mem::take(&mut self.state.lock().unwrap().history) {
-            writeln!(s, "{line:?}").unwrap();
-        }
-        s
-    }
-}
-
-impl TermLike for InMemoryTerm {
-    fn width(&self) -> u16 {
-        self.state.lock().unwrap().width
-    }
-
-    fn height(&self) -> u16 {
-        self.state.lock().unwrap().height
-    }
-
-    fn move_cursor_up(&self, n: usize) -> std::io::Result<()> {
-        match n {
-            0 => Ok(()),
-            _ => {
-                let mut state = self.state.lock().unwrap();
-                state.history.push(Move::Up(n));
-                state.write_str(&format!("\x1b[{n}A"))
-            }
-        }
-    }
-
-    fn move_cursor_down(&self, n: usize) -> std::io::Result<()> {
-        match n {
-            0 => Ok(()),
-            _ => {
-                let mut state = self.state.lock().unwrap();
-                state.history.push(Move::Down(n));
-                state.write_str(&format!("\x1b[{n}B"))
-            }
-        }
-    }
-
-    fn move_cursor_right(&self, n: usize) -> std::io::Result<()> {
-        match n {
-            0 => Ok(()),
-            _ => {
-                let mut state = self.state.lock().unwrap();
-                state.history.push(Move::Right(n));
-                state.write_str(&format!("\x1b[{n}C"))
-            }
-        }
-    }
-
-    fn move_cursor_left(&self, n: usize) -> std::io::Result<()> {
-        match n {
-            0 => Ok(()),
-            _ => {
-                let mut state = self.state.lock().unwrap();
-                state.history.push(Move::Left(n));
-                state.write_str(&format!("\x1b[{n}D"))
-            }
-        }
-    }
-
-    fn write_line(&self, s: &str) -> std::io::Result<()> {
-        let mut state = self.state.lock().unwrap();
-        state.history.push(Move::Str(s.into()));
-        state.history.push(Move::NewLine);
-
-        // Don't try to handle writing lines with additional newlines embedded in them - it's not
-        // worth the extra code for something that indicatif doesn't even do. May revisit in future.
-        debug_assert!(
-            s.lines().count() <= 1,
-            "calling write_line with embedded newlines is not allowed"
-        );
-
-        // vte100 needs the full \r\n sequence to jump to the next line and reset the cursor to
-        // the beginning of the line. Be flexible and take either \n or \r\n
-        state.write_str(s)?;
-        state.write_str("\r\n")
-    }
-
-    fn write_str(&self, s: &str) -> std::io::Result<()> {
-        let mut state = self.state.lock().unwrap();
-        state.history.push(Move::Str(s.into()));
-        state.write_str(s)
-    }
-
-    fn clear_line(&self) -> std::io::Result<()> {
-        let mut state = self.state.lock().unwrap();
-        state.history.push(Move::Clear);
-        state.write_str("\r\x1b[2K")
-    }
-
-    fn flush(&self) -> std::io::Result<()> {
-        let mut state = self.state.lock().unwrap();
-        state.history.push(Move::Flush);
-        state.parser.flush()
-    }
-}
-
-struct InMemoryTermState {
-    width: u16,
-    height: u16,
-    parser: vt100::Parser,
-    history: Vec<Move>,
-}
-
-impl InMemoryTermState {
-    pub(crate) fn new(rows: u16, cols: u16) -> InMemoryTermState {
-        InMemoryTermState {
-            width: cols,
-            height: rows,
-            parser: Parser::new(rows, cols, 0),
-            history: vec![],
-        }
-    }
-
-    pub(crate) fn write_str(&mut self, s: &str) -> std::io::Result<()> {
-        self.parser.write_all(s.as_bytes())
-    }
-}
-
-impl Debug for InMemoryTermState {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("InMemoryTermState").finish_non_exhaustive()
-    }
-}
-
-#[derive(Debug, PartialEq, Clone)]
-enum Move {
-    Up(usize),
-    Down(usize),
-    Left(usize),
-    Right(usize),
-    Str(String),
-    NewLine,
-    Clear,
-    Flush,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn cursor_pos(in_mem: &InMemoryTerm) -> (u16, u16) {
-        in_mem
-            .state
-            .lock()
-            .unwrap()
-            .parser
-            .screen()
-            .cursor_position()
-    }
-
-    #[test]
-    fn line_wrapping() {
-        let in_mem = InMemoryTerm::new(10, 5);
-        assert_eq!(cursor_pos(&in_mem), (0, 0));
-
-        in_mem.write_str("ABCDE").unwrap();
-        assert_eq!(in_mem.contents(), "ABCDE");
-        assert_eq!(cursor_pos(&in_mem), (0, 5));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("ABCDE")
-"#
-        );
-
-        // Should wrap onto next line
-        in_mem.write_str("FG").unwrap();
-        assert_eq!(in_mem.contents(), "ABCDE\nFG");
-        assert_eq!(cursor_pos(&in_mem), (1, 2));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("FG")
-"#
-        );
-
-        in_mem.write_str("HIJ").unwrap();
-        assert_eq!(in_mem.contents(), "ABCDE\nFGHIJ");
-        assert_eq!(cursor_pos(&in_mem), (1, 5));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("HIJ")
-"#
-        );
-    }
-
-    #[test]
-    fn write_line() {
-        let in_mem = InMemoryTerm::new(10, 5);
-        assert_eq!(cursor_pos(&in_mem), (0, 0));
-
-        in_mem.write_line("A").unwrap();
-        assert_eq!(in_mem.contents(), "A");
-        assert_eq!(cursor_pos(&in_mem), (1, 0));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("A")
-NewLine
-"#
-        );
-
-        in_mem.write_line("B").unwrap();
-        assert_eq!(in_mem.contents(), "A\nB");
-        assert_eq!(cursor_pos(&in_mem), (2, 0));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("B")
-NewLine
-"#
-        );
-
-        in_mem.write_line("Longer than cols").unwrap();
-        assert_eq!(in_mem.contents(), "A\nB\nLonge\nr tha\nn col\ns");
-        assert_eq!(cursor_pos(&in_mem), (6, 0));
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("Longer than cols")
-NewLine
-"#
-        );
-    }
-
-    #[test]
-    fn basic_functionality() {
-        let in_mem = InMemoryTerm::new(10, 80);
-
-        in_mem.write_line("This is a test line").unwrap();
-        assert_eq!(in_mem.contents(), "This is a test line");
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("This is a test line")
-NewLine
-"#
-        );
-
-        in_mem.write_line("And another line!").unwrap();
-        assert_eq!(in_mem.contents(), "This is a test line\nAnd another line!");
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("And another line!")
-NewLine
-"#
-        );
-
-        in_mem.move_cursor_up(1).unwrap();
-        in_mem.write_str("TEST").unwrap();
-
-        assert_eq!(in_mem.contents(), "This is a test line\nTESTanother line!");
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Up(1)
-Str("TEST")
-"#
-        );
-    }
-
-    #[test]
-    fn newlines() {
-        let in_mem = InMemoryTerm::new(10, 10);
-        in_mem.write_line("LINE ONE").unwrap();
-        in_mem.write_line("LINE TWO").unwrap();
-        in_mem.write_line("").unwrap();
-        in_mem.write_line("LINE FOUR").unwrap();
-
-        assert_eq!(in_mem.contents(), "LINE ONE\nLINE TWO\n\nLINE FOUR");
-
-        assert_eq!(
-            in_mem.moves_since_last_check(),
-            r#"Str("LINE ONE")
-NewLine
-Str("LINE TWO")
-NewLine
-Str("")
-NewLine
-Str("LINE FOUR")
-NewLine
-"#
-        );
-    }
-
-    #[test]
-    fn cursor_zero_movement() {
-        let in_mem = InMemoryTerm::new(10, 80);
-        in_mem.write_line("LINE ONE").unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 0));
-
-        // Check that moving zero rows/cols does not actually move cursor
-        in_mem.move_cursor_up(0).unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 0));
-
-        in_mem.move_cursor_down(0).unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 0));
-
-        in_mem.move_cursor_right(1).unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 1));
-
-        in_mem.move_cursor_left(0).unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 1));
-
-        in_mem.move_cursor_right(0).unwrap();
-        assert_eq!(cursor_pos(&in_mem), (1, 1));
-    }
-}
diff --git a/vendor/indicatif/src/iter.rs b/vendor/indicatif/src/iter.rs
deleted file mode 100644
index 3e73660..0000000
--- a/vendor/indicatif/src/iter.rs
+++ /dev/null
@@ -1,355 +0,0 @@
-use std::borrow::Cow;
-use std::io::{self, IoSliceMut};
-use std::iter::FusedIterator;
-#[cfg(feature = "tokio")]
-use std::pin::Pin;
-#[cfg(feature = "tokio")]
-use std::task::{Context, Poll};
-use std::time::Duration;
-
-#[cfg(feature = "tokio")]
-use tokio::io::{ReadBuf, SeekFrom};
-
-use crate::progress_bar::ProgressBar;
-use crate::state::ProgressFinish;
-use crate::style::ProgressStyle;
-
-/// Wraps an iterator to display its progress.
-pub trait ProgressIterator
-where
-    Self: Sized + Iterator,
-{
-    /// Wrap an iterator with default styling. Uses `Iterator::size_hint` to get length.
-    /// Returns `Some(..)` only if `size_hint.1` is `Some`. If you want to create a progress bar
-    /// even if `size_hint.1` returns `None` use `progress_count` or `progress_with` instead.
-    fn try_progress(self) -> Option<ProgressBarIter<Self>> {
-        self.size_hint()
-            .1
-            .map(|len| self.progress_count(u64::try_from(len).unwrap()))
-    }
-
-    /// Wrap an iterator with default styling.
-    fn progress(self) -> ProgressBarIter<Self>
-    where
-        Self: ExactSizeIterator,
-    {
-        let len = u64::try_from(self.len()).unwrap();
-        self.progress_count(len)
-    }
-
-    /// Wrap an iterator with an explicit element count.
-    fn progress_count(self, len: u64) -> ProgressBarIter<Self> {
-        self.progress_with(ProgressBar::new(len))
-    }
-
-    /// Wrap an iterator with a custom progress bar.
-    fn progress_with(self, progress: ProgressBar) -> ProgressBarIter<Self>;
-
-    /// Wrap an iterator with a progress bar and style it.
-    fn progress_with_style(self, style: crate::ProgressStyle) -> ProgressBarIter<Self>
-    where
-        Self: ExactSizeIterator,
-    {
-        let len = u64::try_from(self.len()).unwrap();
-        let bar = ProgressBar::new(len).with_style(style);
-        self.progress_with(bar)
-    }
-}
-
-/// Wraps an iterator to display its progress.
-#[derive(Debug)]
-pub struct ProgressBarIter<T> {
-    pub(crate) it: T,
-    pub progress: ProgressBar,
-}
-
-impl<T> ProgressBarIter<T> {
-    /// Builder-like function for setting underlying progress bar's style.
-    ///
-    /// See [ProgressBar::with_style].
-    pub fn with_style(mut self, style: ProgressStyle) -> Self {
-        self.progress = self.progress.with_style(style);
-        self
-    }
-
-    /// Builder-like function for setting underlying progress bar's prefix.
-    ///
-    /// See [ProgressBar::with_prefix].
-    pub fn with_prefix(mut self, prefix: impl Into<Cow<'static, str>>) -> Self {
-        self.progress = self.progress.with_prefix(prefix);
-        self
-    }
-
-    /// Builder-like function for setting underlying progress bar's message.
-    ///
-    /// See [ProgressBar::with_message].
-    pub fn with_message(mut self, message: impl Into<Cow<'static, str>>) -> Self {
-        self.progress = self.progress.with_message(message);
-        self
-    }
-
-    /// Builder-like function for setting underlying progress bar's position.
-    ///
-    /// See [ProgressBar::with_position].
-    pub fn with_position(mut self, position: u64) -> Self {
-        self.progress = self.progress.with_position(position);
-        self
-    }
-
-    /// Builder-like function for setting underlying progress bar's elapsed time.
-    ///
-    /// See [ProgressBar::with_elapsed].
-    pub fn with_elapsed(mut self, elapsed: Duration) -> Self {
-        self.progress = self.progress.with_elapsed(elapsed);
-        self
-    }
-
-    /// Builder-like function for setting underlying progress bar's finish behavior.
-    ///
-    /// See [ProgressBar::with_finish].
-    pub fn with_finish(mut self, finish: ProgressFinish) -> Self {
-        self.progress = self.progress.with_finish(finish);
-        self
-    }
-}
-
-impl<S, T: Iterator<Item = S>> Iterator for ProgressBarIter<T> {
-    type Item = S;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let item = self.it.next();
-
-        if item.is_some() {
-            self.progress.inc(1);
-        } else if !self.progress.is_finished() {
-            self.progress.finish_using_style();
-        }
-
-        item
-    }
-}
-
-impl<T: ExactSizeIterator> ExactSizeIterator for ProgressBarIter<T> {
-    fn len(&self) -> usize {
-        self.it.len()
-    }
-}
-
-impl<T: DoubleEndedIterator> DoubleEndedIterator for ProgressBarIter<T> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let item = self.it.next_back();
-
-        if item.is_some() {
-            self.progress.inc(1);
-        } else if !self.progress.is_finished() {
-            self.progress.finish_using_style();
-        }
-
-        item
-    }
-}
-
-impl<T: FusedIterator> FusedIterator for ProgressBarIter<T> {}
-
-impl<R: io::Read> io::Read for ProgressBarIter<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let inc = self.it.read(buf)?;
-        self.progress.inc(inc as u64);
-        Ok(inc)
-    }
-
-    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        let inc = self.it.read_vectored(bufs)?;
-        self.progress.inc(inc as u64);
-        Ok(inc)
-    }
-
-    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
-        let inc = self.it.read_to_string(buf)?;
-        self.progress.inc(inc as u64);
-        Ok(inc)
-    }
-
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        self.it.read_exact(buf)?;
-        self.progress.inc(buf.len() as u64);
-        Ok(())
-    }
-}
-
-impl<R: io::BufRead> io::BufRead for ProgressBarIter<R> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        self.it.fill_buf()
-    }
-
-    fn consume(&mut self, amt: usize) {
-        self.it.consume(amt);
-        self.progress.inc(amt as u64);
-    }
-}
-
-impl<S: io::Seek> io::Seek for ProgressBarIter<S> {
-    fn seek(&mut self, f: io::SeekFrom) -> io::Result<u64> {
-        self.it.seek(f).map(|pos| {
-            self.progress.set_position(pos);
-            pos
-        })
-    }
-    // Pass this through to preserve optimizations that the inner I/O object may use here
-    // Also avoid sending a set_position update when the position hasn't changed
-    fn stream_position(&mut self) -> io::Result<u64> {
-        self.it.stream_position()
-    }
-}
-
-#[cfg(feature = "tokio")]
-#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-impl<W: tokio::io::AsyncWrite + Unpin> tokio::io::AsyncWrite for ProgressBarIter<W> {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.it).poll_write(cx, buf).map(|poll| {
-            poll.map(|inc| {
-                self.progress.inc(inc as u64);
-                inc
-            })
-        })
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.it).poll_flush(cx)
-    }
-
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.it).poll_shutdown(cx)
-    }
-}
-
-#[cfg(feature = "tokio")]
-#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-impl<W: tokio::io::AsyncRead + Unpin> tokio::io::AsyncRead for ProgressBarIter<W> {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        let prev_len = buf.filled().len() as u64;
-        if let Poll::Ready(e) = Pin::new(&mut self.it).poll_read(cx, buf) {
-            self.progress.inc(buf.filled().len() as u64 - prev_len);
-            Poll::Ready(e)
-        } else {
-            Poll::Pending
-        }
-    }
-}
-
-#[cfg(feature = "tokio")]
-#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-impl<W: tokio::io::AsyncSeek + Unpin> tokio::io::AsyncSeek for ProgressBarIter<W> {
-    fn start_seek(mut self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
-        Pin::new(&mut self.it).start_seek(position)
-    }
-
-    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        Pin::new(&mut self.it).poll_complete(cx)
-    }
-}
-
-#[cfg(feature = "tokio")]
-#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-impl<W: tokio::io::AsyncBufRead + Unpin + tokio::io::AsyncRead> tokio::io::AsyncBufRead
-    for ProgressBarIter<W>
-{
-    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
-        let this = self.get_mut();
-        let result = Pin::new(&mut this.it).poll_fill_buf(cx);
-        if let Poll::Ready(Ok(buf)) = &result {
-            this.progress.inc(buf.len() as u64);
-        }
-        result
-    }
-
-    fn consume(mut self: Pin<&mut Self>, amt: usize) {
-        Pin::new(&mut self.it).consume(amt);
-    }
-}
-
-#[cfg(feature = "futures")]
-#[cfg_attr(docsrs, doc(cfg(feature = "futures")))]
-impl<S: futures_core::Stream + Unpin> futures_core::Stream for ProgressBarIter<S> {
-    type Item = S::Item;
-
-    fn poll_next(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-        let item = std::pin::Pin::new(&mut this.it).poll_next(cx);
-        match &item {
-            std::task::Poll::Ready(Some(_)) => this.progress.inc(1),
-            std::task::Poll::Ready(None) => this.progress.finish_using_style(),
-            std::task::Poll::Pending => {}
-        }
-        item
-    }
-}
-
-impl<W: io::Write> io::Write for ProgressBarIter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.it.write(buf).map(|inc| {
-            self.progress.inc(inc as u64);
-            inc
-        })
-    }
-
-    fn write_vectored(&mut self, bufs: &[io::IoSlice]) -> io::Result<usize> {
-        self.it.write_vectored(bufs).map(|inc| {
-            self.progress.inc(inc as u64);
-            inc
-        })
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.it.flush()
-    }
-
-    // write_fmt can not be captured with reasonable effort.
-    // as it uses write_all internally by default that should not be a problem.
-    // fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()>;
-}
-
-impl<S, T: Iterator<Item = S>> ProgressIterator for T {
-    fn progress_with(self, progress: ProgressBar) -> ProgressBarIter<Self> {
-        ProgressBarIter { it: self, progress }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::iter::{ProgressBarIter, ProgressIterator};
-    use crate::progress_bar::ProgressBar;
-    use crate::ProgressStyle;
-
-    #[test]
-    fn it_can_wrap_an_iterator() {
-        let v = [1, 2, 3];
-        let wrap = |it: ProgressBarIter<_>| {
-            assert_eq!(it.map(|x| x * 2).collect::<Vec<_>>(), vec![2, 4, 6]);
-        };
-
-        wrap(v.iter().progress());
-        wrap(v.iter().progress_count(3));
-        wrap({
-            let pb = ProgressBar::new(v.len() as u64);
-            v.iter().progress_with(pb)
-        });
-        wrap({
-            let style = ProgressStyle::default_bar()
-                .template("{wide_bar:.red} {percent}/100%")
-                .unwrap();
-            v.iter().progress_with_style(style)
-        });
-    }
-}
diff --git a/vendor/indicatif/src/lib.rs b/vendor/indicatif/src/lib.rs
deleted file mode 100644
index 6902ef6..0000000
--- a/vendor/indicatif/src/lib.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-//! indicatif is a library for Rust that helps you build command line
-//! interfaces that report progress to users.  It comes with various
-//! tools and utilities for formatting anything that indicates progress.
-//!
-//! Platform support:
-//!
-//! * Linux
-//! * macOS
-//! * Windows (colors require Windows 10)
-//!
-//! Best paired with other libraries in the family:
-//!
-//! * [console](https://docs.rs/console)
-//! * [dialoguer](https://docs.rs/dialoguer)
-//!
-//! # Crate Contents
-//!
-//! * **Progress bars**
-//!   * [`ProgressBar`](struct.ProgressBar.html) for bars and spinners
-//!   * [`MultiProgress`](struct.MultiProgress.html) for multiple bars
-//! * **Data Formatting**
-//!   * [`HumanBytes`](struct.HumanBytes.html) for formatting bytes
-//!   * [`DecimalBytes`](struct.DecimalBytes.html) for formatting bytes using SI prefixes
-//!   * [`BinaryBytes`](struct.BinaryBytes.html) for formatting bytes using ISO/IEC prefixes
-//!   * [`HumanDuration`](struct.HumanDuration.html) for formatting durations
-//!   * [`HumanCount`](struct.HumanCount.html) for formatting large counts
-//!   * [`HumanFloatCount`](struct.HumanFloatCount.html) for formatting large float counts
-//!
-//! # Progress Bars and Spinners
-//!
-//! indicatif comes with a `ProgressBar` type that supports both bounded
-//! progress bar uses as well as unbounded "spinner" type progress reports.
-//! Progress bars are `Sync` and `Send` objects which means that they are
-//! internally locked and can be passed from thread to thread.
-//!
-//! Additionally a `MultiProgress` utility is provided that can manage
-//! rendering multiple progress bars at once (eg: from multiple threads).
-//!
-//! To whet your appetite, this is what this can look like:
-//!
-//! <img src="https://github.com/console-rs/indicatif/raw/main/screenshots/yarn.gif?raw=true" width="60%">
-//!
-//! Progress bars are manually advanced and by default draw to stderr.
-//! When you are done, the progress bar can be finished either visibly
-//! (eg: the progress bar stays on the screen) or cleared (the progress
-//! bar will be removed).
-//!
-//! ```rust
-//! use indicatif::ProgressBar;
-//!
-//! let bar = ProgressBar::new(1000);
-//! for _ in 0..1000 {
-//!     bar.inc(1);
-//!     // ...
-//! }
-//! bar.finish();
-//! ```
-//!
-//! General progress bar behaviors:
-//!
-//! * if a non terminal is detected the progress bar will be completely
-//!   hidden.  This makes piping programs to logfiles make sense out of
-//!   the box.
-//! * a progress bar only starts drawing when `set_message`, `inc`, `set_position`
-//!   or `tick` are called.  In some situations you might have to call `tick`
-//!   once to draw it.
-//! * progress bars should be explicitly finished to reset the rendering
-//!   for others.  Either by also clearing them or by replacing them with
-//!   a new message / retaining the current message.
-//! * the default template renders neither message nor prefix.
-//!
-//! # Iterators
-//!
-//! Similar to [tqdm](https://github.com/tqdm/tqdm), progress bars can be
-//! associated with an iterator. For example:
-//!
-//! ```rust
-//! use indicatif::ProgressIterator;
-//!
-//! for _ in (0..1000).progress() {
-//!     // ...
-//! }
-//! ```
-//!
-//! See the [`ProgressIterator`](trait.ProgressIterator.html) trait for more
-//! methods to configure the number of elements in the iterator or change
-//! the progress bar style. Indicatif also has optional support for parallel
-//! iterators with [Rayon](https://github.com/rayon-rs/rayon). In your
-//! `Cargo.toml`, use the "rayon" feature:
-//!
-//! ```toml
-//! [dependencies]
-//! indicatif = {version = "*", features = ["rayon"]}
-//! ```
-//!
-//! And then use it like this:
-//!
-//! ```rust,ignore
-//! # extern crate rayon;
-//! use indicatif::ParallelProgressIterator;
-//! use rayon::iter::{ParallelIterator, IntoParallelRefIterator};
-//!
-//! let v: Vec<_> = (0..100000).collect();
-//! let v2: Vec<_> = v.par_iter().progress_count(v.len() as u64).map(|i| i + 1).collect();
-//! assert_eq!(v2[0], 1);
-//! ```
-//!
-//! Or if you'd like to customize the progress bar:
-//!
-//! ```rust,ignore
-//! # extern crate rayon;
-//! use indicatif::{ProgressBar, ParallelProgressIterator, ProgressStyle};
-//! use rayon::iter::{ParallelIterator, IntoParallelRefIterator};
-//!
-//! // Alternatively, use `ProgressBar::new().with_style()`
-//! let style = ProgressStyle::default_bar();
-//! let v: Vec<_> = (0..100000).collect();
-//! let v2: Vec<_> = v.par_iter().progress_with_style(style).map(|i| i + 1).collect();
-//! assert_eq!(v2[0], 1);
-//! ```
-//!
-//! # Templates
-//!
-//! Progress bars can be styled with simple format strings similar to the
-//! ones in Rust itself.  The format for a placeholder is `{key:options}`
-//! where the `options` part is optional.  If provided the format is this:
-//!
-//! ```text
-//! <^>             for an optional alignment specification (left, center and right respectively)
-//! WIDTH           an optional width as positive integer
-//! !               an optional exclamation mark to enable truncation
-//! .STYLE          an optional dot separated style string
-//! /STYLE          an optional dot separated alternative style string
-//! ```
-//!
-//! For the style component see [`Style::from_dotted_str`](https://docs.rs/console/0.7.5/console/struct.Style.html#method.from_dotted_str)
-//! for more information.  Indicatif uses the `console` base crate for all
-//! colorization and formatting options.
-//!
-//! Some examples for templates:
-//!
-//! ```text
-//! [{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}
-//! ```
-//!
-//! This sets a progress bar that is 40 characters wide and has cyan
-//! as primary style color and blue as alternative style color.
-//! Alternative styles are currently only used for progress bars.
-//!
-//! Example configuration:
-//!
-//! ```rust
-//! # use indicatif::{ProgressBar, ProgressStyle};
-//! # let bar = ProgressBar::new(0);
-//! bar.set_style(ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")
-//!     .unwrap()
-//!     .progress_chars("##-"));
-//! ```
-//!
-//! The following keys exist:
-//!
-//! * `bar`: renders a progress bar. By default 20 characters wide.  The
-//!   style string is used to color the elapsed part, the alternative
-//!   style is used for the bar that is yet to render.
-//! * `wide_bar`: like `bar` but always fills the remaining space. It should not be used with
-//! `wide_msg`.
-//! * `spinner`: renders the spinner (current tick string).
-//! * `prefix`: renders the prefix set on the progress bar.
-//! * `msg`: renders the currently set message on the progress bar.
-//! * `wide_msg`: like `msg` but always fills the remaining space and truncates. It should not be used
-//! with `wide_bar`.
-//! * `pos`: renders the current position of the bar as integer
-//! * `human_pos`: renders the current position of the bar as an integer, with commas as the
-//! thousands separator.
-//! * `len`: renders the amount of work to be done as an integer
-//! * `human_len`: renders the total length of the bar as an integer, with commas as the thousands
-//! separator.
-//! * `bytes`: renders the current position of the bar as bytes.
-//! * `percent`: renders the current position of the bar as a percentage of the total length.
-//! * `total_bytes`: renders the total length of the bar as bytes.
-//! * `elapsed_precise`: renders the elapsed time as `HH:MM:SS`.
-//! * `elapsed`: renders the elapsed time as `42s`, `1m` etc.
-//! * `per_sec`: renders the speed in steps per second.
-//! * `bytes_per_sec`: renders the speed in bytes per second.
-//! * `binary_bytes_per_sec`: renders the speed in bytes per second using
-//!   power-of-two units, i.e. `MiB`, `KiB`, etc.
-//! * `eta_precise`: the remaining time (like `elapsed_precise`).
-//! * `eta`: the remaining time (like `elapsed`).
-//! * `duration_precise`: the extrapolated total duration (like `elapsed_precise`).
-//! * `duration`: the extrapolated total duration time (like `elapsed`).
-
-//!
-//! The design of the progress bar can be altered with the integrated
-//! template functionality.  The template can be set by changing a
-//! `ProgressStyle` and attaching it to the progress bar.
-//!
-//! # Human Readable Formatting
-//!
-//! There are some formatting wrappers for showing elapsed time and
-//! file sizes for human users:
-//!
-//! ```rust
-//! # use std::time::Duration;
-//! use indicatif::{HumanBytes, HumanCount, HumanDuration, HumanFloatCount};
-//!
-//! assert_eq!("3.00 MiB", HumanBytes(3*1024*1024).to_string());
-//! assert_eq!("8 seconds", HumanDuration(Duration::from_secs(8)).to_string());
-//! assert_eq!("33,857,009", HumanCount(33857009).to_string());
-//! assert_eq!("33,857,009.1235", HumanFloatCount(33857009.123456).to_string());
-//! ```
-//!
-//! # Feature Flags
-//!
-//! * `rayon`: adds rayon support
-//! * `improved_unicode`: adds improved unicode support (graphemes, better width calculation)
-
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![warn(unreachable_pub)]
-
-mod draw_target;
-mod format;
-#[cfg(feature = "in_memory")]
-mod in_memory;
-mod iter;
-mod multi;
-mod progress_bar;
-#[cfg(feature = "rayon")]
-mod rayon;
-mod state;
-pub mod style;
-mod term_like;
-
-pub use crate::draw_target::ProgressDrawTarget;
-pub use crate::format::{
-    BinaryBytes, DecimalBytes, FormattedDuration, HumanBytes, HumanCount, HumanDuration,
-    HumanFloatCount,
-};
-#[cfg(feature = "in_memory")]
-pub use crate::in_memory::InMemoryTerm;
-pub use crate::iter::{ProgressBarIter, ProgressIterator};
-pub use crate::multi::{MultiProgress, MultiProgressAlignment};
-pub use crate::progress_bar::{ProgressBar, WeakProgressBar};
-#[cfg(feature = "rayon")]
-pub use crate::rayon::ParallelProgressIterator;
-pub use crate::state::{ProgressFinish, ProgressState};
-pub use crate::style::ProgressStyle;
-pub use crate::term_like::TermLike;
diff --git a/vendor/indicatif/src/multi.rs b/vendor/indicatif/src/multi.rs
deleted file mode 100644
index 4409309..0000000
--- a/vendor/indicatif/src/multi.rs
+++ /dev/null
@@ -1,688 +0,0 @@
-use std::fmt::{Debug, Formatter};
-use std::io;
-use std::sync::{Arc, RwLock};
-use std::thread::panicking;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-
-use crate::draw_target::{DrawState, DrawStateWrapper, LineAdjust, ProgressDrawTarget};
-use crate::progress_bar::ProgressBar;
-#[cfg(target_arch = "wasm32")]
-use instant::Instant;
-
-/// Manages multiple progress bars from different threads
-#[derive(Debug, Clone)]
-pub struct MultiProgress {
-    pub(crate) state: Arc<RwLock<MultiState>>,
-}
-
-impl Default for MultiProgress {
-    fn default() -> Self {
-        Self::with_draw_target(ProgressDrawTarget::stderr())
-    }
-}
-
-impl MultiProgress {
-    /// Creates a new multi progress object.
-    ///
-    /// Progress bars added to this object by default draw directly to stderr, and refresh
-    /// a maximum of 15 times a second. To change the refresh rate set the draw target to
-    /// one with a different refresh rate.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Creates a new multi progress object with the given draw target.
-    pub fn with_draw_target(draw_target: ProgressDrawTarget) -> Self {
-        Self {
-            state: Arc::new(RwLock::new(MultiState::new(draw_target))),
-        }
-    }
-
-    /// Sets a different draw target for the multiprogress bar.
-    pub fn set_draw_target(&self, target: ProgressDrawTarget) {
-        let mut state = self.state.write().unwrap();
-        state.draw_target.disconnect(Instant::now());
-        state.draw_target = target;
-    }
-
-    /// Set whether we should try to move the cursor when possible instead of clearing lines.
-    ///
-    /// This can reduce flickering, but do not enable it if you intend to change the number of
-    /// progress bars.
-    pub fn set_move_cursor(&self, move_cursor: bool) {
-        self.state.write().unwrap().move_cursor = move_cursor;
-    }
-
-    /// Set alignment flag
-    pub fn set_alignment(&self, alignment: MultiProgressAlignment) {
-        self.state.write().unwrap().alignment = alignment;
-    }
-
-    /// Adds a progress bar.
-    ///
-    /// The progress bar added will have the draw target changed to a
-    /// remote draw target that is intercepted by the multi progress
-    /// object overriding custom `ProgressDrawTarget` settings.
-    ///
-    /// Adding a progress bar that is already a member of the `MultiProgress`
-    /// will have no effect.
-    pub fn add(&self, pb: ProgressBar) -> ProgressBar {
-        self.internalize(InsertLocation::End, pb)
-    }
-
-    /// Inserts a progress bar.
-    ///
-    /// The progress bar inserted at position `index` will have the draw
-    /// target changed to a remote draw target that is intercepted by the
-    /// multi progress object overriding custom `ProgressDrawTarget` settings.
-    ///
-    /// If `index >= MultiProgressState::objects.len()`, the progress bar
-    /// is added to the end of the list.
-    ///
-    /// Inserting a progress bar that is already a member of the `MultiProgress`
-    /// will have no effect.
-    pub fn insert(&self, index: usize, pb: ProgressBar) -> ProgressBar {
-        self.internalize(InsertLocation::Index(index), pb)
-    }
-
-    /// Inserts a progress bar from the back.
-    ///
-    /// The progress bar inserted at position `MultiProgressState::objects.len() - index`
-    /// will have the draw target changed to a remote draw target that is
-    /// intercepted by the multi progress object overriding custom
-    /// `ProgressDrawTarget` settings.
-    ///
-    /// If `index >= MultiProgressState::objects.len()`, the progress bar
-    /// is added to the start of the list.
-    ///
-    /// Inserting a progress bar that is already a member of the `MultiProgress`
-    /// will have no effect.
-    pub fn insert_from_back(&self, index: usize, pb: ProgressBar) -> ProgressBar {
-        self.internalize(InsertLocation::IndexFromBack(index), pb)
-    }
-
-    /// Inserts a progress bar before an existing one.
-    ///
-    /// The progress bar added will have the draw target changed to a
-    /// remote draw target that is intercepted by the multi progress
-    /// object overriding custom `ProgressDrawTarget` settings.
-    ///
-    /// Inserting a progress bar that is already a member of the `MultiProgress`
-    /// will have no effect.
-    pub fn insert_before(&self, before: &ProgressBar, pb: ProgressBar) -> ProgressBar {
-        self.internalize(InsertLocation::Before(before.index().unwrap()), pb)
-    }
-
-    /// Inserts a progress bar after an existing one.
-    ///
-    /// The progress bar added will have the draw target changed to a
-    /// remote draw target that is intercepted by the multi progress
-    /// object overriding custom `ProgressDrawTarget` settings.
-    ///
-    /// Inserting a progress bar that is already a member of the `MultiProgress`
-    /// will have no effect.
-    pub fn insert_after(&self, after: &ProgressBar, pb: ProgressBar) -> ProgressBar {
-        self.internalize(InsertLocation::After(after.index().unwrap()), pb)
-    }
-
-    /// Removes a progress bar.
-    ///
-    /// The progress bar is removed only if it was previously inserted or added
-    /// by the methods `MultiProgress::insert` or `MultiProgress::add`.
-    /// If the passed progress bar does not satisfy the condition above,
-    /// the `remove` method does nothing.
-    pub fn remove(&self, pb: &ProgressBar) {
-        let mut state = pb.state();
-        let idx = match &state.draw_target.remote() {
-            Some((state, idx)) => {
-                // Check that this progress bar is owned by the current MultiProgress.
-                assert!(Arc::ptr_eq(&self.state, state));
-                *idx
-            }
-            _ => return,
-        };
-
-        state.draw_target = ProgressDrawTarget::hidden();
-        self.state.write().unwrap().remove_idx(idx);
-    }
-
-    fn internalize(&self, location: InsertLocation, pb: ProgressBar) -> ProgressBar {
-        let mut state = self.state.write().unwrap();
-        let idx = state.insert(location);
-        drop(state);
-
-        pb.set_draw_target(ProgressDrawTarget::new_remote(self.state.clone(), idx));
-        pb
-    }
-
-    /// Print a log line above all progress bars in the [`MultiProgress`]
-    ///
-    /// If the draw target is hidden (e.g. when standard output is not a terminal), `println()`
-    /// will not do anything.
-    pub fn println<I: AsRef<str>>(&self, msg: I) -> io::Result<()> {
-        let mut state = self.state.write().unwrap();
-        state.println(msg, Instant::now())
-    }
-
-    /// Hide all progress bars temporarily, execute `f`, then redraw the [`MultiProgress`]
-    ///
-    /// Executes 'f' even if the draw target is hidden.
-    ///
-    /// Useful for external code that writes to the standard output.
-    ///
-    /// **Note:** The internal lock is held while `f` is executed. Other threads trying to print
-    /// anything on the progress bar will be blocked until `f` finishes.
-    /// Therefore, it is recommended to avoid long-running operations in `f`.
-    pub fn suspend<F: FnOnce() -> R, R>(&self, f: F) -> R {
-        let mut state = self.state.write().unwrap();
-        state.suspend(f, Instant::now())
-    }
-
-    pub fn clear(&self) -> io::Result<()> {
-        self.state.write().unwrap().clear(Instant::now())
-    }
-
-    pub fn is_hidden(&self) -> bool {
-        self.state.read().unwrap().is_hidden()
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct MultiState {
-    /// The collection of states corresponding to progress bars
-    members: Vec<MultiStateMember>,
-    /// Set of removed bars, should have corresponding members in the `members` vector with a
-    /// `draw_state` of `None`.
-    free_set: Vec<usize>,
-    /// Indices to the `draw_states` to maintain correct visual order
-    ordering: Vec<usize>,
-    /// Target for draw operation for MultiProgress
-    draw_target: ProgressDrawTarget,
-    /// Whether or not to just move cursor instead of clearing lines
-    move_cursor: bool,
-    /// Controls how the multi progress is aligned if some of its progress bars get removed, default is `Top`
-    alignment: MultiProgressAlignment,
-    /// Lines to be drawn above everything else in the MultiProgress. These specifically come from
-    /// calling `ProgressBar::println` on a pb that is connected to a `MultiProgress`.
-    orphan_lines: Vec<String>,
-    /// The count of currently visible zombie lines.
-    zombie_lines_count: usize,
-}
-
-impl MultiState {
-    fn new(draw_target: ProgressDrawTarget) -> Self {
-        Self {
-            members: vec![],
-            free_set: vec![],
-            ordering: vec![],
-            draw_target,
-            move_cursor: false,
-            alignment: MultiProgressAlignment::default(),
-            orphan_lines: Vec::new(),
-            zombie_lines_count: 0,
-        }
-    }
-
-    pub(crate) fn mark_zombie(&mut self, index: usize) {
-        let member = &mut self.members[index];
-
-        // If the zombie is the first visual bar then we can reap it right now instead of
-        // deferring it to the next draw.
-        if index != self.ordering.first().copied().unwrap() {
-            member.is_zombie = true;
-            return;
-        }
-
-        let line_count = member
-            .draw_state
-            .as_ref()
-            .map(|d| d.lines.len())
-            .unwrap_or_default();
-
-        // Track the total number of zombie lines on the screen
-        self.zombie_lines_count = self.zombie_lines_count.saturating_add(line_count);
-
-        // Make `DrawTarget` forget about the zombie lines so that they aren't cleared on next draw.
-        self.draw_target
-            .adjust_last_line_count(LineAdjust::Keep(line_count));
-
-        self.remove_idx(index);
-    }
-
-    pub(crate) fn draw(
-        &mut self,
-        mut force_draw: bool,
-        extra_lines: Option<Vec<String>>,
-        now: Instant,
-    ) -> io::Result<()> {
-        if panicking() {
-            return Ok(());
-        }
-        let width = self.width() as f64;
-        // Calculate real length based on terminal width
-        // This take in account linewrap from terminal
-        fn real_len(lines: &[String], width: f64) -> usize {
-            lines.iter().fold(0, |sum, val| {
-                sum + (console::measure_text_width(val) as f64 / width).ceil() as usize
-            })
-        }
-
-        // Assumption: if extra_lines is not None, then it has at least one line
-        debug_assert_eq!(
-            extra_lines.is_some(),
-            extra_lines.as_ref().map(Vec::len).unwrap_or_default() > 0
-        );
-
-        let mut reap_indices = vec![];
-
-        // Reap all consecutive 'zombie' progress bars from head of the list.
-        let mut adjust = 0;
-        for &index in &self.ordering {
-            let member = &self.members[index];
-            if !member.is_zombie {
-                break;
-            }
-
-            let line_count = member
-                .draw_state
-                .as_ref()
-                .map(|d| real_len(&d.lines, width))
-                .unwrap_or_default();
-            // Track the total number of zombie lines on the screen.
-            self.zombie_lines_count += line_count;
-
-            // Track the number of zombie lines that will be drawn by this call to draw.
-            adjust += line_count;
-
-            reap_indices.push(index);
-        }
-
-        // If this draw is due to a `println`, then we need to erase all the zombie lines.
-        // This is because `println` is supposed to appear above all other elements in the
-        // `MultiProgress`.
-        if extra_lines.is_some() {
-            self.draw_target
-                .adjust_last_line_count(LineAdjust::Clear(self.zombie_lines_count));
-            self.zombie_lines_count = 0;
-        }
-
-        let orphan_lines_count = real_len(&self.orphan_lines, width);
-        force_draw |= orphan_lines_count > 0;
-        let mut drawable = match self.draw_target.drawable(force_draw, now) {
-            Some(drawable) => drawable,
-            None => return Ok(()),
-        };
-
-        let mut draw_state = drawable.state();
-        draw_state.orphan_lines_count = orphan_lines_count;
-        draw_state.alignment = self.alignment;
-
-        if let Some(extra_lines) = &extra_lines {
-            draw_state.lines.extend_from_slice(extra_lines.as_slice());
-            draw_state.orphan_lines_count += real_len(extra_lines, width);
-        }
-
-        // Add lines from `ProgressBar::println` call.
-        draw_state.lines.append(&mut self.orphan_lines);
-
-        for index in &self.ordering {
-            let member = &self.members[*index];
-            if let Some(state) = &member.draw_state {
-                draw_state.lines.extend_from_slice(&state.lines[..]);
-            }
-        }
-
-        drop(draw_state);
-        let drawable = drawable.draw();
-
-        for index in reap_indices {
-            self.remove_idx(index);
-        }
-
-        // The zombie lines were drawn for the last time, so make `DrawTarget` forget about them
-        // so they aren't cleared on next draw.
-        if extra_lines.is_none() {
-            self.draw_target
-                .adjust_last_line_count(LineAdjust::Keep(adjust));
-        }
-
-        drawable
-    }
-
-    pub(crate) fn println<I: AsRef<str>>(&mut self, msg: I, now: Instant) -> io::Result<()> {
-        let msg = msg.as_ref();
-
-        // If msg is "", make sure a line is still printed
-        let lines: Vec<String> = match msg.is_empty() {
-            false => msg.lines().map(Into::into).collect(),
-            true => vec![String::new()],
-        };
-
-        self.draw(true, Some(lines), now)
-    }
-
-    pub(crate) fn draw_state(&mut self, idx: usize) -> DrawStateWrapper<'_> {
-        let member = self.members.get_mut(idx).unwrap();
-        // alignment is handled by the `MultiProgress`'s underlying draw target, so there is no
-        // point in propagating it here.
-        let state = member.draw_state.get_or_insert(DrawState {
-            move_cursor: self.move_cursor,
-            ..Default::default()
-        });
-
-        DrawStateWrapper::for_multi(state, &mut self.orphan_lines)
-    }
-
-    pub(crate) fn is_hidden(&self) -> bool {
-        self.draw_target.is_hidden()
-    }
-
-    pub(crate) fn suspend<F: FnOnce() -> R, R>(&mut self, f: F, now: Instant) -> R {
-        self.clear(now).unwrap();
-        let ret = f();
-        self.draw(true, None, Instant::now()).unwrap();
-        ret
-    }
-
-    pub(crate) fn width(&self) -> u16 {
-        self.draw_target.width()
-    }
-
-    fn insert(&mut self, location: InsertLocation) -> usize {
-        let idx = if let Some(idx) = self.free_set.pop() {
-            self.members[idx] = MultiStateMember::default();
-            idx
-        } else {
-            self.members.push(MultiStateMember::default());
-            self.members.len() - 1
-        };
-
-        match location {
-            InsertLocation::End => self.ordering.push(idx),
-            InsertLocation::Index(pos) => {
-                let pos = Ord::min(pos, self.ordering.len());
-                self.ordering.insert(pos, idx);
-            }
-            InsertLocation::IndexFromBack(pos) => {
-                let pos = self.ordering.len().saturating_sub(pos);
-                self.ordering.insert(pos, idx);
-            }
-            InsertLocation::After(after_idx) => {
-                let pos = self.ordering.iter().position(|i| *i == after_idx).unwrap();
-                self.ordering.insert(pos + 1, idx);
-            }
-            InsertLocation::Before(before_idx) => {
-                let pos = self.ordering.iter().position(|i| *i == before_idx).unwrap();
-                self.ordering.insert(pos, idx);
-            }
-        }
-
-        assert_eq!(
-            self.len(),
-            self.ordering.len(),
-            "Draw state is inconsistent"
-        );
-
-        idx
-    }
-
-    fn clear(&mut self, now: Instant) -> io::Result<()> {
-        match self.draw_target.drawable(true, now) {
-            Some(mut drawable) => {
-                // Make the clear operation also wipe out zombie lines
-                drawable.adjust_last_line_count(LineAdjust::Clear(self.zombie_lines_count));
-                self.zombie_lines_count = 0;
-                drawable.clear()
-            }
-            None => Ok(()),
-        }
-    }
-
-    fn remove_idx(&mut self, idx: usize) {
-        if self.free_set.contains(&idx) {
-            return;
-        }
-
-        self.members[idx] = MultiStateMember::default();
-        self.free_set.push(idx);
-        self.ordering.retain(|&x| x != idx);
-
-        assert_eq!(
-            self.len(),
-            self.ordering.len(),
-            "Draw state is inconsistent"
-        );
-    }
-
-    fn len(&self) -> usize {
-        self.members.len() - self.free_set.len()
-    }
-}
-
-#[derive(Default)]
-struct MultiStateMember {
-    /// Draw state will be `None` for members that haven't been drawn before, or for entries that
-    /// correspond to something in the free set.
-    draw_state: Option<DrawState>,
-    /// Whether the corresponding progress bar (more precisely, `BarState`) has been dropped.
-    is_zombie: bool,
-}
-
-impl Debug for MultiStateMember {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("MultiStateElement")
-            .field("draw_state", &self.draw_state)
-            .field("is_zombie", &self.is_zombie)
-            .finish_non_exhaustive()
-    }
-}
-
-/// Vertical alignment of a multi progress.
-///
-/// The alignment controls how the multi progress is aligned if some of its progress bars get removed.
-/// E.g. `Top` alignment (default), when _progress bar 2_ is removed:
-/// ```ignore
-/// [0/100] progress bar 1        [0/100] progress bar 1
-/// [0/100] progress bar 2   =>   [0/100] progress bar 3
-/// [0/100] progress bar 3
-/// ```
-///
-/// `Bottom` alignment
-/// ```ignore
-/// [0/100] progress bar 1
-/// [0/100] progress bar 2   =>   [0/100] progress bar 1
-/// [0/100] progress bar 3        [0/100] progress bar 3
-/// ```
-#[derive(Debug, Copy, Clone)]
-pub enum MultiProgressAlignment {
-    Top,
-    Bottom,
-}
-
-impl Default for MultiProgressAlignment {
-    fn default() -> Self {
-        Self::Top
-    }
-}
-
-enum InsertLocation {
-    End,
-    Index(usize),
-    IndexFromBack(usize),
-    After(usize),
-    Before(usize),
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{MultiProgress, ProgressBar, ProgressDrawTarget};
-
-    #[test]
-    fn late_pb_drop() {
-        let pb = ProgressBar::new(10);
-        let mpb = MultiProgress::new();
-        // This clone call is required to trigger a now fixed bug.
-        // See <https://github.com/console-rs/indicatif/pull/141> for context
-        #[allow(clippy::redundant_clone)]
-        mpb.add(pb.clone());
-    }
-
-    #[test]
-    fn progress_bar_sync_send() {
-        let _: Box<dyn Sync> = Box::new(ProgressBar::new(1));
-        let _: Box<dyn Send> = Box::new(ProgressBar::new(1));
-        let _: Box<dyn Sync> = Box::new(MultiProgress::new());
-        let _: Box<dyn Send> = Box::new(MultiProgress::new());
-    }
-
-    #[test]
-    fn multi_progress_hidden() {
-        let mpb = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
-        let pb = mpb.add(ProgressBar::new(123));
-        pb.finish();
-    }
-
-    #[test]
-    fn multi_progress_modifications() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        let p2 = mp.add(ProgressBar::new(1));
-        let p3 = mp.add(ProgressBar::new(1));
-        mp.remove(&p2);
-        mp.remove(&p1);
-        let p4 = mp.insert(1, ProgressBar::new(1));
-
-        let state = mp.state.read().unwrap();
-        // the removed place for p1 is reused
-        assert_eq!(state.members.len(), 4);
-        assert_eq!(state.len(), 3);
-
-        // free_set may contain 1 or 2
-        match state.free_set.last() {
-            Some(1) => {
-                assert_eq!(state.ordering, vec![0, 2, 3]);
-                assert!(state.members[1].draw_state.is_none());
-                assert_eq!(p4.index().unwrap(), 2);
-            }
-            Some(2) => {
-                assert_eq!(state.ordering, vec![0, 1, 3]);
-                assert!(state.members[2].draw_state.is_none());
-                assert_eq!(p4.index().unwrap(), 1);
-            }
-            _ => unreachable!(),
-        }
-
-        assert_eq!(p0.index().unwrap(), 0);
-        assert_eq!(p1.index(), None);
-        assert_eq!(p2.index(), None);
-        assert_eq!(p3.index().unwrap(), 3);
-    }
-
-    #[test]
-    fn multi_progress_insert_from_back() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        let p2 = mp.add(ProgressBar::new(1));
-        let p3 = mp.insert_from_back(1, ProgressBar::new(1));
-        let p4 = mp.insert_from_back(10, ProgressBar::new(1));
-
-        let state = mp.state.read().unwrap();
-        assert_eq!(state.ordering, vec![4, 0, 1, 3, 2]);
-        assert_eq!(p0.index().unwrap(), 0);
-        assert_eq!(p1.index().unwrap(), 1);
-        assert_eq!(p2.index().unwrap(), 2);
-        assert_eq!(p3.index().unwrap(), 3);
-        assert_eq!(p4.index().unwrap(), 4);
-    }
-
-    #[test]
-    fn multi_progress_insert_after() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        let p2 = mp.add(ProgressBar::new(1));
-        let p3 = mp.insert_after(&p2, ProgressBar::new(1));
-        let p4 = mp.insert_after(&p0, ProgressBar::new(1));
-
-        let state = mp.state.read().unwrap();
-        assert_eq!(state.ordering, vec![0, 4, 1, 2, 3]);
-        assert_eq!(p0.index().unwrap(), 0);
-        assert_eq!(p1.index().unwrap(), 1);
-        assert_eq!(p2.index().unwrap(), 2);
-        assert_eq!(p3.index().unwrap(), 3);
-        assert_eq!(p4.index().unwrap(), 4);
-    }
-
-    #[test]
-    fn multi_progress_insert_before() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        let p2 = mp.add(ProgressBar::new(1));
-        let p3 = mp.insert_before(&p0, ProgressBar::new(1));
-        let p4 = mp.insert_before(&p2, ProgressBar::new(1));
-
-        let state = mp.state.read().unwrap();
-        assert_eq!(state.ordering, vec![3, 0, 1, 4, 2]);
-        assert_eq!(p0.index().unwrap(), 0);
-        assert_eq!(p1.index().unwrap(), 1);
-        assert_eq!(p2.index().unwrap(), 2);
-        assert_eq!(p3.index().unwrap(), 3);
-        assert_eq!(p4.index().unwrap(), 4);
-    }
-
-    #[test]
-    fn multi_progress_insert_before_and_after() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        let p2 = mp.add(ProgressBar::new(1));
-        let p3 = mp.insert_before(&p0, ProgressBar::new(1));
-        let p4 = mp.insert_after(&p3, ProgressBar::new(1));
-        let p5 = mp.insert_after(&p3, ProgressBar::new(1));
-        let p6 = mp.insert_before(&p1, ProgressBar::new(1));
-
-        let state = mp.state.read().unwrap();
-        assert_eq!(state.ordering, vec![3, 5, 4, 0, 6, 1, 2]);
-        assert_eq!(p0.index().unwrap(), 0);
-        assert_eq!(p1.index().unwrap(), 1);
-        assert_eq!(p2.index().unwrap(), 2);
-        assert_eq!(p3.index().unwrap(), 3);
-        assert_eq!(p4.index().unwrap(), 4);
-        assert_eq!(p5.index().unwrap(), 5);
-        assert_eq!(p6.index().unwrap(), 6);
-    }
-
-    #[test]
-    fn multi_progress_multiple_remove() {
-        let mp = MultiProgress::new();
-        let p0 = mp.add(ProgressBar::new(1));
-        let p1 = mp.add(ProgressBar::new(1));
-        // double remove beyond the first one have no effect
-        mp.remove(&p0);
-        mp.remove(&p0);
-        mp.remove(&p0);
-
-        let state = mp.state.read().unwrap();
-        // the removed place for p1 is reused
-        assert_eq!(state.members.len(), 2);
-        assert_eq!(state.free_set.len(), 1);
-        assert_eq!(state.len(), 1);
-        assert!(state.members[0].draw_state.is_none());
-        assert_eq!(state.free_set.last(), Some(&0));
-
-        assert_eq!(state.ordering, vec![1]);
-        assert_eq!(p0.index(), None);
-        assert_eq!(p1.index().unwrap(), 1);
-    }
-
-    #[test]
-    fn mp_no_crash_double_add() {
-        let mp = MultiProgress::new();
-        let pb = mp.add(ProgressBar::new(10));
-        mp.add(pb);
-    }
-}
diff --git a/vendor/indicatif/src/progress_bar.rs b/vendor/indicatif/src/progress_bar.rs
deleted file mode 100644
index 938668e..0000000
--- a/vendor/indicatif/src/progress_bar.rs
+++ /dev/null
@@ -1,808 +0,0 @@
-#[cfg(test)]
-use portable_atomic::{AtomicBool, Ordering};
-use std::borrow::Cow;
-use std::sync::{Arc, Condvar, Mutex, MutexGuard, Weak};
-use std::time::Duration;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-use std::{fmt, io, thread};
-
-#[cfg(target_arch = "wasm32")]
-use instant::Instant;
-#[cfg(test)]
-use once_cell::sync::Lazy;
-
-use crate::draw_target::ProgressDrawTarget;
-use crate::state::{AtomicPosition, BarState, ProgressFinish, Reset, TabExpandedString};
-use crate::style::ProgressStyle;
-use crate::{ProgressBarIter, ProgressIterator, ProgressState};
-
-/// A progress bar or spinner
-///
-/// The progress bar is an [`Arc`] around its internal state. When the progress bar is cloned it
-/// just increments the refcount (so the original and its clone share the same state).
-#[derive(Clone)]
-pub struct ProgressBar {
-    state: Arc<Mutex<BarState>>,
-    pos: Arc<AtomicPosition>,
-    ticker: Arc<Mutex<Option<Ticker>>>,
-}
-
-impl fmt::Debug for ProgressBar {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ProgressBar").finish()
-    }
-}
-
-impl ProgressBar {
-    /// Creates a new progress bar with a given length
-    ///
-    /// This progress bar by default draws directly to stderr, and refreshes a maximum of 15 times
-    /// a second. To change the refresh rate, set the draw target to one with a different refresh
-    /// rate.
-    pub fn new(len: u64) -> Self {
-        Self::with_draw_target(Some(len), ProgressDrawTarget::stderr())
-    }
-
-    /// Creates a completely hidden progress bar
-    ///
-    /// This progress bar still responds to API changes but it does not have a length or render in
-    /// any way.
-    pub fn hidden() -> Self {
-        Self::with_draw_target(None, ProgressDrawTarget::hidden())
-    }
-
-    /// Creates a new progress bar with a given length and draw target
-    pub fn with_draw_target(len: Option<u64>, draw_target: ProgressDrawTarget) -> Self {
-        let pos = Arc::new(AtomicPosition::new());
-        Self {
-            state: Arc::new(Mutex::new(BarState::new(len, draw_target, pos.clone()))),
-            pos,
-            ticker: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    /// Get a clone of the current progress bar style.
-    pub fn style(&self) -> ProgressStyle {
-        self.state().style.clone()
-    }
-
-    /// A convenience builder-like function for a progress bar with a given style
-    pub fn with_style(self, style: ProgressStyle) -> Self {
-        self.set_style(style);
-        self
-    }
-
-    /// A convenience builder-like function for a progress bar with a given tab width
-    pub fn with_tab_width(self, tab_width: usize) -> Self {
-        self.state().set_tab_width(tab_width);
-        self
-    }
-
-    /// A convenience builder-like function for a progress bar with a given prefix
-    ///
-    /// For the prefix to be visible, the `{prefix}` placeholder must be present in the template
-    /// (see [`ProgressStyle`]).
-    pub fn with_prefix(self, prefix: impl Into<Cow<'static, str>>) -> Self {
-        let mut state = self.state();
-        state.state.prefix = TabExpandedString::new(prefix.into(), state.tab_width);
-        drop(state);
-        self
-    }
-
-    /// A convenience builder-like function for a progress bar with a given message
-    ///
-    /// For the message to be visible, the `{msg}` placeholder must be present in the template (see
-    /// [`ProgressStyle`]).
-    pub fn with_message(self, message: impl Into<Cow<'static, str>>) -> Self {
-        let mut state = self.state();
-        state.state.message = TabExpandedString::new(message.into(), state.tab_width);
-        drop(state);
-        self
-    }
-
-    /// A convenience builder-like function for a progress bar with a given position
-    pub fn with_position(self, pos: u64) -> Self {
-        self.state().state.set_pos(pos);
-        self
-    }
-
-    /// A convenience builder-like function for a progress bar with a given elapsed time
-    pub fn with_elapsed(self, elapsed: Duration) -> Self {
-        self.state().state.started = Instant::now().checked_sub(elapsed).unwrap();
-        self
-    }
-
-    /// Sets the finish behavior for the progress bar
-    ///
-    /// This behavior is invoked when [`ProgressBar`] or
-    /// [`ProgressBarIter`] completes and
-    /// [`ProgressBar::is_finished()`] is false.
-    /// If you don't want the progress bar to be automatically finished then
-    /// call `on_finish(None)`.
-    ///
-    /// [`ProgressBar`]: crate::ProgressBar
-    /// [`ProgressBarIter`]: crate::ProgressBarIter
-    /// [`ProgressBar::is_finished()`]: crate::ProgressBar::is_finished
-    pub fn with_finish(self, finish: ProgressFinish) -> Self {
-        self.state().on_finish = finish;
-        self
-    }
-
-    /// Creates a new spinner
-    ///
-    /// This spinner by default draws directly to stderr. This adds the default spinner style to it.
-    pub fn new_spinner() -> Self {
-        let rv = Self::with_draw_target(None, ProgressDrawTarget::stderr());
-        rv.set_style(ProgressStyle::default_spinner());
-        rv
-    }
-
-    /// Overrides the stored style
-    ///
-    /// This does not redraw the bar. Call [`ProgressBar::tick()`] to force it.
-    pub fn set_style(&self, style: ProgressStyle) {
-        self.state().set_style(style);
-    }
-
-    /// Sets the tab width (default: 8). All tabs will be expanded to this many spaces.
-    pub fn set_tab_width(&mut self, tab_width: usize) {
-        let mut state = self.state();
-        state.set_tab_width(tab_width);
-        state.draw(true, Instant::now()).unwrap();
-    }
-
-    /// Spawns a background thread to tick the progress bar
-    ///
-    /// When this is enabled a background thread will regularly tick the progress bar in the given
-    /// interval. This is useful to advance progress bars that are very slow by themselves.
-    ///
-    /// When steady ticks are enabled, calling [`ProgressBar::tick()`] on a progress bar does not
-    /// have any effect.
-    pub fn enable_steady_tick(&self, interval: Duration) {
-        // The way we test for ticker termination is with a single static `AtomicBool`. Since cargo
-        // runs tests concurrently, we have a `TICKER_TEST` lock to make sure tests using ticker
-        // don't step on each other. This check catches attempts to use tickers in tests without
-        // acquiring the lock.
-        #[cfg(test)]
-        {
-            let guard = TICKER_TEST.try_lock();
-            let lock_acquired = guard.is_ok();
-            // Drop the guard before panicking to avoid poisoning the lock (which would cause other
-            // ticker tests to fail)
-            drop(guard);
-            if lock_acquired {
-                panic!("you must acquire the TICKER_TEST lock in your test to use this method");
-            }
-        }
-
-        if interval.is_zero() {
-            return;
-        }
-
-        self.stop_and_replace_ticker(Some(interval));
-    }
-
-    /// Undoes [`ProgressBar::enable_steady_tick()`]
-    pub fn disable_steady_tick(&self) {
-        self.stop_and_replace_ticker(None);
-    }
-
-    fn stop_and_replace_ticker(&self, interval: Option<Duration>) {
-        let mut ticker_state = self.ticker.lock().unwrap();
-        if let Some(ticker) = ticker_state.take() {
-            ticker.stop();
-        }
-
-        *ticker_state = interval.map(|interval| Ticker::new(interval, &self.state));
-    }
-
-    /// Manually ticks the spinner or progress bar
-    ///
-    /// This automatically happens on any other change to a progress bar.
-    pub fn tick(&self) {
-        self.tick_inner(Instant::now());
-    }
-
-    fn tick_inner(&self, now: Instant) {
-        // Only tick if a `Ticker` isn't installed
-        if self.ticker.lock().unwrap().is_none() {
-            self.state().tick(now);
-        }
-    }
-
-    /// Advances the position of the progress bar by `delta`
-    pub fn inc(&self, delta: u64) {
-        self.pos.inc(delta);
-        let now = Instant::now();
-        if self.pos.allow(now) {
-            self.tick_inner(now);
-        }
-    }
-
-    /// A quick convenience check if the progress bar is hidden
-    pub fn is_hidden(&self) -> bool {
-        self.state().draw_target.is_hidden()
-    }
-
-    /// Indicates that the progress bar finished
-    pub fn is_finished(&self) -> bool {
-        self.state().state.is_finished()
-    }
-
-    /// Print a log line above the progress bar
-    ///
-    /// If the progress bar is hidden (e.g. when standard output is not a terminal), `println()`
-    /// will not do anything. If you want to write to the standard output in such cases as well, use
-    /// [`suspend`] instead.
-    ///
-    /// If the progress bar was added to a [`MultiProgress`], the log line will be
-    /// printed above all other progress bars.
-    ///
-    /// [`suspend`]: ProgressBar::suspend
-    /// [`MultiProgress`]: crate::MultiProgress
-    pub fn println<I: AsRef<str>>(&self, msg: I) {
-        self.state().println(Instant::now(), msg.as_ref());
-    }
-
-    /// Update the `ProgressBar`'s inner [`ProgressState`]
-    pub fn update(&self, f: impl FnOnce(&mut ProgressState)) {
-        self.state()
-            .update(Instant::now(), f, self.ticker.lock().unwrap().is_none());
-    }
-
-    /// Sets the position of the progress bar
-    pub fn set_position(&self, pos: u64) {
-        self.pos.set(pos);
-        let now = Instant::now();
-        if self.pos.allow(now) {
-            self.tick_inner(now);
-        }
-    }
-
-    /// Sets the length of the progress bar
-    pub fn set_length(&self, len: u64) {
-        self.state().set_length(Instant::now(), len);
-    }
-
-    /// Increase the length of the progress bar
-    pub fn inc_length(&self, delta: u64) {
-        self.state().inc_length(Instant::now(), delta);
-    }
-
-    /// Sets the current prefix of the progress bar
-    ///
-    /// For the prefix to be visible, the `{prefix}` placeholder must be present in the template
-    /// (see [`ProgressStyle`]).
-    pub fn set_prefix(&self, prefix: impl Into<Cow<'static, str>>) {
-        let mut state = self.state();
-        state.state.prefix = TabExpandedString::new(prefix.into(), state.tab_width);
-        state.update_estimate_and_draw(Instant::now());
-    }
-
-    /// Sets the current message of the progress bar
-    ///
-    /// For the message to be visible, the `{msg}` placeholder must be present in the template (see
-    /// [`ProgressStyle`]).
-    pub fn set_message(&self, msg: impl Into<Cow<'static, str>>) {
-        let mut state = self.state();
-        state.state.message = TabExpandedString::new(msg.into(), state.tab_width);
-        state.update_estimate_and_draw(Instant::now());
-    }
-
-    /// Creates a new weak reference to this `ProgressBar`
-    pub fn downgrade(&self) -> WeakProgressBar {
-        WeakProgressBar {
-            state: Arc::downgrade(&self.state),
-            pos: Arc::downgrade(&self.pos),
-            ticker: Arc::downgrade(&self.ticker),
-        }
-    }
-
-    /// Resets the ETA calculation
-    ///
-    /// This can be useful if the progress bars made a large jump or was paused for a prolonged
-    /// time.
-    pub fn reset_eta(&self) {
-        self.state().reset(Instant::now(), Reset::Eta);
-    }
-
-    /// Resets elapsed time and the ETA calculation
-    pub fn reset_elapsed(&self) {
-        self.state().reset(Instant::now(), Reset::Elapsed);
-    }
-
-    /// Resets all of the progress bar state
-    pub fn reset(&self) {
-        self.state().reset(Instant::now(), Reset::All);
-    }
-
-    /// Finishes the progress bar and leaves the current message
-    pub fn finish(&self) {
-        self.state()
-            .finish_using_style(Instant::now(), ProgressFinish::AndLeave);
-    }
-
-    /// Finishes the progress bar and sets a message
-    ///
-    /// For the message to be visible, the `{msg}` placeholder must be present in the template (see
-    /// [`ProgressStyle`]).
-    pub fn finish_with_message(&self, msg: impl Into<Cow<'static, str>>) {
-        self.state()
-            .finish_using_style(Instant::now(), ProgressFinish::WithMessage(msg.into()));
-    }
-
-    /// Finishes the progress bar and completely clears it
-    pub fn finish_and_clear(&self) {
-        self.state()
-            .finish_using_style(Instant::now(), ProgressFinish::AndClear);
-    }
-
-    /// Finishes the progress bar and leaves the current message and progress
-    pub fn abandon(&self) {
-        self.state()
-            .finish_using_style(Instant::now(), ProgressFinish::Abandon);
-    }
-
-    /// Finishes the progress bar and sets a message, and leaves the current progress
-    ///
-    /// For the message to be visible, the `{msg}` placeholder must be present in the template (see
-    /// [`ProgressStyle`]).
-    pub fn abandon_with_message(&self, msg: impl Into<Cow<'static, str>>) {
-        self.state().finish_using_style(
-            Instant::now(),
-            ProgressFinish::AbandonWithMessage(msg.into()),
-        );
-    }
-
-    /// Finishes the progress bar using the behavior stored in the [`ProgressStyle`]
-    ///
-    /// See [`ProgressBar::with_finish()`].
-    pub fn finish_using_style(&self) {
-        let mut state = self.state();
-        let finish = state.on_finish.clone();
-        state.finish_using_style(Instant::now(), finish);
-    }
-
-    /// Sets a different draw target for the progress bar
-    ///
-    /// This can be used to draw the progress bar to stderr (this is the default):
-    ///
-    /// ```rust,no_run
-    /// # use indicatif::{ProgressBar, ProgressDrawTarget};
-    /// let pb = ProgressBar::new(100);
-    /// pb.set_draw_target(ProgressDrawTarget::stderr());
-    /// ```
-    ///
-    /// **Note:** Calling this method on a [`ProgressBar`] linked with a [`MultiProgress`] (after
-    /// running [`MultiProgress::add`]) will unlink this progress bar. If you don't want this
-    /// behavior, call [`MultiProgress::set_draw_target`] instead.
-    ///
-    /// [`MultiProgress`]: crate::MultiProgress
-    /// [`MultiProgress::add`]: crate::MultiProgress::add
-    /// [`MultiProgress::set_draw_target`]: crate::MultiProgress::set_draw_target
-    pub fn set_draw_target(&self, target: ProgressDrawTarget) {
-        let mut state = self.state();
-        state.draw_target.disconnect(Instant::now());
-        state.draw_target = target;
-    }
-
-    /// Hide the progress bar temporarily, execute `f`, then redraw the progress bar
-    ///
-    /// Useful for external code that writes to the standard output.
-    ///
-    /// If the progress bar was added to a MultiProgress, it will suspend the entire MultiProgress
-    ///
-    /// **Note:** The internal lock is held while `f` is executed. Other threads trying to print
-    /// anything on the progress bar will be blocked until `f` finishes.
-    /// Therefore, it is recommended to avoid long-running operations in `f`.
-    ///
-    /// ```rust,no_run
-    /// # use indicatif::ProgressBar;
-    /// let mut pb = ProgressBar::new(3);
-    /// pb.suspend(|| {
-    ///     println!("Log message");
-    /// })
-    /// ```
-    pub fn suspend<F: FnOnce() -> R, R>(&self, f: F) -> R {
-        self.state().suspend(Instant::now(), f)
-    }
-
-    /// Wraps an [`Iterator`] with the progress bar
-    ///
-    /// ```rust,no_run
-    /// # use indicatif::ProgressBar;
-    /// let v = vec![1, 2, 3];
-    /// let pb = ProgressBar::new(3);
-    /// for item in pb.wrap_iter(v.iter()) {
-    ///     // ...
-    /// }
-    /// ```
-    pub fn wrap_iter<It: Iterator>(&self, it: It) -> ProgressBarIter<It> {
-        it.progress_with(self.clone())
-    }
-
-    /// Wraps an [`io::Read`] with the progress bar
-    ///
-    /// ```rust,no_run
-    /// # use std::fs::File;
-    /// # use std::io;
-    /// # use indicatif::ProgressBar;
-    /// # fn test () -> io::Result<()> {
-    /// let source = File::open("work.txt")?;
-    /// let mut target = File::create("done.txt")?;
-    /// let pb = ProgressBar::new(source.metadata()?.len());
-    /// io::copy(&mut pb.wrap_read(source), &mut target);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn wrap_read<R: io::Read>(&self, read: R) -> ProgressBarIter<R> {
-        ProgressBarIter {
-            progress: self.clone(),
-            it: read,
-        }
-    }
-
-    /// Wraps an [`io::Write`] with the progress bar
-    ///
-    /// ```rust,no_run
-    /// # use std::fs::File;
-    /// # use std::io;
-    /// # use indicatif::ProgressBar;
-    /// # fn test () -> io::Result<()> {
-    /// let mut source = File::open("work.txt")?;
-    /// let target = File::create("done.txt")?;
-    /// let pb = ProgressBar::new(source.metadata()?.len());
-    /// io::copy(&mut source, &mut pb.wrap_write(target));
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn wrap_write<W: io::Write>(&self, write: W) -> ProgressBarIter<W> {
-        ProgressBarIter {
-            progress: self.clone(),
-            it: write,
-        }
-    }
-
-    #[cfg(feature = "tokio")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-    /// Wraps an [`tokio::io::AsyncWrite`] with the progress bar
-    ///
-    /// ```rust,no_run
-    /// # use tokio::fs::File;
-    /// # use tokio::io;
-    /// # use indicatif::ProgressBar;
-    /// # async fn test() -> io::Result<()> {
-    /// let mut source = File::open("work.txt").await?;
-    /// let mut target = File::open("done.txt").await?;
-    /// let pb = ProgressBar::new(source.metadata().await?.len());
-    /// io::copy(&mut source, &mut pb.wrap_async_write(target)).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn wrap_async_write<W: tokio::io::AsyncWrite + Unpin>(
-        &self,
-        write: W,
-    ) -> ProgressBarIter<W> {
-        ProgressBarIter {
-            progress: self.clone(),
-            it: write,
-        }
-    }
-
-    #[cfg(feature = "tokio")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-    /// Wraps an [`tokio::io::AsyncRead`] with the progress bar
-    ///
-    /// ```rust,no_run
-    /// # use tokio::fs::File;
-    /// # use tokio::io;
-    /// # use indicatif::ProgressBar;
-    /// # async fn test() -> io::Result<()> {
-    /// let mut source = File::open("work.txt").await?;
-    /// let mut target = File::open("done.txt").await?;
-    /// let pb = ProgressBar::new(source.metadata().await?.len());
-    /// io::copy(&mut pb.wrap_async_read(source), &mut target).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn wrap_async_read<R: tokio::io::AsyncRead + Unpin>(&self, read: R) -> ProgressBarIter<R> {
-        ProgressBarIter {
-            progress: self.clone(),
-            it: read,
-        }
-    }
-
-    /// Wraps a [`futures::Stream`](https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html) with the progress bar
-    ///
-    /// ```
-    /// # use indicatif::ProgressBar;
-    /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt};
-    /// let pb = ProgressBar::new(10);
-    /// let mut stream = pb.wrap_stream(stream::iter('a'..='z'));
-    ///
-    /// assert_eq!(stream.next().await, Some('a'));
-    /// assert_eq!(stream.count().await, 25);
-    /// # }); // block_on
-    /// ```
-    #[cfg(feature = "futures")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "futures")))]
-    pub fn wrap_stream<S: futures_core::Stream>(&self, stream: S) -> ProgressBarIter<S> {
-        ProgressBarIter {
-            progress: self.clone(),
-            it: stream,
-        }
-    }
-
-    /// Returns the current position
-    pub fn position(&self) -> u64 {
-        self.state().state.pos()
-    }
-
-    /// Returns the current length
-    pub fn length(&self) -> Option<u64> {
-        self.state().state.len()
-    }
-
-    /// Returns the current ETA
-    pub fn eta(&self) -> Duration {
-        self.state().state.eta()
-    }
-
-    /// Returns the current rate of progress
-    pub fn per_sec(&self) -> f64 {
-        self.state().state.per_sec()
-    }
-
-    /// Returns the current expected duration
-    pub fn duration(&self) -> Duration {
-        self.state().state.duration()
-    }
-
-    /// Returns the current elapsed time
-    pub fn elapsed(&self) -> Duration {
-        self.state().state.elapsed()
-    }
-
-    /// Index in the `MultiState`
-    pub(crate) fn index(&self) -> Option<usize> {
-        self.state().draw_target.remote().map(|(_, idx)| idx)
-    }
-
-    /// Current message
-    pub fn message(&self) -> String {
-        self.state().state.message.expanded().to_string()
-    }
-
-    /// Current prefix
-    pub fn prefix(&self) -> String {
-        self.state().state.prefix.expanded().to_string()
-    }
-
-    #[inline]
-    pub(crate) fn state(&self) -> MutexGuard<'_, BarState> {
-        self.state.lock().unwrap()
-    }
-}
-
-/// A weak reference to a `ProgressBar`.
-///
-/// Useful for creating custom steady tick implementations
-#[derive(Clone, Default)]
-pub struct WeakProgressBar {
-    state: Weak<Mutex<BarState>>,
-    pos: Weak<AtomicPosition>,
-    ticker: Weak<Mutex<Option<Ticker>>>,
-}
-
-impl WeakProgressBar {
-    /// Create a new `WeakProgressBar` that returns `None` when [`upgrade`] is called.
-    ///
-    /// [`upgrade`]: WeakProgressBar::upgrade
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Attempts to upgrade the Weak pointer to a [`ProgressBar`], delaying dropping of the inner
-    /// value if successful. Returns `None` if the inner value has since been dropped.
-    ///
-    /// [`ProgressBar`]: struct.ProgressBar.html
-    pub fn upgrade(&self) -> Option<ProgressBar> {
-        let state = self.state.upgrade()?;
-        let pos = self.pos.upgrade()?;
-        let ticker = self.ticker.upgrade()?;
-        Some(ProgressBar { state, pos, ticker })
-    }
-}
-
-pub(crate) struct Ticker {
-    stopping: Arc<(Mutex<bool>, Condvar)>,
-    join_handle: Option<thread::JoinHandle<()>>,
-}
-
-impl Drop for Ticker {
-    fn drop(&mut self) {
-        self.stop();
-        self.join_handle.take().map(|handle| handle.join());
-    }
-}
-
-#[cfg(test)]
-static TICKER_RUNNING: AtomicBool = AtomicBool::new(false);
-
-impl Ticker {
-    pub(crate) fn new(interval: Duration, bar_state: &Arc<Mutex<BarState>>) -> Self {
-        debug_assert!(!interval.is_zero());
-
-        // A `Mutex<bool>` is used as a flag to indicate whether the ticker was requested to stop.
-        // The `Condvar` is used a notification mechanism: when the ticker is dropped, we notify
-        // the thread and interrupt the ticker wait.
-        #[allow(clippy::mutex_atomic)]
-        let stopping = Arc::new((Mutex::new(false), Condvar::new()));
-        let control = TickerControl {
-            stopping: stopping.clone(),
-            state: Arc::downgrade(bar_state),
-        };
-
-        let join_handle = thread::spawn(move || control.run(interval));
-        Self {
-            stopping,
-            join_handle: Some(join_handle),
-        }
-    }
-
-    pub(crate) fn stop(&self) {
-        *self.stopping.0.lock().unwrap() = true;
-        self.stopping.1.notify_one();
-    }
-}
-
-struct TickerControl {
-    stopping: Arc<(Mutex<bool>, Condvar)>,
-    state: Weak<Mutex<BarState>>,
-}
-
-impl TickerControl {
-    fn run(&self, interval: Duration) {
-        #[cfg(test)]
-        TICKER_RUNNING.store(true, Ordering::SeqCst);
-
-        while let Some(arc) = self.state.upgrade() {
-            let mut state = arc.lock().unwrap();
-            if state.state.is_finished() {
-                break;
-            }
-
-            state.tick(Instant::now());
-
-            drop(state); // Don't forget to drop the lock before sleeping
-            drop(arc); // Also need to drop Arc otherwise BarState won't be dropped
-
-            // Wait for `interval` but return early if we are notified to stop
-            let (_, result) = self
-                .stopping
-                .1
-                .wait_timeout_while(self.stopping.0.lock().unwrap(), interval, |stopped| {
-                    !*stopped
-                })
-                .unwrap();
-
-            // If the wait didn't time out, it means we were notified to stop
-            if !result.timed_out() {
-                break;
-            }
-        }
-
-        #[cfg(test)]
-        TICKER_RUNNING.store(false, Ordering::SeqCst);
-    }
-}
-
-// Tests using the global TICKER_RUNNING flag need to be serialized
-#[cfg(test)]
-pub(crate) static TICKER_TEST: Lazy<Mutex<()>> = Lazy::new(Mutex::default);
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[allow(clippy::float_cmp)]
-    #[test]
-    fn test_pbar_zero() {
-        let pb = ProgressBar::new(0);
-        assert_eq!(pb.state().state.fraction(), 1.0);
-    }
-
-    #[allow(clippy::float_cmp)]
-    #[test]
-    fn test_pbar_maxu64() {
-        let pb = ProgressBar::new(!0);
-        assert_eq!(pb.state().state.fraction(), 0.0);
-    }
-
-    #[test]
-    fn test_pbar_overflow() {
-        let pb = ProgressBar::new(1);
-        pb.set_draw_target(ProgressDrawTarget::hidden());
-        pb.inc(2);
-        pb.finish();
-    }
-
-    #[test]
-    fn test_get_position() {
-        let pb = ProgressBar::new(1);
-        pb.set_draw_target(ProgressDrawTarget::hidden());
-        pb.inc(2);
-        let pos = pb.position();
-        assert_eq!(pos, 2);
-    }
-
-    #[test]
-    fn test_weak_pb() {
-        let pb = ProgressBar::new(0);
-        let weak = pb.downgrade();
-        assert!(weak.upgrade().is_some());
-        ::std::mem::drop(pb);
-        assert!(weak.upgrade().is_none());
-    }
-
-    #[test]
-    fn it_can_wrap_a_reader() {
-        let bytes = &b"I am an implementation of io::Read"[..];
-        let pb = ProgressBar::new(bytes.len() as u64);
-        let mut reader = pb.wrap_read(bytes);
-        let mut writer = Vec::new();
-        io::copy(&mut reader, &mut writer).unwrap();
-        assert_eq!(writer, bytes);
-    }
-
-    #[test]
-    fn it_can_wrap_a_writer() {
-        let bytes = b"implementation of io::Read";
-        let mut reader = &bytes[..];
-        let pb = ProgressBar::new(bytes.len() as u64);
-        let writer = Vec::new();
-        let mut writer = pb.wrap_write(writer);
-        io::copy(&mut reader, &mut writer).unwrap();
-        assert_eq!(writer.it, bytes);
-    }
-
-    #[test]
-    fn ticker_thread_terminates_on_drop() {
-        let _guard = TICKER_TEST.lock().unwrap();
-        assert!(!TICKER_RUNNING.load(Ordering::SeqCst));
-
-        let pb = ProgressBar::new_spinner();
-        pb.enable_steady_tick(Duration::from_millis(50));
-
-        // Give the thread time to start up
-        thread::sleep(Duration::from_millis(250));
-
-        assert!(TICKER_RUNNING.load(Ordering::SeqCst));
-
-        drop(pb);
-        assert!(!TICKER_RUNNING.load(Ordering::SeqCst));
-    }
-
-    #[test]
-    fn ticker_thread_terminates_on_drop_2() {
-        let _guard = TICKER_TEST.lock().unwrap();
-        assert!(!TICKER_RUNNING.load(Ordering::SeqCst));
-
-        let pb = ProgressBar::new_spinner();
-        pb.enable_steady_tick(Duration::from_millis(50));
-        let pb2 = pb.clone();
-
-        // Give the thread time to start up
-        thread::sleep(Duration::from_millis(250));
-
-        assert!(TICKER_RUNNING.load(Ordering::SeqCst));
-
-        drop(pb);
-        assert!(TICKER_RUNNING.load(Ordering::SeqCst));
-
-        drop(pb2);
-        assert!(!TICKER_RUNNING.load(Ordering::SeqCst));
-    }
-}
diff --git a/vendor/indicatif/src/rayon.rs b/vendor/indicatif/src/rayon.rs
deleted file mode 100644
index 1c8e844..0000000
--- a/vendor/indicatif/src/rayon.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-use rayon::iter::plumbing::{Consumer, Folder, Producer, ProducerCallback, UnindexedConsumer};
-use rayon::iter::{IndexedParallelIterator, ParallelIterator};
-
-use crate::{ProgressBar, ProgressBarIter};
-
-/// Wraps a Rayon parallel iterator.
-///
-/// See [`ProgressIterator`](trait.ProgressIterator.html) for method
-/// documentation.
-#[cfg_attr(docsrs, doc(cfg(feature = "rayon")))]
-pub trait ParallelProgressIterator
-where
-    Self: Sized + ParallelIterator,
-{
-    /// Wrap an iterator with a custom progress bar.
-    fn progress_with(self, progress: ProgressBar) -> ProgressBarIter<Self>;
-
-    /// Wrap an iterator with an explicit element count.
-    fn progress_count(self, len: u64) -> ProgressBarIter<Self> {
-        self.progress_with(ProgressBar::new(len))
-    }
-
-    fn progress(self) -> ProgressBarIter<Self>
-    where
-        Self: IndexedParallelIterator,
-    {
-        let len = u64::try_from(self.len()).unwrap();
-        self.progress_count(len)
-    }
-
-    /// Wrap an iterator with a progress bar and style it.
-    fn progress_with_style(self, style: crate::ProgressStyle) -> ProgressBarIter<Self>
-    where
-        Self: IndexedParallelIterator,
-    {
-        let len = u64::try_from(self.len()).unwrap();
-        let bar = ProgressBar::new(len).with_style(style);
-        self.progress_with(bar)
-    }
-}
-
-impl<S: Send, T: ParallelIterator<Item = S>> ParallelProgressIterator for T {
-    fn progress_with(self, progress: ProgressBar) -> ProgressBarIter<Self> {
-        ProgressBarIter { it: self, progress }
-    }
-}
-
-impl<S: Send, T: IndexedParallelIterator<Item = S>> IndexedParallelIterator for ProgressBarIter<T> {
-    fn len(&self) -> usize {
-        self.it.len()
-    }
-
-    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> <C as Consumer<Self::Item>>::Result {
-        let consumer = ProgressConsumer::new(consumer, self.progress);
-        self.it.drive(consumer)
-    }
-
-    fn with_producer<CB: ProducerCallback<Self::Item>>(
-        self,
-        callback: CB,
-    ) -> <CB as ProducerCallback<Self::Item>>::Output {
-        return self.it.with_producer(Callback {
-            callback,
-            progress: self.progress,
-        });
-
-        struct Callback<CB> {
-            callback: CB,
-            progress: ProgressBar,
-        }
-
-        impl<T, CB: ProducerCallback<T>> ProducerCallback<T> for Callback<CB> {
-            type Output = CB::Output;
-
-            fn callback<P>(self, base: P) -> CB::Output
-            where
-                P: Producer<Item = T>,
-            {
-                let producer = ProgressProducer {
-                    base,
-                    progress: self.progress,
-                };
-                self.callback.callback(producer)
-            }
-        }
-    }
-}
-
-struct ProgressProducer<T> {
-    base: T,
-    progress: ProgressBar,
-}
-
-impl<T, P: Producer<Item = T>> Producer for ProgressProducer<P> {
-    type Item = T;
-    type IntoIter = ProgressBarIter<P::IntoIter>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        ProgressBarIter {
-            it: self.base.into_iter(),
-            progress: self.progress,
-        }
-    }
-
-    fn min_len(&self) -> usize {
-        self.base.min_len()
-    }
-
-    fn max_len(&self) -> usize {
-        self.base.max_len()
-    }
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        let (left, right) = self.base.split_at(index);
-        (
-            ProgressProducer {
-                base: left,
-                progress: self.progress.clone(),
-            },
-            ProgressProducer {
-                base: right,
-                progress: self.progress,
-            },
-        )
-    }
-}
-
-struct ProgressConsumer<C> {
-    base: C,
-    progress: ProgressBar,
-}
-
-impl<C> ProgressConsumer<C> {
-    fn new(base: C, progress: ProgressBar) -> Self {
-        ProgressConsumer { base, progress }
-    }
-}
-
-impl<T, C: Consumer<T>> Consumer<T> for ProgressConsumer<C> {
-    type Folder = ProgressFolder<C::Folder>;
-    type Reducer = C::Reducer;
-    type Result = C::Result;
-
-    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
-        let (left, right, reducer) = self.base.split_at(index);
-        (
-            ProgressConsumer::new(left, self.progress.clone()),
-            ProgressConsumer::new(right, self.progress),
-            reducer,
-        )
-    }
-
-    fn into_folder(self) -> Self::Folder {
-        ProgressFolder {
-            base: self.base.into_folder(),
-            progress: self.progress,
-        }
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}
-
-impl<T, C: UnindexedConsumer<T>> UnindexedConsumer<T> for ProgressConsumer<C> {
-    fn split_off_left(&self) -> Self {
-        ProgressConsumer::new(self.base.split_off_left(), self.progress.clone())
-    }
-
-    fn to_reducer(&self) -> Self::Reducer {
-        self.base.to_reducer()
-    }
-}
-
-struct ProgressFolder<C> {
-    base: C,
-    progress: ProgressBar,
-}
-
-impl<T, C: Folder<T>> Folder<T> for ProgressFolder<C> {
-    type Result = C::Result;
-
-    fn consume(self, item: T) -> Self {
-        self.progress.inc(1);
-        ProgressFolder {
-            base: self.base.consume(item),
-            progress: self.progress,
-        }
-    }
-
-    fn complete(self) -> C::Result {
-        self.base.complete()
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}
-
-impl<S: Send, T: ParallelIterator<Item = S>> ParallelIterator for ProgressBarIter<T> {
-    type Item = S;
-
-    fn drive_unindexed<C: UnindexedConsumer<Self::Item>>(self, consumer: C) -> C::Result {
-        let consumer1 = ProgressConsumer::new(consumer, self.progress.clone());
-        self.it.drive_unindexed(consumer1)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-
-    use crate::{ParallelProgressIterator, ProgressBar, ProgressBarIter, ProgressStyle};
-
-    #[test]
-    fn it_can_wrap_a_parallel_iterator() {
-        let v = vec![1, 2, 3];
-        fn wrap<'a, T: ParallelIterator<Item = &'a i32>>(it: ProgressBarIter<T>) {
-            assert_eq!(it.map(|x| x * 2).collect::<Vec<_>>(), vec![2, 4, 6]);
-        }
-
-        wrap(v.par_iter().progress_count(3));
-        wrap({
-            let pb = ProgressBar::new(v.len() as u64);
-            v.par_iter().progress_with(pb)
-        });
-
-        wrap({
-            let style = ProgressStyle::default_bar()
-                .template("{wide_bar:.red} {percent}/100%")
-                .unwrap();
-            v.par_iter().progress_with_style(style)
-        });
-    }
-}
diff --git a/vendor/indicatif/src/state.rs b/vendor/indicatif/src/state.rs
deleted file mode 100644
index 3bcdc44..0000000
--- a/vendor/indicatif/src/state.rs
+++ /dev/null
@@ -1,798 +0,0 @@
-use std::borrow::Cow;
-use std::io;
-use std::sync::Arc;
-use std::time::Duration;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-
-#[cfg(target_arch = "wasm32")]
-use instant::Instant;
-use portable_atomic::{AtomicU64, AtomicU8, Ordering};
-
-use crate::draw_target::ProgressDrawTarget;
-use crate::style::ProgressStyle;
-
-pub(crate) struct BarState {
-    pub(crate) draw_target: ProgressDrawTarget,
-    pub(crate) on_finish: ProgressFinish,
-    pub(crate) style: ProgressStyle,
-    pub(crate) state: ProgressState,
-    pub(crate) tab_width: usize,
-}
-
-impl BarState {
-    pub(crate) fn new(
-        len: Option<u64>,
-        draw_target: ProgressDrawTarget,
-        pos: Arc<AtomicPosition>,
-    ) -> Self {
-        Self {
-            draw_target,
-            on_finish: ProgressFinish::default(),
-            style: ProgressStyle::default_bar(),
-            state: ProgressState::new(len, pos),
-            tab_width: DEFAULT_TAB_WIDTH,
-        }
-    }
-
-    /// Finishes the progress bar using the [`ProgressFinish`] behavior stored
-    /// in the [`ProgressStyle`].
-    pub(crate) fn finish_using_style(&mut self, now: Instant, finish: ProgressFinish) {
-        self.state.status = Status::DoneVisible;
-        match finish {
-            ProgressFinish::AndLeave => {
-                if let Some(len) = self.state.len {
-                    self.state.pos.set(len);
-                }
-            }
-            ProgressFinish::WithMessage(msg) => {
-                if let Some(len) = self.state.len {
-                    self.state.pos.set(len);
-                }
-                self.state.message = TabExpandedString::new(msg, self.tab_width);
-            }
-            ProgressFinish::AndClear => {
-                if let Some(len) = self.state.len {
-                    self.state.pos.set(len);
-                }
-                self.state.status = Status::DoneHidden;
-            }
-            ProgressFinish::Abandon => {}
-            ProgressFinish::AbandonWithMessage(msg) => {
-                self.state.message = TabExpandedString::new(msg, self.tab_width);
-            }
-        }
-
-        // There's no need to update the estimate here; once the `status` is no longer
-        // `InProgress`, we will use the length and elapsed time to estimate.
-        let _ = self.draw(true, now);
-    }
-
-    pub(crate) fn reset(&mut self, now: Instant, mode: Reset) {
-        // Always reset the estimator; this is the only reset that will occur if mode is
-        // `Reset::Eta`.
-        self.state.est.reset(now);
-
-        if let Reset::Elapsed | Reset::All = mode {
-            self.state.started = now;
-        }
-
-        if let Reset::All = mode {
-            self.state.pos.reset(now);
-            self.state.status = Status::InProgress;
-
-            for tracker in self.style.format_map.values_mut() {
-                tracker.reset(&self.state, now);
-            }
-
-            let _ = self.draw(false, now);
-        }
-    }
-
-    pub(crate) fn update(&mut self, now: Instant, f: impl FnOnce(&mut ProgressState), tick: bool) {
-        f(&mut self.state);
-        if tick {
-            self.tick(now);
-        }
-    }
-
-    pub(crate) fn set_length(&mut self, now: Instant, len: u64) {
-        self.state.len = Some(len);
-        self.update_estimate_and_draw(now);
-    }
-
-    pub(crate) fn inc_length(&mut self, now: Instant, delta: u64) {
-        if let Some(len) = self.state.len {
-            self.state.len = Some(len.saturating_add(delta));
-        }
-        self.update_estimate_and_draw(now);
-    }
-
-    pub(crate) fn set_tab_width(&mut self, tab_width: usize) {
-        self.tab_width = tab_width;
-        self.state.message.set_tab_width(tab_width);
-        self.state.prefix.set_tab_width(tab_width);
-        self.style.set_tab_width(tab_width);
-    }
-
-    pub(crate) fn set_style(&mut self, style: ProgressStyle) {
-        self.style = style;
-        self.style.set_tab_width(self.tab_width);
-    }
-
-    pub(crate) fn tick(&mut self, now: Instant) {
-        self.state.tick = self.state.tick.saturating_add(1);
-        self.update_estimate_and_draw(now);
-    }
-
-    pub(crate) fn update_estimate_and_draw(&mut self, now: Instant) {
-        let pos = self.state.pos.pos.load(Ordering::Relaxed);
-        self.state.est.record(pos, now);
-
-        for tracker in self.style.format_map.values_mut() {
-            tracker.tick(&self.state, now);
-        }
-
-        let _ = self.draw(false, now);
-    }
-
-    pub(crate) fn println(&mut self, now: Instant, msg: &str) {
-        let width = self.draw_target.width();
-        let mut drawable = match self.draw_target.drawable(true, now) {
-            Some(drawable) => drawable,
-            None => return,
-        };
-
-        let mut draw_state = drawable.state();
-        let lines: Vec<String> = msg.lines().map(Into::into).collect();
-        // Empty msg should trigger newline as we are in println
-        if lines.is_empty() {
-            draw_state.lines.push(String::new());
-        } else {
-            draw_state.lines.extend(lines);
-        }
-        draw_state.orphan_lines_count = draw_state.lines.len();
-        if !matches!(self.state.status, Status::DoneHidden) {
-            self.style
-                .format_state(&self.state, &mut draw_state.lines, width);
-        }
-
-        drop(draw_state);
-        let _ = drawable.draw();
-    }
-
-    pub(crate) fn suspend<F: FnOnce() -> R, R>(&mut self, now: Instant, f: F) -> R {
-        if let Some((state, _)) = self.draw_target.remote() {
-            return state.write().unwrap().suspend(f, now);
-        }
-
-        if let Some(drawable) = self.draw_target.drawable(true, now) {
-            let _ = drawable.clear();
-        }
-
-        let ret = f();
-        let _ = self.draw(true, Instant::now());
-        ret
-    }
-
-    pub(crate) fn draw(&mut self, mut force_draw: bool, now: Instant) -> io::Result<()> {
-        let width = self.draw_target.width();
-
-        // `|= self.is_finished()` should not be needed here, but we used to always draw for
-        // finished progress bars, so it's kept as to not cause compatibility issues in weird cases.
-        force_draw |= self.state.is_finished();
-        let mut drawable = match self.draw_target.drawable(force_draw, now) {
-            Some(drawable) => drawable,
-            None => return Ok(()),
-        };
-
-        let mut draw_state = drawable.state();
-
-        if !matches!(self.state.status, Status::DoneHidden) {
-            self.style
-                .format_state(&self.state, &mut draw_state.lines, width);
-        }
-
-        drop(draw_state);
-        drawable.draw()
-    }
-}
-
-impl Drop for BarState {
-    fn drop(&mut self) {
-        // Progress bar is already finished.  Do not need to do anything other than notify
-        // the `MultiProgress` that we're now a zombie.
-        if self.state.is_finished() {
-            self.draw_target.mark_zombie();
-            return;
-        }
-
-        self.finish_using_style(Instant::now(), self.on_finish.clone());
-
-        // Notify the `MultiProgress` that we're now a zombie.
-        self.draw_target.mark_zombie();
-    }
-}
-
-pub(crate) enum Reset {
-    Eta,
-    Elapsed,
-    All,
-}
-
-/// The state of a progress bar at a moment in time.
-#[non_exhaustive]
-pub struct ProgressState {
-    pos: Arc<AtomicPosition>,
-    len: Option<u64>,
-    pub(crate) tick: u64,
-    pub(crate) started: Instant,
-    status: Status,
-    est: Estimator,
-    pub(crate) message: TabExpandedString,
-    pub(crate) prefix: TabExpandedString,
-}
-
-impl ProgressState {
-    pub(crate) fn new(len: Option<u64>, pos: Arc<AtomicPosition>) -> Self {
-        let now = Instant::now();
-        Self {
-            pos,
-            len,
-            tick: 0,
-            status: Status::InProgress,
-            started: now,
-            est: Estimator::new(now),
-            message: TabExpandedString::NoTabs("".into()),
-            prefix: TabExpandedString::NoTabs("".into()),
-        }
-    }
-
-    /// Indicates that the progress bar finished.
-    pub fn is_finished(&self) -> bool {
-        match self.status {
-            Status::InProgress => false,
-            Status::DoneVisible => true,
-            Status::DoneHidden => true,
-        }
-    }
-
-    /// Returns the completion as a floating-point number between 0 and 1
-    pub fn fraction(&self) -> f32 {
-        let pos = self.pos.pos.load(Ordering::Relaxed);
-        let pct = match (pos, self.len) {
-            (_, None) => 0.0,
-            (_, Some(0)) => 1.0,
-            (0, _) => 0.0,
-            (pos, Some(len)) => pos as f32 / len as f32,
-        };
-        pct.clamp(0.0, 1.0)
-    }
-
-    /// The expected ETA
-    pub fn eta(&self) -> Duration {
-        if self.is_finished() {
-            return Duration::new(0, 0);
-        }
-
-        let len = match self.len {
-            Some(len) => len,
-            None => return Duration::new(0, 0),
-        };
-
-        let pos = self.pos.pos.load(Ordering::Relaxed);
-
-        let sps = self.est.steps_per_second(Instant::now());
-
-        // Infinite duration should only ever happen at the beginning, so in this case it's okay to
-        // just show an ETA of 0 until progress starts to occur.
-        if sps == 0.0 {
-            return Duration::new(0, 0);
-        }
-
-        secs_to_duration(len.saturating_sub(pos) as f64 / sps)
-    }
-
-    /// The expected total duration (that is, elapsed time + expected ETA)
-    pub fn duration(&self) -> Duration {
-        if self.len.is_none() || self.is_finished() {
-            return Duration::new(0, 0);
-        }
-        self.started.elapsed().saturating_add(self.eta())
-    }
-
-    /// The number of steps per second
-    pub fn per_sec(&self) -> f64 {
-        if let Status::InProgress = self.status {
-            self.est.steps_per_second(Instant::now())
-        } else {
-            let len = self.len.unwrap_or_else(|| self.pos());
-            len as f64 / self.started.elapsed().as_secs_f64()
-        }
-    }
-
-    pub fn elapsed(&self) -> Duration {
-        self.started.elapsed()
-    }
-
-    pub fn pos(&self) -> u64 {
-        self.pos.pos.load(Ordering::Relaxed)
-    }
-
-    pub fn set_pos(&mut self, pos: u64) {
-        self.pos.set(pos);
-    }
-
-    #[allow(clippy::len_without_is_empty)]
-    pub fn len(&self) -> Option<u64> {
-        self.len
-    }
-
-    pub fn set_len(&mut self, len: u64) {
-        self.len = Some(len);
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub(crate) enum TabExpandedString {
-    NoTabs(Cow<'static, str>),
-    WithTabs {
-        original: Cow<'static, str>,
-        expanded: String,
-        tab_width: usize,
-    },
-}
-
-impl TabExpandedString {
-    pub(crate) fn new(s: Cow<'static, str>, tab_width: usize) -> Self {
-        let expanded = s.replace('\t', &" ".repeat(tab_width));
-        if s == expanded {
-            Self::NoTabs(s)
-        } else {
-            Self::WithTabs {
-                original: s,
-                expanded,
-                tab_width,
-            }
-        }
-    }
-
-    pub(crate) fn expanded(&self) -> &str {
-        match &self {
-            Self::NoTabs(s) => {
-                debug_assert!(!s.contains('\t'));
-                s
-            }
-            Self::WithTabs { expanded, .. } => expanded,
-        }
-    }
-
-    pub(crate) fn set_tab_width(&mut self, new_tab_width: usize) {
-        if let Self::WithTabs {
-            original,
-            expanded,
-            tab_width,
-        } = self
-        {
-            if *tab_width != new_tab_width {
-                *tab_width = new_tab_width;
-                *expanded = original.replace('\t', &" ".repeat(new_tab_width));
-            }
-        }
-    }
-}
-
-/// Double-smoothed exponentially weighted estimator
-///
-/// This uses an exponentially weighted *time-based* estimator, meaning that it exponentially
-/// downweights old data based on its age. The rate at which this occurs is currently a constant
-/// value of 15 seconds for 90% weighting. This means that all data older than 15 seconds has a
-/// collective weight of 0.1 in the estimate, and all data older than 30 seconds has a collective
-/// weight of 0.01, and so on.
-///
-/// The primary value exposed by `Estimator` is `steps_per_second`. This value is doubly-smoothed,
-/// meaning that is the result of using an exponentially weighted estimator (as described above) to
-/// estimate the value of another exponentially weighted estimator, which estimates the value of
-/// the raw data.
-///
-/// The purpose of this extra smoothing step is to reduce instantaneous fluctations in the estimate
-/// when large updates are received. Without this, estimates might have a large spike followed by a
-/// slow asymptotic approach to zero (until the next spike).
-#[derive(Debug)]
-pub(crate) struct Estimator {
-    smoothed_steps_per_sec: f64,
-    double_smoothed_steps_per_sec: f64,
-    prev_steps: u64,
-    prev_time: Instant,
-    start_time: Instant,
-}
-
-impl Estimator {
-    fn new(now: Instant) -> Self {
-        Self {
-            smoothed_steps_per_sec: 0.0,
-            double_smoothed_steps_per_sec: 0.0,
-            prev_steps: 0,
-            prev_time: now,
-            start_time: now,
-        }
-    }
-
-    fn record(&mut self, new_steps: u64, now: Instant) {
-        // sanity check: don't record data if time or steps have not advanced
-        if new_steps <= self.prev_steps || now <= self.prev_time {
-            // Reset on backwards seek to prevent breakage from seeking to the end for length determination
-            // See https://github.com/console-rs/indicatif/issues/480
-            if new_steps < self.prev_steps {
-                self.prev_steps = new_steps;
-                self.reset(now);
-            }
-            return;
-        }
-
-        let delta_steps = new_steps - self.prev_steps;
-        let delta_t = duration_to_secs(now - self.prev_time);
-
-        // the rate of steps we saw in this update
-        let new_steps_per_second = delta_steps as f64 / delta_t;
-
-        // update the estimate: a weighted average of the old estimate and new data
-        let weight = estimator_weight(delta_t);
-        self.smoothed_steps_per_sec =
-            self.smoothed_steps_per_sec * weight + new_steps_per_second * (1.0 - weight);
-
-        // An iterative estimate like `smoothed_steps_per_sec` is supposed to be an exponentially
-        // weighted average from t=0 back to t=-inf; Since we initialize it to 0, we neglect the
-        // (non-existent) samples in the weighted average prior to the first one, so the resulting
-        // average must be normalized. We normalize the single estimate here in order to use it as
-        // a source for the double smoothed estimate. See comment on normalization in
-        // `steps_per_second` for details.
-        let delta_t_start = duration_to_secs(now - self.start_time);
-        let total_weight = 1.0 - estimator_weight(delta_t_start);
-        let normalized_smoothed_steps_per_sec = self.smoothed_steps_per_sec / total_weight;
-
-        // determine the double smoothed value (EWA smoothing of the single EWA)
-        self.double_smoothed_steps_per_sec = self.double_smoothed_steps_per_sec * weight
-            + normalized_smoothed_steps_per_sec * (1.0 - weight);
-
-        self.prev_steps = new_steps;
-        self.prev_time = now;
-    }
-
-    /// Reset the state of the estimator. Once reset, estimates will not depend on any data prior
-    /// to `now`. This does not reset the stored position of the progress bar.
-    pub(crate) fn reset(&mut self, now: Instant) {
-        self.smoothed_steps_per_sec = 0.0;
-        self.double_smoothed_steps_per_sec = 0.0;
-
-        // only reset prev_time, not prev_steps
-        self.prev_time = now;
-        self.start_time = now;
-    }
-
-    /// Average time per step in seconds, using double exponential smoothing
-    fn steps_per_second(&self, now: Instant) -> f64 {
-        // Because the value stored in the Estimator is only updated when the Estimator receives an
-        // update, this value will become stuck if progress stalls. To return an accurate estimate,
-        // we determine how much time has passed since the last update, and treat this as a
-        // pseudo-update with 0 steps.
-        let delta_t = duration_to_secs(now - self.prev_time);
-        let reweight = estimator_weight(delta_t);
-
-        // Normalization of estimates:
-        //
-        // The raw estimate is a single value (smoothed_steps_per_second) that is iteratively
-        // updated. At each update, the previous value of the estimate is downweighted according to
-        // its age, receiving the iterative weight W(t) = 0.1 ^ (t/15).
-        //
-        // Since W(Sum(t_n)) = Prod(W(t_n)), the total weight of a sample after a series of
-        // iterative steps is simply W(t_e) - W(t_b), where t_e is the time since the end of the
-        // sample, and t_b is the time since the beginning. The resulting estimate is therefore a
-        // weighted average with sample weights W(t_e) - W(t_b).
-        //
-        // Notice that the weighting function generates sample weights that sum to 1 only when the
-        // sample times span from t=0 to t=inf; but this is not the case. We have a first sample
-        // with finite, positive t_b = t_f. In the raw estimate, we handle times prior to t_f by
-        // setting an initial value of 0, meaning that these (non-existent) samples have no weight.
-        //
-        // Therefore, the raw estimate must be normalized by dividing it by the sum of the weights
-        // in the weighted average. This sum is just W(0) - W(t_f), where t_f is the time since the
-        // first sample, and W(0) = 1.
-        let delta_t_start = duration_to_secs(now - self.start_time);
-        let total_weight = 1.0 - estimator_weight(delta_t_start);
-
-        // Generate updated values for `smoothed_steps_per_sec` and `double_smoothed_steps_per_sec`
-        // (sps and dsps) without storing them. Note that we normalize sps when using it as a
-        // source to update dsps, and then normalize dsps itself before returning it.
-        let sps = self.smoothed_steps_per_sec * reweight / total_weight;
-        let dsps = self.double_smoothed_steps_per_sec * reweight + sps * (1.0 - reweight);
-        dsps / total_weight
-    }
-}
-
-pub(crate) struct AtomicPosition {
-    pub(crate) pos: AtomicU64,
-    capacity: AtomicU8,
-    prev: AtomicU64,
-    start: Instant,
-}
-
-impl AtomicPosition {
-    pub(crate) fn new() -> Self {
-        Self {
-            pos: AtomicU64::new(0),
-            capacity: AtomicU8::new(MAX_BURST),
-            prev: AtomicU64::new(0),
-            start: Instant::now(),
-        }
-    }
-
-    pub(crate) fn allow(&self, now: Instant) -> bool {
-        if now < self.start {
-            return false;
-        }
-
-        let mut capacity = self.capacity.load(Ordering::Acquire);
-        // `prev` is the number of ms after `self.started` we last returned `true`, in ns
-        let prev = self.prev.load(Ordering::Acquire);
-        // `elapsed` is the number of ns since `self.started`
-        let elapsed = (now - self.start).as_nanos() as u64;
-        // `diff` is the number of ns since we last returned `true`
-        let diff = elapsed.saturating_sub(prev);
-
-        // If `capacity` is 0 and not enough time (1ms) has passed since `prev`
-        // to add new capacity, return `false`. The goal of this method is to
-        // make this decision as efficient as possible.
-        if capacity == 0 && diff < INTERVAL {
-            return false;
-        }
-
-        // We now calculate `new`, the number of ms, in ns, since we last returned `true`,
-        // and `remainder`, which represents a number of ns less than 1ms which we cannot
-        // convert into capacity now, so we're saving it for later. We do this by
-        // substracting this from `elapsed` before storing it into `self.prev`.
-        let (new, remainder) = ((diff / INTERVAL), (diff % INTERVAL));
-        // We add `new` to `capacity`, subtract one for returning `true` from here,
-        // then make sure it does not exceed a maximum of `MAX_BURST`.
-        capacity = Ord::min(MAX_BURST as u128, (capacity as u128) + (new as u128) - 1) as u8;
-
-        // Then, we just store `capacity` and `prev` atomically for the next iteration
-        self.capacity.store(capacity, Ordering::Release);
-        self.prev.store(elapsed - remainder, Ordering::Release);
-        true
-    }
-
-    fn reset(&self, now: Instant) {
-        self.set(0);
-        let elapsed = (now.saturating_duration_since(self.start)).as_millis() as u64;
-        self.prev.store(elapsed, Ordering::Release);
-    }
-
-    pub(crate) fn inc(&self, delta: u64) {
-        self.pos.fetch_add(delta, Ordering::SeqCst);
-    }
-
-    pub(crate) fn set(&self, pos: u64) {
-        self.pos.store(pos, Ordering::Release);
-    }
-}
-
-const INTERVAL: u64 = 1_000_000;
-const MAX_BURST: u8 = 10;
-
-/// Behavior of a progress bar when it is finished
-///
-/// This is invoked when a [`ProgressBar`] or [`ProgressBarIter`] completes and
-/// [`ProgressBar::is_finished`] is false.
-///
-/// [`ProgressBar`]: crate::ProgressBar
-/// [`ProgressBarIter`]: crate::ProgressBarIter
-/// [`ProgressBar::is_finished`]: crate::ProgressBar::is_finished
-#[derive(Clone, Debug)]
-pub enum ProgressFinish {
-    /// Finishes the progress bar and leaves the current message
-    ///
-    /// Same behavior as calling [`ProgressBar::finish()`](crate::ProgressBar::finish).
-    AndLeave,
-    /// Finishes the progress bar and sets a message
-    ///
-    /// Same behavior as calling [`ProgressBar::finish_with_message()`](crate::ProgressBar::finish_with_message).
-    WithMessage(Cow<'static, str>),
-    /// Finishes the progress bar and completely clears it (this is the default)
-    ///
-    /// Same behavior as calling [`ProgressBar::finish_and_clear()`](crate::ProgressBar::finish_and_clear).
-    AndClear,
-    /// Finishes the progress bar and leaves the current message and progress
-    ///
-    /// Same behavior as calling [`ProgressBar::abandon()`](crate::ProgressBar::abandon).
-    Abandon,
-    /// Finishes the progress bar and sets a message, and leaves the current progress
-    ///
-    /// Same behavior as calling [`ProgressBar::abandon_with_message()`](crate::ProgressBar::abandon_with_message).
-    AbandonWithMessage(Cow<'static, str>),
-}
-
-impl Default for ProgressFinish {
-    fn default() -> Self {
-        Self::AndClear
-    }
-}
-
-/// Get the appropriate dilution weight for Estimator data given the data's age (in seconds)
-///
-/// Whenever an update occurs, we will create a new estimate using a weight `w_i` like so:
-///
-/// ```math
-/// <new estimate> = <previous estimate> * w_i + <new data> * (1 - w_i)
-/// ```
-///
-/// In other words, the new estimate is a weighted average of the previous estimate and the new
-/// data. We want to choose weights such that for any set of samples where `t_0, t_1, ...` are
-/// the durations of the samples:
-///
-/// ```math
-/// Sum(t_i) = ews ==> Prod(w_i) = 0.1
-/// ```
-///
-/// With this constraint it is easy to show that
-///
-/// ```math
-/// w_i = 0.1 ^ (t_i / ews)
-/// ```
-///
-/// Notice that the constraint implies that estimates are independent of the durations of the
-/// samples, a very useful feature.
-fn estimator_weight(age: f64) -> f64 {
-    const EXPONENTIAL_WEIGHTING_SECONDS: f64 = 15.0;
-    0.1_f64.powf(age / EXPONENTIAL_WEIGHTING_SECONDS)
-}
-
-fn duration_to_secs(d: Duration) -> f64 {
-    d.as_secs() as f64 + f64::from(d.subsec_nanos()) / 1_000_000_000f64
-}
-
-fn secs_to_duration(s: f64) -> Duration {
-    let secs = s.trunc() as u64;
-    let nanos = (s.fract() * 1_000_000_000f64) as u32;
-    Duration::new(secs, nanos)
-}
-
-#[derive(Debug)]
-pub(crate) enum Status {
-    InProgress,
-    DoneVisible,
-    DoneHidden,
-}
-
-pub(crate) const DEFAULT_TAB_WIDTH: usize = 8;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ProgressBar;
-
-    // https://github.com/rust-lang/rust-clippy/issues/10281
-    #[allow(clippy::uninlined_format_args)]
-    #[test]
-    fn test_steps_per_second() {
-        let test_rate = |items_per_second| {
-            let mut now = Instant::now();
-            let mut est = Estimator::new(now);
-            let mut pos = 0;
-
-            for _ in 0..20 {
-                pos += items_per_second;
-                now += Duration::from_secs(1);
-                est.record(pos, now);
-            }
-            let avg_steps_per_second = est.steps_per_second(now);
-
-            assert!(avg_steps_per_second > 0.0);
-            assert!(avg_steps_per_second.is_finite());
-
-            let absolute_error = (avg_steps_per_second - items_per_second as f64).abs();
-            let relative_error = absolute_error / items_per_second as f64;
-            assert!(
-                relative_error < 1.0 / 1e9,
-                "Expected rate: {}, actual: {}, relative error: {}",
-                items_per_second,
-                avg_steps_per_second,
-                relative_error
-            );
-        };
-
-        test_rate(1);
-        test_rate(1_000);
-        test_rate(1_000_000);
-        test_rate(1_000_000_000);
-        test_rate(1_000_000_001);
-        test_rate(100_000_000_000);
-        test_rate(1_000_000_000_000);
-        test_rate(100_000_000_000_000);
-        test_rate(1_000_000_000_000_000);
-    }
-
-    #[test]
-    fn test_double_exponential_ave() {
-        let mut now = Instant::now();
-        let mut est = Estimator::new(now);
-        let mut pos = 0;
-
-        // note: this is the default weight set in the Estimator
-        let weight = 15;
-
-        for _ in 0..weight {
-            pos += 1;
-            now += Duration::from_secs(1);
-            est.record(pos, now);
-        }
-        now += Duration::from_secs(weight);
-
-        // The first level EWA:
-        //   -> 90% weight @ 0 eps, 9% weight @ 1 eps, 1% weight @ 0 eps
-        //   -> then normalized by deweighting the 1% weight (before -30 seconds)
-        let single_target = 0.09 / 0.99;
-
-        // The second level EWA:
-        //   -> same logic as above, but using the first level EWA as the source
-        let double_target = (0.9 * single_target + 0.09) / 0.99;
-        assert_eq!(est.steps_per_second(now), double_target);
-    }
-
-    #[test]
-    fn test_estimator_rewind_position() {
-        let mut now = Instant::now();
-        let mut est = Estimator::new(now);
-
-        now += Duration::from_secs(1);
-        est.record(1, now);
-
-        // should not panic
-        now += Duration::from_secs(1);
-        est.record(0, now);
-
-        // check that reset occurred (estimator at 1 event per sec)
-        now += Duration::from_secs(1);
-        est.record(1, now);
-        assert_eq!(est.steps_per_second(now), 1.0);
-
-        // check that progress bar handles manual seeking
-        let pb = ProgressBar::hidden();
-        pb.set_length(10);
-        pb.set_position(1);
-        pb.tick();
-        // Should not panic.
-        pb.set_position(0);
-    }
-
-    #[test]
-    fn test_reset_eta() {
-        let mut now = Instant::now();
-        let mut est = Estimator::new(now);
-
-        // two per second, then reset
-        now += Duration::from_secs(1);
-        est.record(2, now);
-        est.reset(now);
-
-        // now one per second, and verify
-        now += Duration::from_secs(1);
-        est.record(3, now);
-        assert_eq!(est.steps_per_second(now), 1.0);
-    }
-
-    #[test]
-    fn test_duration_stuff() {
-        let duration = Duration::new(42, 100_000_000);
-        let secs = duration_to_secs(duration);
-        assert_eq!(secs_to_duration(secs), duration);
-    }
-
-    #[test]
-    fn test_atomic_position_large_time_difference() {
-        let atomic_position = AtomicPosition::new();
-        let later = atomic_position.start + Duration::from_nanos(INTERVAL * u64::from(u8::MAX));
-        // Should not panic.
-        atomic_position.allow(later);
-    }
-}
diff --git a/vendor/indicatif/src/style.rs b/vendor/indicatif/src/style.rs
deleted file mode 100644
index 01b220f..0000000
--- a/vendor/indicatif/src/style.rs
+++ /dev/null
@@ -1,987 +0,0 @@
-use std::collections::HashMap;
-use std::fmt::{self, Write};
-use std::mem;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-
-use console::{measure_text_width, Style};
-#[cfg(target_arch = "wasm32")]
-use instant::Instant;
-#[cfg(feature = "unicode-segmentation")]
-use unicode_segmentation::UnicodeSegmentation;
-
-use crate::format::{
-    BinaryBytes, DecimalBytes, FormattedDuration, HumanBytes, HumanCount, HumanDuration,
-    HumanFloatCount,
-};
-use crate::state::{ProgressState, TabExpandedString, DEFAULT_TAB_WIDTH};
-
-#[derive(Clone)]
-pub struct ProgressStyle {
-    tick_strings: Vec<Box<str>>,
-    progress_chars: Vec<Box<str>>,
-    template: Template,
-    // how unicode-big each char in progress_chars is
-    char_width: usize,
-    tab_width: usize,
-    pub(crate) format_map: HashMap<&'static str, Box<dyn ProgressTracker>>,
-}
-
-#[cfg(feature = "unicode-segmentation")]
-fn segment(s: &str) -> Vec<Box<str>> {
-    UnicodeSegmentation::graphemes(s, true)
-        .map(|s| s.into())
-        .collect()
-}
-
-#[cfg(not(feature = "unicode-segmentation"))]
-fn segment(s: &str) -> Vec<Box<str>> {
-    s.chars().map(|x| x.to_string().into()).collect()
-}
-
-#[cfg(feature = "unicode-width")]
-fn measure(s: &str) -> usize {
-    unicode_width::UnicodeWidthStr::width(s)
-}
-
-#[cfg(not(feature = "unicode-width"))]
-fn measure(s: &str) -> usize {
-    s.chars().count()
-}
-
-/// finds the unicode-aware width of the passed grapheme cluters
-/// panics on an empty parameter, or if the characters are not equal-width
-fn width(c: &[Box<str>]) -> usize {
-    c.iter()
-        .map(|s| measure(s.as_ref()))
-        .fold(None, |acc, new| {
-            match acc {
-                None => return Some(new),
-                Some(old) => assert_eq!(old, new, "got passed un-equal width progress characters"),
-            }
-            acc
-        })
-        .unwrap()
-}
-
-impl ProgressStyle {
-    /// Returns the default progress bar style for bars
-    pub fn default_bar() -> Self {
-        Self::new(Template::from_str("{wide_bar} {pos}/{len}").unwrap())
-    }
-
-    /// Returns the default progress bar style for spinners
-    pub fn default_spinner() -> Self {
-        Self::new(Template::from_str("{spinner} {msg}").unwrap())
-    }
-
-    /// Sets the template string for the progress bar
-    ///
-    /// Review the [list of template keys](../index.html#templates) for more information.
-    pub fn with_template(template: &str) -> Result<Self, TemplateError> {
-        Ok(Self::new(Template::from_str(template)?))
-    }
-
-    pub(crate) fn set_tab_width(&mut self, new_tab_width: usize) {
-        self.tab_width = new_tab_width;
-        self.template.set_tab_width(new_tab_width);
-    }
-
-    fn new(template: Template) -> Self {
-        let progress_chars = segment("█░");
-        let char_width = width(&progress_chars);
-        Self {
-            tick_strings: "⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈ "
-                .chars()
-                .map(|c| c.to_string().into())
-                .collect(),
-            progress_chars,
-            char_width,
-            template,
-            format_map: HashMap::default(),
-            tab_width: DEFAULT_TAB_WIDTH,
-        }
-    }
-
-    /// Sets the tick character sequence for spinners
-    ///
-    /// Note that the last character is used as the [final tick string][Self::get_final_tick_str()].
-    /// At least two characters are required to provide a non-final and final state.
-    pub fn tick_chars(mut self, s: &str) -> Self {
-        self.tick_strings = s.chars().map(|c| c.to_string().into()).collect();
-        // Format bar will panic with some potentially confusing message, better to panic here
-        // with a message explicitly informing of the problem
-        assert!(
-            self.tick_strings.len() >= 2,
-            "at least 2 tick chars required"
-        );
-        self
-    }
-
-    /// Sets the tick string sequence for spinners
-    ///
-    /// Note that the last string is used as the [final tick string][Self::get_final_tick_str()].
-    /// At least two strings are required to provide a non-final and final state.
-    pub fn tick_strings(mut self, s: &[&str]) -> Self {
-        self.tick_strings = s.iter().map(|s| s.to_string().into()).collect();
-        // Format bar will panic with some potentially confusing message, better to panic here
-        // with a message explicitly informing of the problem
-        assert!(
-            self.progress_chars.len() >= 2,
-            "at least 2 tick strings required"
-        );
-        self
-    }
-
-    /// Sets the progress characters `(filled, current, to do)`
-    ///
-    /// You can pass more than three for a more detailed display.
-    /// All passed grapheme clusters need to be of equal width.
-    pub fn progress_chars(mut self, s: &str) -> Self {
-        self.progress_chars = segment(s);
-        // Format bar will panic with some potentially confusing message, better to panic here
-        // with a message explicitly informing of the problem
-        assert!(
-            self.progress_chars.len() >= 2,
-            "at least 2 progress chars required"
-        );
-        self.char_width = width(&self.progress_chars);
-        self
-    }
-
-    /// Adds a custom key that owns a [`ProgressTracker`] to the template
-    pub fn with_key<S: ProgressTracker + 'static>(mut self, key: &'static str, f: S) -> Self {
-        self.format_map.insert(key, Box::new(f));
-        self
-    }
-
-    /// Sets the template string for the progress bar
-    ///
-    /// Review the [list of template keys](../index.html#templates) for more information.
-    pub fn template(mut self, s: &str) -> Result<Self, TemplateError> {
-        self.template = Template::from_str(s)?;
-        Ok(self)
-    }
-
-    fn current_tick_str(&self, state: &ProgressState) -> &str {
-        match state.is_finished() {
-            true => self.get_final_tick_str(),
-            false => self.get_tick_str(state.tick),
-        }
-    }
-
-    /// Returns the tick string for a given number
-    pub fn get_tick_str(&self, idx: u64) -> &str {
-        &self.tick_strings[(idx as usize) % (self.tick_strings.len() - 1)]
-    }
-
-    /// Returns the tick string for the finished state
-    pub fn get_final_tick_str(&self) -> &str {
-        &self.tick_strings[self.tick_strings.len() - 1]
-    }
-
-    fn format_bar(&self, fract: f32, width: usize, alt_style: Option<&Style>) -> BarDisplay<'_> {
-        // The number of clusters from progress_chars to write (rounding down).
-        let width = width / self.char_width;
-        // The number of full clusters (including a fractional component for a partially-full one).
-        let fill = fract * width as f32;
-        // The number of entirely full clusters (by truncating `fill`).
-        let entirely_filled = fill as usize;
-        // 1 if the bar is not entirely empty or full (meaning we need to draw the "current"
-        // character between the filled and "to do" segment), 0 otherwise.
-        let head = usize::from(fill > 0.0 && entirely_filled < width);
-
-        let cur = if head == 1 {
-            // Number of fine-grained progress entries in progress_chars.
-            let n = self.progress_chars.len().saturating_sub(2);
-            let cur_char = if n <= 1 {
-                // No fine-grained entries. 1 is the single "current" entry if we have one, the "to
-                // do" entry if not.
-                1
-            } else {
-                // Pick a fine-grained entry, ranging from the last one (n) if the fractional part
-                // of fill is 0 to the first one (1) if the fractional part of fill is almost 1.
-                n.saturating_sub((fill.fract() * n as f32) as usize)
-            };
-            Some(cur_char)
-        } else {
-            None
-        };
-
-        // Number of entirely empty clusters needed to fill the bar up to `width`.
-        let bg = width.saturating_sub(entirely_filled).saturating_sub(head);
-        let rest = RepeatedStringDisplay {
-            str: &self.progress_chars[self.progress_chars.len() - 1],
-            num: bg,
-        };
-
-        BarDisplay {
-            chars: &self.progress_chars,
-            filled: entirely_filled,
-            cur,
-            rest: alt_style.unwrap_or(&Style::new()).apply_to(rest),
-        }
-    }
-
-    pub(crate) fn format_state(
-        &self,
-        state: &ProgressState,
-        lines: &mut Vec<String>,
-        target_width: u16,
-    ) {
-        let mut cur = String::new();
-        let mut buf = String::new();
-        let mut wide = None;
-
-        let pos = state.pos();
-        let len = state.len().unwrap_or(pos);
-        for part in &self.template.parts {
-            match part {
-                TemplatePart::Placeholder {
-                    key,
-                    align,
-                    width,
-                    truncate,
-                    style,
-                    alt_style,
-                } => {
-                    buf.clear();
-                    if let Some(tracker) = self.format_map.get(key.as_str()) {
-                        tracker.write(state, &mut TabRewriter(&mut buf, self.tab_width));
-                    } else {
-                        match key.as_str() {
-                            "wide_bar" => {
-                                wide = Some(WideElement::Bar { alt_style });
-                                buf.push('\x00');
-                            }
-                            "bar" => buf
-                                .write_fmt(format_args!(
-                                    "{}",
-                                    self.format_bar(
-                                        state.fraction(),
-                                        width.unwrap_or(20) as usize,
-                                        alt_style.as_ref(),
-                                    )
-                                ))
-                                .unwrap(),
-                            "spinner" => buf.push_str(self.current_tick_str(state)),
-                            "wide_msg" => {
-                                wide = Some(WideElement::Message { align });
-                                buf.push('\x00');
-                            }
-                            "msg" => buf.push_str(state.message.expanded()),
-                            "prefix" => buf.push_str(state.prefix.expanded()),
-                            "pos" => buf.write_fmt(format_args!("{pos}")).unwrap(),
-                            "human_pos" => {
-                                buf.write_fmt(format_args!("{}", HumanCount(pos))).unwrap();
-                            }
-                            "len" => buf.write_fmt(format_args!("{len}")).unwrap(),
-                            "human_len" => {
-                                buf.write_fmt(format_args!("{}", HumanCount(len))).unwrap();
-                            }
-                            "percent" => buf
-                                .write_fmt(format_args!("{:.*}", 0, state.fraction() * 100f32))
-                                .unwrap(),
-                            "bytes" => buf.write_fmt(format_args!("{}", HumanBytes(pos))).unwrap(),
-                            "total_bytes" => {
-                                buf.write_fmt(format_args!("{}", HumanBytes(len))).unwrap();
-                            }
-                            "decimal_bytes" => buf
-                                .write_fmt(format_args!("{}", DecimalBytes(pos)))
-                                .unwrap(),
-                            "decimal_total_bytes" => buf
-                                .write_fmt(format_args!("{}", DecimalBytes(len)))
-                                .unwrap(),
-                            "binary_bytes" => {
-                                buf.write_fmt(format_args!("{}", BinaryBytes(pos))).unwrap();
-                            }
-                            "binary_total_bytes" => {
-                                buf.write_fmt(format_args!("{}", BinaryBytes(len))).unwrap();
-                            }
-                            "elapsed_precise" => buf
-                                .write_fmt(format_args!("{}", FormattedDuration(state.elapsed())))
-                                .unwrap(),
-                            "elapsed" => buf
-                                .write_fmt(format_args!("{:#}", HumanDuration(state.elapsed())))
-                                .unwrap(),
-                            "per_sec" => buf
-                                .write_fmt(format_args!("{}/s", HumanFloatCount(state.per_sec())))
-                                .unwrap(),
-                            "bytes_per_sec" => buf
-                                .write_fmt(format_args!("{}/s", HumanBytes(state.per_sec() as u64)))
-                                .unwrap(),
-                            "binary_bytes_per_sec" => buf
-                                .write_fmt(format_args!(
-                                    "{}/s",
-                                    BinaryBytes(state.per_sec() as u64)
-                                ))
-                                .unwrap(),
-                            "eta_precise" => buf
-                                .write_fmt(format_args!("{}", FormattedDuration(state.eta())))
-                                .unwrap(),
-                            "eta" => buf
-                                .write_fmt(format_args!("{:#}", HumanDuration(state.eta())))
-                                .unwrap(),
-                            "duration_precise" => buf
-                                .write_fmt(format_args!("{}", FormattedDuration(state.duration())))
-                                .unwrap(),
-                            "duration" => buf
-                                .write_fmt(format_args!("{:#}", HumanDuration(state.duration())))
-                                .unwrap(),
-                            _ => (),
-                        }
-                    };
-
-                    match width {
-                        Some(width) => {
-                            let padded = PaddedStringDisplay {
-                                str: &buf,
-                                width: *width as usize,
-                                align: *align,
-                                truncate: *truncate,
-                            };
-                            match style {
-                                Some(s) => cur
-                                    .write_fmt(format_args!("{}", s.apply_to(padded)))
-                                    .unwrap(),
-                                None => cur.write_fmt(format_args!("{padded}")).unwrap(),
-                            }
-                        }
-                        None => match style {
-                            Some(s) => cur.write_fmt(format_args!("{}", s.apply_to(&buf))).unwrap(),
-                            None => cur.push_str(&buf),
-                        },
-                    }
-                }
-                TemplatePart::Literal(s) => cur.push_str(s.expanded()),
-                TemplatePart::NewLine => {
-                    self.push_line(lines, &mut cur, state, &mut buf, target_width, &wide);
-                }
-            }
-        }
-
-        if !cur.is_empty() {
-            self.push_line(lines, &mut cur, state, &mut buf, target_width, &wide);
-        }
-    }
-
-    fn push_line(
-        &self,
-        lines: &mut Vec<String>,
-        cur: &mut String,
-        state: &ProgressState,
-        buf: &mut String,
-        target_width: u16,
-        wide: &Option<WideElement>,
-    ) {
-        let expanded = match wide {
-            Some(inner) => inner.expand(mem::take(cur), self, state, buf, target_width),
-            None => mem::take(cur),
-        };
-
-        // If there are newlines, we need to split them up
-        // and add the lines separately so that they're counted
-        // correctly on re-render.
-        for (i, line) in expanded.split('\n').enumerate() {
-            // No newlines found in this case
-            if i == 0 && line.len() == expanded.len() {
-                lines.push(expanded);
-                break;
-            }
-
-            lines.push(line.to_string());
-        }
-    }
-}
-
-struct TabRewriter<'a>(&'a mut dyn fmt::Write, usize);
-
-impl Write for TabRewriter<'_> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.0
-            .write_str(s.replace('\t', &" ".repeat(self.1)).as_str())
-    }
-}
-
-#[derive(Clone, Copy)]
-enum WideElement<'a> {
-    Bar { alt_style: &'a Option<Style> },
-    Message { align: &'a Alignment },
-}
-
-impl<'a> WideElement<'a> {
-    fn expand(
-        self,
-        cur: String,
-        style: &ProgressStyle,
-        state: &ProgressState,
-        buf: &mut String,
-        width: u16,
-    ) -> String {
-        let left = (width as usize).saturating_sub(measure_text_width(&cur.replace('\x00', "")));
-        match self {
-            Self::Bar { alt_style } => cur.replace(
-                '\x00',
-                &format!(
-                    "{}",
-                    style.format_bar(state.fraction(), left, alt_style.as_ref())
-                ),
-            ),
-            WideElement::Message { align } => {
-                buf.clear();
-                buf.write_fmt(format_args!(
-                    "{}",
-                    PaddedStringDisplay {
-                        str: state.message.expanded(),
-                        width: left,
-                        align: *align,
-                        truncate: true,
-                    }
-                ))
-                .unwrap();
-
-                let trimmed = match cur.as_bytes().last() == Some(&b'\x00') {
-                    true => buf.trim_end(),
-                    false => buf,
-                };
-
-                cur.replace('\x00', trimmed)
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-struct Template {
-    parts: Vec<TemplatePart>,
-}
-
-impl Template {
-    fn from_str_with_tab_width(s: &str, tab_width: usize) -> Result<Self, TemplateError> {
-        use State::*;
-        let (mut state, mut parts, mut buf) = (Literal, vec![], String::new());
-        for c in s.chars() {
-            let new = match (state, c) {
-                (Literal, '{') => (MaybeOpen, None),
-                (Literal, '\n') => {
-                    if !buf.is_empty() {
-                        parts.push(TemplatePart::Literal(TabExpandedString::new(
-                            mem::take(&mut buf).into(),
-                            tab_width,
-                        )));
-                    }
-                    parts.push(TemplatePart::NewLine);
-                    (Literal, None)
-                }
-                (Literal, '}') => (DoubleClose, Some('}')),
-                (Literal, c) => (Literal, Some(c)),
-                (DoubleClose, '}') => (Literal, None),
-                (MaybeOpen, '{') => (Literal, Some('{')),
-                (MaybeOpen | Key, c) if c.is_ascii_whitespace() => {
-                    // If we find whitespace where the variable key is supposed to go,
-                    // backtrack and act as if this was a literal.
-                    buf.push(c);
-                    let mut new = String::from("{");
-                    new.push_str(&buf);
-                    buf.clear();
-                    parts.push(TemplatePart::Literal(TabExpandedString::new(
-                        new.into(),
-                        tab_width,
-                    )));
-                    (Literal, None)
-                }
-                (MaybeOpen, c) if c != '}' && c != ':' => (Key, Some(c)),
-                (Key, c) if c != '}' && c != ':' => (Key, Some(c)),
-                (Key, ':') => (Align, None),
-                (Key, '}') => (Literal, None),
-                (Key, '!') if !buf.is_empty() => {
-                    parts.push(TemplatePart::Placeholder {
-                        key: mem::take(&mut buf),
-                        align: Alignment::Left,
-                        width: None,
-                        truncate: true,
-                        style: None,
-                        alt_style: None,
-                    });
-                    (Width, None)
-                }
-                (Align, c) if c == '<' || c == '^' || c == '>' => {
-                    if let Some(TemplatePart::Placeholder { align, .. }) = parts.last_mut() {
-                        match c {
-                            '<' => *align = Alignment::Left,
-                            '^' => *align = Alignment::Center,
-                            '>' => *align = Alignment::Right,
-                            _ => (),
-                        }
-                    }
-
-                    (Width, None)
-                }
-                (Align, c @ '0'..='9') => (Width, Some(c)),
-                (Align | Width, '!') => {
-                    if let Some(TemplatePart::Placeholder { truncate, .. }) = parts.last_mut() {
-                        *truncate = true;
-                    }
-                    (Width, None)
-                }
-                (Align, '.') => (FirstStyle, None),
-                (Align, '}') => (Literal, None),
-                (Width, c @ '0'..='9') => (Width, Some(c)),
-                (Width, '.') => (FirstStyle, None),
-                (Width, '}') => (Literal, None),
-                (FirstStyle, '/') => (AltStyle, None),
-                (FirstStyle, '}') => (Literal, None),
-                (FirstStyle, c) => (FirstStyle, Some(c)),
-                (AltStyle, '}') => (Literal, None),
-                (AltStyle, c) => (AltStyle, Some(c)),
-                (st, c) => return Err(TemplateError { next: c, state: st }),
-            };
-
-            match (state, new.0) {
-                (MaybeOpen, Key) if !buf.is_empty() => parts.push(TemplatePart::Literal(
-                    TabExpandedString::new(mem::take(&mut buf).into(), tab_width),
-                )),
-                (Key, Align | Literal) if !buf.is_empty() => {
-                    parts.push(TemplatePart::Placeholder {
-                        key: mem::take(&mut buf),
-                        align: Alignment::Left,
-                        width: None,
-                        truncate: false,
-                        style: None,
-                        alt_style: None,
-                    });
-                }
-                (Width, FirstStyle | Literal) if !buf.is_empty() => {
-                    if let Some(TemplatePart::Placeholder { width, .. }) = parts.last_mut() {
-                        *width = Some(buf.parse().unwrap());
-                        buf.clear();
-                    }
-                }
-                (FirstStyle, AltStyle | Literal) if !buf.is_empty() => {
-                    if let Some(TemplatePart::Placeholder { style, .. }) = parts.last_mut() {
-                        *style = Some(Style::from_dotted_str(&buf));
-                        buf.clear();
-                    }
-                }
-                (AltStyle, Literal) if !buf.is_empty() => {
-                    if let Some(TemplatePart::Placeholder { alt_style, .. }) = parts.last_mut() {
-                        *alt_style = Some(Style::from_dotted_str(&buf));
-                        buf.clear();
-                    }
-                }
-                (_, _) => (),
-            }
-
-            state = new.0;
-            if let Some(c) = new.1 {
-                buf.push(c);
-            }
-        }
-
-        if matches!(state, Literal | DoubleClose) && !buf.is_empty() {
-            parts.push(TemplatePart::Literal(TabExpandedString::new(
-                buf.into(),
-                tab_width,
-            )));
-        }
-
-        Ok(Self { parts })
-    }
-
-    fn from_str(s: &str) -> Result<Self, TemplateError> {
-        Self::from_str_with_tab_width(s, DEFAULT_TAB_WIDTH)
-    }
-
-    fn set_tab_width(&mut self, new_tab_width: usize) {
-        for part in &mut self.parts {
-            if let TemplatePart::Literal(s) = part {
-                s.set_tab_width(new_tab_width);
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct TemplateError {
-    state: State,
-    next: char,
-}
-
-impl fmt::Display for TemplateError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "TemplateError: unexpected character {:?} in state {:?}",
-            self.next, self.state
-        )
-    }
-}
-
-impl std::error::Error for TemplateError {}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-enum TemplatePart {
-    Literal(TabExpandedString),
-    Placeholder {
-        key: String,
-        align: Alignment,
-        width: Option<u16>,
-        truncate: bool,
-        style: Option<Style>,
-        alt_style: Option<Style>,
-    },
-    NewLine,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum State {
-    Literal,
-    MaybeOpen,
-    DoubleClose,
-    Key,
-    Align,
-    Width,
-    FirstStyle,
-    AltStyle,
-}
-
-struct BarDisplay<'a> {
-    chars: &'a [Box<str>],
-    filled: usize,
-    cur: Option<usize>,
-    rest: console::StyledObject<RepeatedStringDisplay<'a>>,
-}
-
-impl<'a> fmt::Display for BarDisplay<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for _ in 0..self.filled {
-            f.write_str(&self.chars[0])?;
-        }
-        if let Some(cur) = self.cur {
-            f.write_str(&self.chars[cur])?;
-        }
-        self.rest.fmt(f)
-    }
-}
-
-struct RepeatedStringDisplay<'a> {
-    str: &'a str,
-    num: usize,
-}
-
-impl<'a> fmt::Display for RepeatedStringDisplay<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for _ in 0..self.num {
-            f.write_str(self.str)?;
-        }
-        Ok(())
-    }
-}
-
-struct PaddedStringDisplay<'a> {
-    str: &'a str,
-    width: usize,
-    align: Alignment,
-    truncate: bool,
-}
-
-impl<'a> fmt::Display for PaddedStringDisplay<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let cols = measure_text_width(self.str);
-        let excess = cols.saturating_sub(self.width);
-        if excess > 0 && !self.truncate {
-            return f.write_str(self.str);
-        } else if excess > 0 {
-            let (start, end) = match self.align {
-                Alignment::Left => (0, self.str.len() - excess),
-                Alignment::Right => (excess, self.str.len()),
-                Alignment::Center => (
-                    excess / 2,
-                    self.str.len() - excess.saturating_sub(excess / 2),
-                ),
-            };
-
-            return f.write_str(self.str.get(start..end).unwrap_or(self.str));
-        }
-
-        let diff = self.width.saturating_sub(cols);
-        let (left_pad, right_pad) = match self.align {
-            Alignment::Left => (0, diff),
-            Alignment::Right => (diff, 0),
-            Alignment::Center => (diff / 2, diff.saturating_sub(diff / 2)),
-        };
-
-        for _ in 0..left_pad {
-            f.write_char(' ')?;
-        }
-        f.write_str(self.str)?;
-        for _ in 0..right_pad {
-            f.write_char(' ')?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(PartialEq, Eq, Debug, Copy, Clone)]
-enum Alignment {
-    Left,
-    Center,
-    Right,
-}
-
-/// Trait for defining stateful or stateless formatters
-pub trait ProgressTracker: Send + Sync {
-    /// Creates a new instance of the progress tracker
-    fn clone_box(&self) -> Box<dyn ProgressTracker>;
-    /// Notifies the progress tracker of a tick event
-    fn tick(&mut self, state: &ProgressState, now: Instant);
-    /// Notifies the progress tracker of a reset event
-    fn reset(&mut self, state: &ProgressState, now: Instant);
-    /// Provides access to the progress bar display buffer for custom messages
-    fn write(&self, state: &ProgressState, w: &mut dyn fmt::Write);
-}
-
-impl Clone for Box<dyn ProgressTracker> {
-    fn clone(&self) -> Self {
-        self.clone_box()
-    }
-}
-
-impl<F> ProgressTracker for F
-where
-    F: Fn(&ProgressState, &mut dyn fmt::Write) + Send + Sync + Clone + 'static,
-{
-    fn clone_box(&self) -> Box<dyn ProgressTracker> {
-        Box::new(self.clone())
-    }
-
-    fn tick(&mut self, _: &ProgressState, _: Instant) {}
-
-    fn reset(&mut self, _: &ProgressState, _: Instant) {}
-
-    fn write(&self, state: &ProgressState, w: &mut dyn fmt::Write) {
-        (self)(state, w);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use super::*;
-    use crate::state::{AtomicPosition, ProgressState};
-    use std::sync::Mutex;
-
-    #[test]
-    fn test_stateful_tracker() {
-        #[derive(Debug, Clone)]
-        struct TestTracker(Arc<Mutex<String>>);
-
-        impl ProgressTracker for TestTracker {
-            fn clone_box(&self) -> Box<dyn ProgressTracker> {
-                Box::new(self.clone())
-            }
-
-            fn tick(&mut self, state: &ProgressState, _: Instant) {
-                let mut m = self.0.lock().unwrap();
-                m.clear();
-                m.push_str(format!("{} {}", state.len().unwrap(), state.pos()).as_str());
-            }
-
-            fn reset(&mut self, _state: &ProgressState, _: Instant) {
-                let mut m = self.0.lock().unwrap();
-                m.clear();
-            }
-
-            fn write(&self, _state: &ProgressState, w: &mut dyn fmt::Write) {
-                w.write_str(self.0.lock().unwrap().as_str()).unwrap();
-            }
-        }
-
-        use crate::ProgressBar;
-
-        let pb = ProgressBar::new(1);
-        pb.set_style(
-            ProgressStyle::with_template("{{ {foo} }}")
-                .unwrap()
-                .with_key("foo", TestTracker(Arc::new(Mutex::new(String::default()))))
-                .progress_chars("#>-"),
-        );
-
-        let mut buf = Vec::new();
-        let style = pb.clone().style();
-
-        style.format_state(&pb.state().state, &mut buf, 16);
-        assert_eq!(&buf[0], "{  }");
-        buf.clear();
-        pb.inc(1);
-        style.format_state(&pb.state().state, &mut buf, 16);
-        assert_eq!(&buf[0], "{ 1 1 }");
-        pb.reset();
-        buf.clear();
-        style.format_state(&pb.state().state, &mut buf, 16);
-        assert_eq!(&buf[0], "{  }");
-        pb.finish_and_clear();
-    }
-
-    use crate::state::TabExpandedString;
-
-    #[test]
-    fn test_expand_template() {
-        const WIDTH: u16 = 80;
-        let pos = Arc::new(AtomicPosition::new());
-        let state = ProgressState::new(Some(10), pos);
-        let mut buf = Vec::new();
-
-        let mut style = ProgressStyle::default_bar();
-        style.format_map.insert(
-            "foo",
-            Box::new(|_: &ProgressState, w: &mut dyn Write| write!(w, "FOO").unwrap()),
-        );
-        style.format_map.insert(
-            "bar",
-            Box::new(|_: &ProgressState, w: &mut dyn Write| write!(w, "BAR").unwrap()),
-        );
-
-        style.template = Template::from_str("{{ {foo} {bar} }}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "{ FOO BAR }");
-
-        buf.clear();
-        style.template = Template::from_str(r#"{ "foo": "{foo}", "bar": {bar} }"#).unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], r#"{ "foo": "FOO", "bar": BAR }"#);
-    }
-
-    #[test]
-    fn test_expand_template_flags() {
-        use console::set_colors_enabled;
-        set_colors_enabled(true);
-
-        const WIDTH: u16 = 80;
-        let pos = Arc::new(AtomicPosition::new());
-        let state = ProgressState::new(Some(10), pos);
-        let mut buf = Vec::new();
-
-        let mut style = ProgressStyle::default_bar();
-        style.format_map.insert(
-            "foo",
-            Box::new(|_: &ProgressState, w: &mut dyn Write| write!(w, "XXX").unwrap()),
-        );
-
-        style.template = Template::from_str("{foo:5}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "XXX  ");
-
-        buf.clear();
-        style.template = Template::from_str("{foo:.red.on_blue}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "\u{1b}[31m\u{1b}[44mXXX\u{1b}[0m");
-
-        buf.clear();
-        style.template = Template::from_str("{foo:^5.red.on_blue}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
-
-        buf.clear();
-        style.template = Template::from_str("{foo:^5.red.on_blue/green.on_cyan}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
-    }
-
-    #[test]
-    fn align_truncation() {
-        const WIDTH: u16 = 10;
-        let pos = Arc::new(AtomicPosition::new());
-        let mut state = ProgressState::new(Some(10), pos);
-        let mut buf = Vec::new();
-
-        let style = ProgressStyle::with_template("{wide_msg}").unwrap();
-        state.message = TabExpandedString::NoTabs("abcdefghijklmnopqrst".into());
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "abcdefghij");
-
-        buf.clear();
-        let style = ProgressStyle::with_template("{wide_msg:>}").unwrap();
-        state.message = TabExpandedString::NoTabs("abcdefghijklmnopqrst".into());
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "klmnopqrst");
-
-        buf.clear();
-        let style = ProgressStyle::with_template("{wide_msg:^}").unwrap();
-        state.message = TabExpandedString::NoTabs("abcdefghijklmnopqrst".into());
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "fghijklmno");
-    }
-
-    #[test]
-    fn wide_element_style() {
-        const CHARS: &str = "=>-";
-        const WIDTH: u16 = 8;
-        let pos = Arc::new(AtomicPosition::new());
-        // half finished
-        pos.set(2);
-        let mut state = ProgressState::new(Some(4), pos);
-        let mut buf = Vec::new();
-
-        let style = ProgressStyle::with_template("{wide_bar}")
-            .unwrap()
-            .progress_chars(CHARS);
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "====>---");
-
-        buf.clear();
-        let style = ProgressStyle::with_template("{wide_bar:.red.on_blue/green.on_cyan}")
-            .unwrap()
-            .progress_chars(CHARS);
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(
-            &buf[0],
-            "\u{1b}[31m\u{1b}[44m====>\u{1b}[32m\u{1b}[46m---\u{1b}[0m\u{1b}[0m"
-        );
-
-        buf.clear();
-        let style = ProgressStyle::with_template("{wide_msg:^.red.on_blue}").unwrap();
-        state.message = TabExpandedString::NoTabs("foobar".into());
-        style.format_state(&state, &mut buf, WIDTH);
-        assert_eq!(&buf[0], "\u{1b}[31m\u{1b}[44m foobar \u{1b}[0m");
-    }
-
-    #[test]
-    fn multiline_handling() {
-        const WIDTH: u16 = 80;
-        let pos = Arc::new(AtomicPosition::new());
-        let mut state = ProgressState::new(Some(10), pos);
-        let mut buf = Vec::new();
-
-        let mut style = ProgressStyle::default_bar();
-        state.message = TabExpandedString::new("foo\nbar\nbaz".into(), 2);
-        style.template = Template::from_str("{msg}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-
-        assert_eq!(buf.len(), 3);
-        assert_eq!(&buf[0], "foo");
-        assert_eq!(&buf[1], "bar");
-        assert_eq!(&buf[2], "baz");
-
-        buf.clear();
-        style.template = Template::from_str("{wide_msg}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-
-        assert_eq!(buf.len(), 3);
-        assert_eq!(&buf[0], "foo");
-        assert_eq!(&buf[1], "bar");
-        assert_eq!(&buf[2], "baz");
-
-        buf.clear();
-        state.prefix = TabExpandedString::new("prefix\nprefix".into(), 2);
-        style.template = Template::from_str("{prefix} {wide_msg}").unwrap();
-        style.format_state(&state, &mut buf, WIDTH);
-
-        assert_eq!(buf.len(), 4);
-        assert_eq!(&buf[0], "prefix");
-        assert_eq!(&buf[1], "prefix foo");
-        assert_eq!(&buf[2], "bar");
-        assert_eq!(&buf[3], "baz");
-    }
-}
diff --git a/vendor/indicatif/src/term_like.rs b/vendor/indicatif/src/term_like.rs
deleted file mode 100644
index b489b65..0000000
--- a/vendor/indicatif/src/term_like.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use std::fmt::Debug;
-use std::io;
-
-use console::Term;
-
-/// A trait for minimal terminal-like behavior.
-///
-/// Anything that implements this trait can be used a draw target via [`ProgressDrawTarget::term_like`].
-///
-/// [`ProgressDrawTarget::term_like`]: crate::ProgressDrawTarget::term_like
-pub trait TermLike: Debug + Send + Sync {
-    /// Return the terminal width
-    fn width(&self) -> u16;
-    /// Return the terminal height
-    fn height(&self) -> u16 {
-        // FIXME: remove this default impl in the next major version bump
-        20 // sensible default
-    }
-
-    /// Move the cursor up by `n` lines
-    fn move_cursor_up(&self, n: usize) -> io::Result<()>;
-    /// Move the cursor down by `n` lines
-    fn move_cursor_down(&self, n: usize) -> io::Result<()>;
-    /// Move the cursor right by `n` chars
-    fn move_cursor_right(&self, n: usize) -> io::Result<()>;
-    /// Move the cursor left by `n` chars
-    fn move_cursor_left(&self, n: usize) -> io::Result<()>;
-
-    /// Write a string and add a newline.
-    fn write_line(&self, s: &str) -> io::Result<()>;
-    /// Write a string
-    fn write_str(&self, s: &str) -> io::Result<()>;
-    /// Clear the current line and reset the cursor to beginning of the line
-    fn clear_line(&self) -> io::Result<()>;
-
-    fn flush(&self) -> io::Result<()>;
-}
-
-impl TermLike for Term {
-    fn width(&self) -> u16 {
-        self.size().1
-    }
-
-    fn height(&self) -> u16 {
-        self.size().0
-    }
-
-    fn move_cursor_up(&self, n: usize) -> io::Result<()> {
-        self.move_cursor_up(n)
-    }
-
-    fn move_cursor_down(&self, n: usize) -> io::Result<()> {
-        self.move_cursor_down(n)
-    }
-
-    fn move_cursor_right(&self, n: usize) -> io::Result<()> {
-        self.move_cursor_right(n)
-    }
-
-    fn move_cursor_left(&self, n: usize) -> io::Result<()> {
-        self.move_cursor_left(n)
-    }
-
-    fn write_line(&self, s: &str) -> io::Result<()> {
-        self.write_line(s)
-    }
-
-    fn write_str(&self, s: &str) -> io::Result<()> {
-        self.write_str(s)
-    }
-
-    fn clear_line(&self) -> io::Result<()> {
-        self.clear_line()
-    }
-
-    fn flush(&self) -> io::Result<()> {
-        self.flush()
-    }
-}