use crate::InlineHiddenTagParser;use crate::InlineTagSpec;use crate::StreamTextChunk;use crate::StreamTextParser;#[derive(Debug, Clone, Copy, PartialEq, Eq)]enum CitationTag {    Citation,}const CITATION_OPEN: &str = "<oai-mem-citation>";const CITATION_CLOSE: &str = "</oai-mem-citation>";/// Stream parser for `<oai-mem-citation>...</oai-mem-citation>` tags.////// This is a thin convenience wrapper around [`InlineHiddenTagParser`]. It returns citation bodies/// as plain strings and omits the citation tags from visible text.////// Matching is literal and non-nested. If EOF is reached before a closing/// `</oai-mem-citation>`, the parser auto-closes the tag and returns the buffered body as an/// extracted citation.#[derive(Debug)]pub struct CitationStreamParser {    inner: InlineHiddenTagParser<CitationTag>,}impl CitationStreamParser {    pub fn new() -> Self {        Self {            inner: InlineHiddenTagParser::new(vec![InlineTagSpec {                tag: CitationTag::Citation,                open: CITATION_OPEN,                close: CITATION_CLOSE,            }]),        }    }}impl Default for CitationStreamParser {    fn default() -> Self {        Self::new()    }}impl StreamTextParser for CitationStreamParser {    type Extracted = String;    fn push_str(&mut self, chunk: &str) -> StreamTextChunk<Self::Extracted> {        let inner = self.inner.push_str(chunk);        StreamTextChunk {            visible_text: inner.visible_text,            extracted: inner.extracted.into_iter().map(|tag| tag.content).collect(),        }    }    fn finish(&mut self) -> StreamTextChunk<Self::Extracted> {        let inner = self.inner.finish();        StreamTextChunk {            visible_text: inner.visible_text,            extracted: inner.extracted.into_iter().map(|tag| tag.content).collect(),        }    }}/// Strip citation tags from a complete string and return `(visible_text, citations)`.////// This uses [`CitationStreamParser`] internally, so it inherits the same semantics:/// literal, non-nested matching and auto-closing unterminated citations at EOF.pub fn strip_citations(text: &str) -> (String, Vec<String>) {    let mut parser = CitationStreamParser::new();    let mut out = parser.push_str(text);    let tail = parser.finish();    out.visible_text.push_str(&tail.visible_text);    out.extracted.extend(tail.extracted);    (out.visible_text, out.extracted)}#[cfg(test)]mod tests {    use super::CitationStreamParser;    use super::strip_citations;    use crate::StreamTextChunk;    use crate::StreamTextParser;    use pretty_assertions::assert_eq;    fn collect_chunks<P>(parser: &mut P, chunks: &[&str]) -> StreamTextChunk<P::Extracted>    where        P: StreamTextParser,    {        let mut all = StreamTextChunk::default();        for chunk in chunks {            let next = parser.push_str(chunk);            all.visible_text.push_str(&next.visible_text);            all.extracted.extend(next.extracted);        }        let tail = parser.finish();        all.visible_text.push_str(&tail.visible_text);        all.extracted.extend(tail.extracted);        all    }    #[test]    fn citation_parser_streams_across_chunk_boundaries() {        let mut parser = CitationStreamParser::new();        let out = collect_chunks(            &mut parser,            &[                "Hello <oai-mem-",                "citation>source A</oai-mem-",                "citation> world",            ],        );        assert_eq!(out.visible_text, "Hello  world");        assert_eq!(out.extracted, vec!["source A".to_string()]);    }    #[test]    fn citation_parser_buffers_partial_open_tag_prefix() {        let mut parser = CitationStreamParser::new();        let first = parser.push_str("abc <oai-mem-");        assert_eq!(first.visible_text, "abc ");        assert_eq!(first.extracted, Vec::<String>::new());        let second = parser.push_str("citation>x</oai-mem-citation>z");        let tail = parser.finish();        assert_eq!(second.visible_text, "z");        assert_eq!(second.extracted, vec!["x".to_string()]);        assert!(tail.is_empty());    }    #[test]    fn citation_parser_auto_closes_unterminated_tag_on_finish() {        let mut parser = CitationStreamParser::new();        let out = collect_chunks(&mut parser, &["x<oai-mem-citation>source"]);        assert_eq!(out.visible_text, "x");        assert_eq!(out.extracted, vec!["source".to_string()]);    }    #[test]    fn citation_parser_preserves_partial_open_tag_at_eof_if_not_a_full_tag() {        let mut parser = CitationStreamParser::new();        let out = collect_chunks(&mut parser, &["hello <oai-mem-"]);        assert_eq!(out.visible_text, "hello <oai-mem-");        assert_eq!(out.extracted, Vec::<String>::new());    }    #[test]    fn strip_citations_collects_all_citations() {        let (visible, citations) = strip_citations(            "a<oai-mem-citation>one</oai-mem-citation>b<oai-mem-citation>two</oai-mem-citation>c",        );        assert_eq!(visible, "abc");        assert_eq!(citations, vec!["one".to_string(), "two".to_string()]);    }    #[test]    fn strip_citations_auto_closes_unterminated_citation_at_eof() {        let (visible, citations) = strip_citations("x<oai-mem-citation>y");        assert_eq!(visible, "x");        assert_eq!(citations, vec!["y".to_string()]);    }    #[test]    fn citation_parser_does_not_support_nested_tags() {        let (visible, citations) = strip_citations(            "a<oai-mem-citation>x<oai-mem-citation>y</oai-mem-citation>z</oai-mem-citation>b",        );        assert_eq!(visible, "az</oai-mem-citation>b");        assert_eq!(citations, vec!["x<oai-mem-citation>y".to_string()]);    }}