diff --git a/packages/rsx-rosetta/examples/html.rs b/packages/rsx-rosetta/examples/html.rs
index 4a64b6c57..ef3006f31 100644
--- a/packages/rsx-rosetta/examples/html.rs
+++ b/packages/rsx-rosetta/examples/html.rs
@@ -16,7 +16,7 @@ fn main() {
 
     let dom = Dom::parse(html).unwrap();
 
-    let body = rsx_rosetta::convert_from_html(dom);
+    let body = rsx_rosetta::rsx_from_html(dom);
 
     let out = dioxus_autofmt::write_block_out(body).unwrap();
 
diff --git a/packages/rsx-rosetta/src/lib.rs b/packages/rsx-rosetta/src/lib.rs
index 83f79883c..440a41ebc 100644
--- a/packages/rsx-rosetta/src/lib.rs
+++ b/packages/rsx-rosetta/src/lib.rs
@@ -1,30 +1,30 @@
+use convert_case::{Case, Casing};
 use dioxus_rsx::{BodyNode, CallBody, Element, ElementAttr, ElementAttrNamed, IfmtInput};
 pub use html_parser::{Dom, Node};
 use proc_macro2::{Ident, Span};
 use syn::LitStr;
 
-pub fn convert_from_html(dom: Dom) -> CallBody {
+/// Convert an HTML DOM tree into an RSX CallBody
+pub fn rsx_from_html(dom: &Dom) -> CallBody {
     CallBody {
         roots: dom
             .children
-            .into_iter()
+            .iter()
             .filter_map(create_body_node_from_node)
             .collect(),
     }
 }
 
-fn create_body_node_from_node(node: Node) -> Option<BodyNode> {
+fn create_body_node_from_node(node: &Node) -> Option<BodyNode> {
     match node {
         Node::Text(text) => Some(BodyNode::Text(ifmt_from_text(text))),
         Node::Element(el) => {
-            use convert_case::{Case, Casing};
-
             let el_name = el.name.to_case(Case::Snake);
             let el_name = Ident::new(el_name.as_str(), Span::call_site());
 
             let mut attributes: Vec<_> = el
                 .attributes
-                .into_iter()
+                .iter()
                 .map(|(name, value)| {
                     let ident = if matches!(name.as_str(), "for" | "async" | "type" | "as") {
                         Ident::new_raw(name.as_str(), Span::call_site())
@@ -34,11 +34,11 @@ fn create_body_node_from_node(node: Node) -> Option<BodyNode> {
                     };
 
                     ElementAttrNamed {
-                        attr: ElementAttr::AttrText {
-                            name: ident,
-                            value: ifmt_from_text(value.unwrap_or_else(|| "false".to_string())),
-                        },
                         el_name: el_name.clone(),
+                        attr: ElementAttr::AttrText {
+                            value: ifmt_from_text(value.as_deref().unwrap_or("false")),
+                            name: ident,
+                        },
                     }
                 })
                 .collect();
@@ -46,27 +46,27 @@ fn create_body_node_from_node(node: Node) -> Option<BodyNode> {
             let class = el.classes.join(" ");
             if !class.is_empty() {
                 attributes.push(ElementAttrNamed {
+                    el_name: el_name.clone(),
                     attr: ElementAttr::AttrText {
                         name: Ident::new("class", Span::call_site()),
-                        value: ifmt_from_text(class),
+                        value: ifmt_from_text(&class),
                     },
-                    el_name: el_name.clone(),
                 });
             }
 
-            if let Some(id) = el.id {
+            if let Some(id) = &el.id {
                 attributes.push(ElementAttrNamed {
+                    el_name: el_name.clone(),
                     attr: ElementAttr::AttrText {
                         name: Ident::new("id", Span::call_site()),
                         value: ifmt_from_text(id),
                     },
-                    el_name: el_name.clone(),
                 });
             }
 
             let children = el
                 .children
-                .into_iter()
+                .iter()
                 .filter_map(create_body_node_from_node)
                 .collect();
 
@@ -78,13 +78,15 @@ fn create_body_node_from_node(node: Node) -> Option<BodyNode> {
                 key: None,
             }))
         }
+
+        // We ignore comments
         Node::Comment(_) => None,
     }
 }
 
-fn ifmt_from_text(text: String) -> IfmtInput {
+fn ifmt_from_text(text: &str) -> IfmtInput {
     IfmtInput {
-        source: Some(LitStr::new(text.as_str(), Span::call_site())),
+        source: Some(LitStr::new(text, Span::call_site())),
         segments: vec![],
     }
 }