use bstr::{BStr, BString, ByteSlice}; use crate::{File, file::SectionRef, parse::Event}; impl File {    /// Serialize this type into a `BString` for convenience.    ///    /// Note that `to_string()` can also be used, but might not be lossless.    #[must_use]    pub fn to_bstring(&self) -> BString {        let mut buf = Vec::new();        self.write_to(&mut buf).expect("io error impossible");        buf.into()    }     /// Stream ourselves to the given `out` in order to reproduce this file mostly losslessly    /// as it was parsed, while writing only sections for which `filter` returns true.    pub fn write_to_filter(        &self,        mut out: &mut dyn std::io::Write,        mut filter: impl FnMut(&SectionRef<'_>) -> bool,    ) -> std::io::Result<()> {        let nl = self.detect_newline_style();         {            for event in self.frontmatter_events.as_ref() {                event.write_to_in(&self.backing, &mut out)?;            }             if !ends_with_newline(self.frontmatter_events.as_ref(), &self.backing, nl, true)                && self                    .sections                    .values()                    .map(|section| SectionRef::from_data(section, &self.backing))                    .any(|section| filter(&section))            {                out.write_all(nl)?;            }        }         let mut prev_section_ended_with_newline = true;        for section_id in &self.section_order {            if !prev_section_ended_with_newline {                out.write_all(nl)?;            }            let section_data = self.sections.get(section_id).expect("known section-id");            let section = SectionRef::from_data(section_data, &self.backing);            if !filter(&section) {                continue;            }            section.write_to(&mut *out)?;             prev_section_ended_with_newline = ends_with_newline(section_data.body.0.as_ref(), &self.backing, nl, false);            if let Some(post_matter) = self.frontmatter_post_section.get(section_id) {                if !prev_section_ended_with_newline {                    out.write_all(nl)?;                }                for event in post_matter {                    event.write_to_in(&self.backing, &mut out)?;                }                prev_section_ended_with_newline =                    ends_with_newline(post_matter, &self.backing, nl, prev_section_ended_with_newline);            }        }         if !prev_section_ended_with_newline {            out.write_all(nl)?;        }         Ok(())    }     /// Stream ourselves to the given `out`, in order to reproduce this file mostly losslessly    /// as it was parsed.    pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {        self.write_to_filter(out, |_| true)    }} pub(crate) fn ends_with_newline(    e: &[crate::parse::Event],    backing: &[u8],    nl: impl AsRef<[u8]>,    default: bool,) -> bool {    if e.is_empty() {        return default;    }    e.iter()        .rev()        .take_while(|e| e.to_bstr_lossy_in(backing).iter().all(u8::is_ascii_whitespace))        .find_map(|e| e.to_bstr_lossy_in(backing).contains_str(nl.as_ref()).then_some(true))        .unwrap_or(false)} pub(crate) fn extract_newline<'a>(e: &'a Event, backing: &'a [u8]) -> Option<&'a BStr> {    Some(match e {        Event::Newline(b) => {            let nl = b.as_slice_in(backing);             // Newlines are parsed consecutively, be sure we only take the smallest possible variant            if nl.contains(&b'\r') {                "\r\n".into()            } else {                "\n".into()            }        }        _ => return None,    })} pub(crate) fn platform_newline() -> &'static BStr {    if cfg!(windows) { "\r\n" } else { "\n" }.into()}