diff --git a/fuzz/test_case/src/lib.rs b/fuzz/test_case/src/lib.rs
index 70f01632..98a2d96f 100644
--- a/fuzz/test_case/src/lib.rs
+++ b/fuzz/test_case/src/lib.rs
@@ -11,7 +11,8 @@ use std::ffi::{CStr, CString};
 
 use encoding_rs::*;
 use lol_html::html_content::ContentType;
-use lol_html::{comments, doc_comments, doc_text, element, text, HtmlRewriter, MemorySettings, Settings};
+use lol_html::{comments, doc_comments, doc_text, element, streaming, text};
+use lol_html::{HtmlRewriter, MemorySettings, Settings};
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
@@ -111,10 +112,12 @@ fn run_rewriter_iter(data: &[u8], selector: &str, encoding: &'static Encoding) {
                         &format!("<!--[/ELEMENT('{selector}')]-->"),
                         ContentType::Html,
                     );
-                    el.set_inner_content(
-                        &format!("<!--Replaced ({selector}) -->"),
-                        ContentType::Html,
-                    );
+
+                    let replaced = format!("<!--Replaced ({selector}) -->");
+                    el.streaming_set_inner_content(streaming!(move |sink| {
+                        sink.write_str(&replaced, ContentType::Html);
+                        Ok(())
+                    }));
 
                     Ok(())
                 }),
diff --git a/src/lib.rs b/src/lib.rs
index 398a829b..0e7e0a90 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -86,7 +86,9 @@ pub mod send {
 pub mod errors {
     pub use super::memory::MemoryLimitExceededError;
     pub use super::parser::ParsingAmbiguityError;
-    pub use super::rewritable_units::{AttributeNameError, CommentTextError, TagNameError};
+    pub use super::rewritable_units::{
+        AttributeNameError, CommentTextError, TagNameError, Utf8Error,
+    };
     pub use super::rewriter::RewritingError;
     pub use super::selectors_vm::SelectorError;
 }
@@ -95,7 +97,7 @@ pub mod errors {
 pub mod html_content {
     pub use super::rewritable_units::{
         Attribute, Comment, ContentType, Doctype, DocumentEnd, Element, EndTag, StartTag,
-        TextChunk, UserData,
+        StreamingHandler, StreamingHandlerSink, TextChunk, UserData,
     };
 
     pub use super::html::TextType;
diff --git a/src/rewritable_units/document_end.rs b/src/rewritable_units/document_end.rs
index 7075a41c..4458157c 100644
--- a/src/rewritable_units/document_end.rs
+++ b/src/rewritable_units/document_end.rs
@@ -1,5 +1,4 @@
-use super::text_encoder::StreamingHandlerSink;
-use super::ContentType;
+use super::{ContentType, StreamingHandlerSink};
 use encoding_rs::Encoding;
 
 use crate::transform_stream::OutputSink;
@@ -53,7 +52,7 @@ impl<'a> DocumentEnd<'a> {
         StreamingHandlerSink::new(self.encoding, &mut |c| {
             self.output_sink.handle_chunk(c);
         })
-        .write_str_chunk(content, content_type);
+        .write_str(content, content_type);
     }
 }
 
diff --git a/src/rewritable_units/element.rs b/src/rewritable_units/element.rs
index 6f5c8905..cb98959a 100644
--- a/src/rewritable_units/element.rs
+++ b/src/rewritable_units/element.rs
@@ -1,4 +1,7 @@
-use super::{Attribute, AttributeNameError, ContentType, EndTag, Mutations, StartTag, StringChunk};
+use super::{
+    Attribute, AttributeNameError, ContentType, EndTag, Mutations, StartTag, StreamingHandler,
+    StringChunk,
+};
 use crate::base::Bytes;
 use crate::rewriter::{HandlerTypes, LocalHandlerTypes};
 use encoding_rs::Encoding;
@@ -240,6 +243,18 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
             .push_back((content, content_type).into());
     }
 
+    /// Inserts  content from a [`StreamingHandler`] before the element.
+    ///
+    /// Consequent calls to the method append to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_before(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.start_tag
+            .mutations
+            .content_before
+            .push_back(string_writer.into());
+    }
+
     /// Inserts `content` after the element.
     ///
     /// Consequent calls to the method prepend `content` to the previously inserted content.
@@ -282,6 +297,16 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
         .push_front(chunk);
     }
 
+    /// Inserts content from a [`StreamingHandler`] after the element.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    ///
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_after(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.after_chunk(string_writer.into());
+    }
+
     /// Prepends `content` to the element's inner content, i.e. inserts content right after
     /// the element's start tag.
     ///
@@ -328,6 +353,20 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
         }
     }
 
+    /// Prepends content from a [`StreamingHandler`] to the element's inner content,
+    /// i.e. inserts content right after the element's start tag.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    /// A call to the method doesn't make any effect if the element is an [empty element].
+    ///
+    /// [empty element]: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
+    ///
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_prepend(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.prepend_chunk(string_writer.into());
+    }
+
     /// Appends `content` to the element's inner content, i.e. inserts content right before
     /// the element's end tag.
     ///
@@ -374,6 +413,19 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
         }
     }
 
+    /// Appends content from a [`StreamingHandler`] to the element's inner content,
+    /// i.e. inserts content right before the element's end tag.
+    ///
+    /// Consequent calls to the method append to the previously inserted content.
+    /// A call to the method doesn't make any effect if the element is an [empty element].
+    ///
+    /// [empty element]: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_append(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.append_chunk(string_writer.into());
+    }
+
     /// Replaces inner content of the element with `content`.
     ///
     /// Consequent calls to the method overwrite previously inserted content.
@@ -420,6 +472,19 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
         }
     }
 
+    /// Replaces inner content of the element with content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previously inserted content.
+    /// A call to the method doesn't make any effect if the element is an [empty element].
+    ///
+    /// [empty element]: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
+    ///
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_set_inner_content(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.set_inner_content_chunk(string_writer.into());
+    }
+
     /// Replaces the element and its inner content with `content`.
     ///
     /// Consequent calls to the method overwrite previously inserted content.
@@ -461,6 +526,16 @@ impl<'r, 't, H: HandlerTypes> Element<'r, 't, H> {
         }
     }
 
+    /// Replaces the element and its inner content with content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previously inserted content.
+    ///
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_replace(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.replace_chunk(string_writer.into());
+    }
+
     /// Removes the element and its inner content.
     #[inline]
     pub fn remove(&mut self) {
@@ -629,6 +704,7 @@ mod tests {
     use crate::rewritable_units::test_utils::*;
     use crate::*;
     use encoding_rs::{Encoding, EUC_JP, UTF_8};
+    use rewritable_units::StreamingHandlerSink;
 
     fn rewrite_element(
         html: &[u8],
@@ -651,7 +727,11 @@ mod tests {
                     el.before("[before: should be removed]", ContentType::Text);
                     el.after("[after: should be removed]", ContentType::Text);
                     el.append("[append: should be removed]", ContentType::Text);
-                    el.before("[before: should be removed]", ContentType::Text);
+                    el.streaming_before(Box::new(|sink: &mut StreamingHandlerSink<'_>| {
+                        sink.write_str("[before:", ContentType::Text);
+                        sink.write_str(" should be removed]", ContentType::Text);
+                        Ok(())
+                    }));
                     Ok(())
                 }),
             ],
@@ -953,7 +1033,10 @@ mod tests {
             encoded("<div><span>Hi<inner-remove-me>RemoveŴ</inner-remove-me></span></div>")
         {
             let output = rewrite_element(&html, enc, "span", |el| {
-                el.prepend("<prepended>", ContentType::Html);
+                el.streaming_prepend(streaming!(|s| {
+                    s.write_utf8_chunk(b"<prepended>", ContentType::Html)?;
+                    Ok(())
+                }));
                 el.append("<appended>", ContentType::Html);
                 el.set_inner_content("<imgŵ>", ContentType::Html);
                 el.set_inner_content("<imgŵ>", ContentType::Text);
@@ -1087,7 +1170,17 @@ mod tests {
     #[test]
     fn self_closing_element() {
         let output = rewrite_element(b"<svg><foo/>Hi</foo></svg>", UTF_8, "foo", |el| {
-            el.after("<!--after-->", ContentType::Html);
+            el.after("->", ContentType::Html);
+            el.streaming_after(streaming!(|sink| {
+                sink.write_str("er-", ContentType::Html);
+                Ok(())
+            }));
+            el.after("t", ContentType::Html);
+            el.streaming_after(streaming!(|sink| {
+                sink.write_str("af", ContentType::Html);
+                Ok(())
+            }));
+            el.after("<!--", ContentType::Html);
             el.set_tag_name("bar").unwrap();
         });
 
diff --git a/src/rewritable_units/mod.rs b/src/rewritable_units/mod.rs
index 6843ab69..1df2b0b5 100644
--- a/src/rewritable_units/mod.rs
+++ b/src/rewritable_units/mod.rs
@@ -2,9 +2,9 @@ use std::any::Any;
 
 pub use self::document_end::*;
 pub use self::element::*;
-pub use self::mutations::ContentType;
+pub use self::mutations::{ContentType, StreamingHandler};
 pub(crate) use self::mutations::{Mutations, StringChunk};
-pub use self::text_encoder::StreamingHandlerSink;
+pub use self::text_encoder::{StreamingHandlerSink, Utf8Error};
 pub use self::tokens::*;
 
 /// Data that can be attached to a rewritable unit by a user and shared between content handler
diff --git a/src/rewritable_units/mutations.rs b/src/rewritable_units/mutations.rs
index 1d668ef7..38dab648 100644
--- a/src/rewritable_units/mutations.rs
+++ b/src/rewritable_units/mutations.rs
@@ -1,6 +1,7 @@
-use super::text_encoder::StreamingHandlerSink;
+use super::StreamingHandlerSink;
 use encoding_rs::Encoding;
 use std::error::Error as StdError;
+use std::panic::{RefUnwindSafe, UnwindSafe};
 
 type BoxResult = Result<(), Box<dyn StdError + Send + Sync>>;
 
@@ -64,6 +65,7 @@ impl From<(&str, ContentType)> for StringChunk {
 
 pub(crate) enum StringChunk {
     Buffer(Box<str>, ContentType),
+    Stream(Box<dyn StreamingHandler>),
 }
 
 #[derive(Default)]
@@ -96,10 +98,59 @@ impl DynamicString {
         for chunk in self.chunks {
             match chunk {
                 StringChunk::Buffer(content, content_type) => {
-                    sink.write_str_chunk(&content, content_type);
+                    sink.write_str(&content, content_type);
+                }
+                StringChunk::Stream(handler) => {
+                    handler.write_all(sink)?;
                 }
             };
         }
         Ok(())
     }
 }
+
+/// A callback used to write content asynchronously.
+pub trait StreamingHandler: Send {
+    /// This method is called only once, and is expected to write content
+    /// by calling the [`sink.write_str()`](StreamingHandlerSink::write_str) one or more times.
+    ///
+    /// Multiple calls to `sink.write_str()` append more content to the output.
+    ///
+    /// See [`StreamingHandlerSink`].
+    fn write_all(self: Box<Self>, sink: &mut StreamingHandlerSink<'_>) -> BoxResult;
+
+    // Safety: due to lack of Sync, this trait must not have `&self` methods
+}
+
+/// Avoid requring `StreamingHandler` to be `Sync`.
+/// It only has a method taking exclusive ownership, so there's no sharing possible.
+unsafe impl Sync for StringChunk {}
+impl RefUnwindSafe for StringChunk {}
+impl UnwindSafe for StringChunk {}
+
+impl<F> From<F> for Box<dyn StreamingHandler>
+where
+    F: FnOnce(&mut StreamingHandlerSink<'_>) -> BoxResult + Send + 'static,
+{
+    #[inline]
+    fn from(f: F) -> Self {
+        Box::new(f)
+    }
+}
+
+impl<F> StreamingHandler for F
+where
+    F: FnOnce(&mut StreamingHandlerSink<'_>) -> BoxResult + Send + 'static,
+{
+    #[inline]
+    fn write_all(self: Box<F>, sink: &mut StreamingHandlerSink<'_>) -> BoxResult {
+        (self)(sink)
+    }
+}
+
+impl From<Box<dyn StreamingHandler>> for StringChunk {
+    #[inline]
+    fn from(writer: Box<dyn StreamingHandler>) -> Self {
+        Self::Stream(writer)
+    }
+}
diff --git a/src/rewritable_units/text_encoder.rs b/src/rewritable_units/text_encoder.rs
index 234e9068..6e5dc0eb 100644
--- a/src/rewritable_units/text_encoder.rs
+++ b/src/rewritable_units/text_encoder.rs
@@ -1,10 +1,20 @@
 use super::ContentType;
 use crate::html::escape_body_text;
 use encoding_rs::{CoderResult, Encoder, Encoding, UTF_8};
+use thiserror::Error;
+
+/// Input contained non-UTF-8 byte sequence
+///
+/// [`StreamingHandlerSink::write_utf8_chunk`] will not fail on an incomplete UTF-8 sequence at the end of the chunk,
+/// but it will report errors if incomplete UTF-8 sequences are within the chunk, or the next call starts with
+/// bytes that don't match the previous call's trailing bytes.
+#[derive(Error, Debug, Eq, PartialEq, Copy, Clone)]
+#[error("Invalid UTF-8")]
+pub struct Utf8Error;
 
 /// Used to write chunks of text or markup in streaming mutation handlers.
 ///
-/// Argument to [`StreamingHandler::write_all`]
+/// Argument to [`StreamingHandler::write_all()`](crate::html_content::StreamingHandler::write_all).
 pub struct StreamingHandlerSink<'output_handler> {
     non_utf8_encoder: Option<TextEncoder>,
 
@@ -20,6 +30,10 @@ pub struct StreamingHandlerSink<'output_handler> {
     /// let x: IsSync<StreamingHandlerSink<'static>>;
     /// ```
     output_handler: &'output_handler mut dyn FnMut(&[u8]),
+
+    /// Half-written UTF-8
+    incomplete_bytes: [u8; 4],
+    incomplete_bytes_len: u8,
 }
 
 impl<'output_handler> StreamingHandlerSink<'output_handler> {
@@ -31,6 +45,8 @@ impl<'output_handler> StreamingHandlerSink<'output_handler> {
         Self {
             non_utf8_encoder: (encoding != UTF_8).then(|| TextEncoder::new(encoding)),
             output_handler,
+            incomplete_bytes: [0; 4],
+            incomplete_bytes_len: 0,
         }
     }
 
@@ -38,14 +54,115 @@ impl<'output_handler> StreamingHandlerSink<'output_handler> {
     ///
     /// It may be called multiple times. The strings will be concatenated together.
     #[inline]
-    pub fn write_str_chunk(&mut self, content: &str, content_type: ContentType) {
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn write_str(&mut self, content: &str, content_type: ContentType) {
         match content_type {
             ContentType::Html => self.write_html(content),
             ContentType::Text => self.write_body_text(content),
         }
     }
 
+    /// Writes as much of the given UTF-8 fragment as possible, converting the encoding and [escaping](ContentType) if necessary.
+    ///
+    /// The `content` doesn't need to be a complete UTF-8 string, as long as consecutive calls to `write_utf8_bytes` create a valid UTF-8 string.
+    /// Any incomplete UTF-8 sequence at the end of the content is buffered and flushed as soon as it's completed.
+    ///
+    /// Other methods like `write_str_chunk` should not be called after a `write_utf8_bytes` call with an incomplete UTF-8 sequence.
+    #[inline]
+    pub fn write_utf8_chunk(
+        &mut self,
+        content: &[u8],
+        content_type: ContentType,
+    ) -> Result<(), Utf8Error> {
+        let content = self.make_complete_utf8(content).ok_or(Utf8Error)?;
+        if content.is_empty() {
+            return Ok(());
+        }
+
+        match content_type {
+            ContentType::Html => self.write_html_inner(content),
+            ContentType::Text => self.write_body_text(content),
+        };
+        Ok(())
+    }
+
+    fn make_complete_utf8<'c>(&mut self, mut content: &'c [u8]) -> Option<&'c str> {
+        // Finish previous incomplete sequence if possible
+        while let Some((&first, rest)) = content.split_first() {
+            if is_utf8_char_boundary(first) {
+                break;
+            }
+            let pos = self.incomplete_bytes_len as usize;
+            *self.incomplete_bytes.get_mut(pos)? = first;
+            self.incomplete_bytes_len += 1;
+            content = rest;
+            if content.is_empty() {
+                if self.incomplete_bytes_len > 1 {
+                    // this could have been the end of the string with the last char completed now
+                    let _ = self.flush_incomplete_utf8();
+                }
+                return Some("");
+            }
+        }
+        // Found a new char boundary, so the buffer must contain a valid UTF-8 sequence
+        if self.incomplete_bytes_len > 0 {
+            self.flush_incomplete_utf8()?;
+        }
+
+        match std::str::from_utf8(content) {
+            Ok(content) => Some(content),
+            Err(err) => {
+                // error_len means invalid bytes, not just incomplete
+                if err.error_len().is_none() {
+                    let (valid, invalid) = content.split_at_checked(err.valid_up_to())?;
+                    if invalid.len() <= 3 {
+                        debug_assert_eq!(0, self.incomplete_bytes_len);
+                        self.incomplete_bytes[..invalid.len()].copy_from_slice(invalid);
+                        self.incomplete_bytes_len = invalid.len() as _;
+                        // valid_up_to promises it is valid
+                        debug_assert!(std::str::from_utf8(valid).is_ok());
+                        return Some(unsafe { std::str::from_utf8_unchecked(valid) });
+                    }
+                }
+                None
+            }
+        }
+    }
+
+    #[inline]
+    fn flush_incomplete_utf8(&mut self) -> Option<()> {
+        debug_assert!(self.incomplete_bytes_len > 0);
+        let tmp = self.incomplete_bytes;
+        let completed_char = tmp.get(..self.incomplete_bytes_len as usize)?;
+        let completed_char = std::str::from_utf8(completed_char).ok()?;
+        self.incomplete_bytes_len = 0;
+        self.write_html_inner(completed_char); // it's non-ASCII, so it can't contain chars to escape
+        Some(())
+    }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn discard_incomplete_utf8(&mut self) {
+        debug_assert_eq!(
+            0, self.incomplete_bytes_len,
+            "Previous write had unfinished UTF-8 sequence"
+        );
+
+        if self.incomplete_bytes_len > 0 {
+            // It's not possible for a valid UTF-8 string to complete a previously-incomplete sequence
+            self.incomplete_bytes_len = 0;
+            self.write_html_inner("\u{fffd}");
+        }
+    }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
     pub(crate) fn write_html(&mut self, html: &str) {
+        self.discard_incomplete_utf8();
+        self.write_html_inner(html);
+    }
+
+    pub(crate) fn write_html_inner(&mut self, html: &str) {
         if let Some(encoder) = &mut self.non_utf8_encoder {
             encoder.encode(html, self.output_handler);
         } else if !html.is_empty() {
@@ -54,7 +171,9 @@ impl<'output_handler> StreamingHandlerSink<'output_handler> {
     }
 
     /// For text content, not attributes
+    #[cfg_attr(debug_assertions, track_caller)]
     pub(crate) fn write_body_text(&mut self, plaintext: &str) {
+        self.discard_incomplete_utf8();
         if let Some(encoder) = &mut self.non_utf8_encoder {
             escape_body_text(plaintext, &mut |chunk| {
                 debug_assert!(!chunk.is_empty());
@@ -68,11 +187,18 @@ impl<'output_handler> StreamingHandlerSink<'output_handler> {
         }
     }
 
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
     pub(crate) fn output_handler(&mut self) -> &mut dyn FnMut(&[u8]) {
+        self.discard_incomplete_utf8();
         &mut self.output_handler
     }
 }
 
+pub(crate) const fn is_utf8_char_boundary(b: u8) -> bool {
+    b < 128 || b >= 192
+}
+
 enum Buffer {
     Heap(Vec<u8>),
     Stack([u8; 63]), // leave a byte for the tag
@@ -144,3 +270,32 @@ impl TextEncoder {
         }
     }
 }
+
+#[test]
+fn chars() {
+    let boundaries = "🐈°文字化けしない"
+        .as_bytes()
+        .iter()
+        .map(|&ch| if is_utf8_char_boundary(ch) { '!' } else { '.' })
+        .collect::<String>();
+    assert_eq!("!...!.!..!..!..!..!..!..!..", boundaries);
+}
+
+#[test]
+fn utf8_fragments() {
+    let text = "▀▄ ɯopuɐɹ ⓤⓝⓘⓒⓞⓓⓔ and ascii 🐳 sʇuıodǝpoɔ ✴";
+    for len in 1..9 {
+        let mut out = Vec::new();
+        let mut handler = |ch: &[u8]| out.extend_from_slice(ch);
+        let mut t = StreamingHandlerSink::new(UTF_8, &mut handler);
+        for (nth, chunk) in text.as_bytes().chunks(len).enumerate() {
+            let msg = format!(
+                "{len} at {nth} '{chunk:?}'; {:?}[..{}]",
+                t.incomplete_bytes, t.incomplete_bytes_len
+            );
+            t.write_utf8_chunk(chunk, ContentType::Html).expect(&msg);
+        }
+        drop(t);
+        assert_eq!(String::from_utf8_lossy(&out), text, "{len}");
+    }
+}
diff --git a/src/rewritable_units/tokens/comment.rs b/src/rewritable_units/tokens/comment.rs
index fd921c23..ae3fe4d9 100644
--- a/src/rewritable_units/tokens/comment.rs
+++ b/src/rewritable_units/tokens/comment.rs
@@ -1,6 +1,7 @@
 use super::{Mutations, Token};
 use crate::base::Bytes;
 use crate::errors::RewritingError;
+use crate::html_content::StreamingHandler;
 use encoding_rs::Encoding;
 use std::any::Any;
 use std::fmt::{self, Debug};
@@ -111,6 +112,16 @@ impl<'i> Comment<'i> {
             .push_back((content, content_type).into());
     }
 
+    /// Inserts content from a [`StreamingHandler`] before the comment.
+    ///
+    /// Consequent calls to the method append to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_before(&mut self, handler: Box<dyn StreamingHandler>) {
+        self.mutations.content_before.push_back(handler.into());
+    }
+
     /// Inserts `content` after the comment.
     ///
     /// Consequent calls to the method prepend `content` to the previously inserted content.
@@ -145,6 +156,16 @@ impl<'i> Comment<'i> {
             .push_front((content, content_type).into());
     }
 
+    /// Inserts content from a [`StreamingHandler`] after the comment.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_after(&mut self, handler: Box<dyn StreamingHandler>) {
+        self.mutations.content_after.push_front(handler.into());
+    }
+
     /// Replaces the comment with the `content`.
     ///
     /// Consequent calls to the method overwrite previous replacement content.
@@ -177,6 +198,16 @@ impl<'i> Comment<'i> {
         self.mutations.replace((content, content_type).into());
     }
 
+    /// Replaces the comment with the content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previous replacement content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_replace(&mut self, handler: Box<dyn StreamingHandler>) {
+        self.mutations.replace(handler.into());
+    }
+
     /// Removes the comment.
     #[inline]
     pub fn remove(&mut self) {
@@ -338,7 +369,11 @@ mod tests {
                     assert!(c.removed());
 
                     c.before("<before>", ContentType::Html);
-                    c.after("<after>", ContentType::Html);
+                    c.streaming_after(Box::new(|s: &mut StreamingHandlerSink<'_>| {
+                        s.write_str("<af", ContentType::Html);
+                        s.write_str("ter>", ContentType::Html);
+                        Ok(())
+                    }));
                 },
                 "<before><after>"
             );
@@ -355,7 +390,11 @@ mod tests {
 
                     c.replace("<div></div>", ContentType::Html);
                     c.replace("<!--42-->", ContentType::Html);
-                    c.replace("<foo & bar>", ContentType::Text);
+                    c.streaming_replace(streaming!(|h| {
+                        h.write_str("<foo &", ContentType::Text);
+                        h.write_str(" bar>", ContentType::Text);
+                        Ok(())
+                    }));
 
                     assert!(c.removed());
                 },
diff --git a/src/rewritable_units/tokens/end_tag.rs b/src/rewritable_units/tokens/end_tag.rs
index 6789e3f0..56269be5 100644
--- a/src/rewritable_units/tokens/end_tag.rs
+++ b/src/rewritable_units/tokens/end_tag.rs
@@ -1,7 +1,7 @@
 use super::{Mutations, Token};
 use crate::base::Bytes;
 use crate::errors::RewritingError;
-use crate::html_content::ContentType;
+use crate::html_content::{ContentType, StreamingHandler};
 use encoding_rs::Encoding;
 use std::fmt::{self, Debug};
 
@@ -92,6 +92,40 @@ impl<'i> EndTag<'i> {
         self.mutations.replace((content, content_type).into());
     }
 
+    /// Inserts content from a [`StreamingHandler`] before the end tag.
+    ///
+    /// Consequent calls to the method append to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_before(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_before
+            .push_back(string_writer.into());
+    }
+
+    /// Inserts content from a [`StreamingHandler`] after the end tag.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_after(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_after
+            .push_front(string_writer.into());
+    }
+
+    /// Replaces the end tag with content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previous replacement content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    #[inline]
+    pub fn streaming_replace(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations.replace(string_writer.into());
+    }
+
     /// Removes the end tag.
     #[inline]
     pub fn remove(&mut self) {
diff --git a/src/rewritable_units/tokens/start_tag.rs b/src/rewritable_units/tokens/start_tag.rs
index b0e13697..63d7acaa 100644
--- a/src/rewritable_units/tokens/start_tag.rs
+++ b/src/rewritable_units/tokens/start_tag.rs
@@ -3,7 +3,7 @@ use super::{Mutations, Serialize, Token};
 use crate::base::Bytes;
 use crate::errors::RewritingError;
 use crate::html::Namespace;
-use crate::html_content::ContentType;
+use crate::html_content::{ContentType, StreamingHandler};
 use encoding_rs::Encoding;
 use std::fmt::{self, Debug};
 
@@ -135,6 +135,37 @@ impl<'i> StartTag<'i> {
         self.mutations.replace((content, content_type).into());
     }
 
+    /// Inserts content from a [`StreamingHandler`] before the start tag.
+    ///
+    /// Consequent calls to the method append to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_before(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_before
+            .push_back(string_writer.into());
+    }
+
+    /// Inserts content from a [`StreamingHandler`] after the start tag.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_after(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_after
+            .push_front(string_writer.into());
+    }
+
+    /// Replaces the start tag with the content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previous replacement content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_replace(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations.replace(string_writer.into());
+    }
+
     /// Removes the start tag.
     #[inline]
     pub fn remove(&mut self) {
diff --git a/src/rewritable_units/tokens/text_chunk.rs b/src/rewritable_units/tokens/text_chunk.rs
index a7a48827..f6e4ac99 100644
--- a/src/rewritable_units/tokens/text_chunk.rs
+++ b/src/rewritable_units/tokens/text_chunk.rs
@@ -2,7 +2,7 @@ use super::{Mutations, Token};
 use crate::base::Bytes;
 use crate::errors::RewritingError;
 use crate::html::TextType;
-use crate::html_content::ContentType;
+use crate::html_content::{ContentType, StreamingHandler};
 use encoding_rs::Encoding;
 use std::any::Any;
 use std::borrow::Cow;
@@ -261,6 +261,37 @@ impl<'i> TextChunk<'i> {
         self.mutations.replace((content, content_type).into());
     }
 
+    /// Inserts content from a [`StreamingHandler`] before the text chunk.
+    ///
+    /// Consequent calls to the method append `content` to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_before(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_before
+            .push_back(string_writer.into());
+    }
+
+    /// Inserts content from a [`StreamingHandler`] after the text chunk.
+    ///
+    /// Consequent calls to the method prepend to the previously inserted content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_after(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations
+            .content_after
+            .push_front(string_writer.into());
+    }
+
+    /// Replaces the text chunk with the content from a [`StreamingHandler`].
+    ///
+    /// Consequent calls to the method overwrite previous replacement content.
+    ///
+    /// Use the [`streaming!`] macro to make a `StreamingHandler` from a closure.
+    pub fn streaming_replace(&mut self, string_writer: Box<dyn StreamingHandler>) {
+        self.mutations.replace(string_writer.into());
+    }
+
     /// Removes the text chunk.
     #[inline]
     pub fn remove(&mut self) {
diff --git a/src/rewriter/settings.rs b/src/rewriter/settings.rs
index ea5451ca..92d1d5d2 100644
--- a/src/rewriter/settings.rs
+++ b/src/rewriter/settings.rs
@@ -503,6 +503,51 @@ macro_rules! comments {
     }};
 }
 
+/// A convenience macro to construct a `StreamingHandler` from a closure.
+///
+/// For use with [`Element::streaming_replace`], etc.
+///
+/// ```rust
+/// use lol_html::{element, streaming, RewriteStrSettings};
+/// use lol_html::html_content::ContentType;
+///
+/// RewriteStrSettings {
+///     element_content_handlers: vec![
+///         element!("div", |element| {
+///             element.streaming_replace(streaming!(|sink| {
+///                 sink.write_str("…", ContentType::Html);
+///                 sink.write_str("…", ContentType::Html);
+///                 Ok(())
+///             }));
+///             Ok(())
+///         })
+///     ],
+///     ..RewriteStrSettings::default()
+/// };
+/// ```
+
+#[macro_export(local_inner_macros)]
+macro_rules! streaming {
+    ($closure:expr) => {{
+        use ::std::error::Error;
+        use $crate::html_content::StreamingHandlerSink;
+        // Without this rust won't be able to always infer the type of the handler.
+        #[inline(always)]
+        const fn streaming_macro_type_hint<StreamingHandler>(
+            handler_closure: StreamingHandler,
+        ) -> StreamingHandler
+        where
+            StreamingHandler:
+                FnOnce(&mut StreamingHandlerSink<'_>) -> Result<(), Box<dyn Error + Send + Sync>> + 'static + Send,
+        {
+            handler_closure
+        }
+
+        Box::new(streaming_macro_type_hint($closure))
+            as Box<dyn $crate::html_content::StreamingHandler>
+    }};
+}
+
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __document_content_handler {