selma 0.0.7 → 0.2.0

data/Cargo.toml

@@ -0,0 +1,6 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions depedencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["ext/selma"]

data/README.md

@@ -29,7 +29,7 @@ Selma can perform two different actions, either independently or together:
 - Sanitize HTML, through a [Sanitize](https://github.com/rgrove/sanitize)-like allowlist syntax; and
 - Select HTML using CSS rules, and manipulate elements and text nodes along the way.
 
-It does this through two kwargsL `sanitizer` and `handlers`. The basic API for Selma looks like this:
+It does this through two kwargs: `sanitizer` and `handlers`. The basic API for Selma looks like this:
 
 ```ruby
 sanitizer_config = {
@@ -164,6 +164,9 @@ The `element` argument in `handle_element` has the following methods:
 - `prepend(content, as: content_type)`: prepends `content` to the element's inner content, i.e. inserts content right after the element's start tag. `content_type` is either `:text` or `:html` and determines how the content will be applied.
 - `append(content, as: content_type)`: appends `content` to the element's inner content, i.e. inserts content right before the element's end tag. `content_type` is either `:text` or `:html` and determines how the content will be applied.
 - `set_inner_content`: Replaces inner content of the element with `content`. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `remove`: Removes the element and its inner content.
+- `remove_and_keep_content`: Removes the element, but keeps its content. I.e. remove start and end tags of the element.
+- `removed?`: A bool which identifies if the element has been removed or replaced with some content.
 
 #### `text_chunk` methods
 

data/ext/selma/Cargo.toml

@@ -4,10 +4,10 @@ version = "1.0.0"
 edition = "2021"
 
 [dependencies]
-enum-iterator = "1.2"
+enum-iterator = "1.4"
 escapist = "0.0.2"
-magnus = { git = "https://github.com/matsadler/magnus", rev = "23160f7229ac74c42da1b5096a65ccbc40962697" }
-lol_html = "0.3"
+magnus = "0.6"
+lol_html = "1.2"
 
 [lib]
 name = "selma"

data/ext/selma/extconf.rb

@@ -1,6 +1,4 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
-require_relative "_util"
-
 create_rust_makefile("selma/selma")

data/ext/selma/src/html/element.rs

@@ -215,12 +215,41 @@ impl SelmaHTMLElement {
 
         Ok(())
     }
+
+    fn remove(&self) {
+        let mut binding = self.0.borrow_mut();
+
+        if let Ok(e) = binding.element.get_mut() {
+            e.remove()
+        }
+    }
+
+    fn remove_and_keep_content(&self) {
+        let mut binding = self.0.borrow_mut();
+
+        if let Ok(e) = binding.element.get_mut() {
+            e.remove_and_keep_content()
+        }
+    }
+
+    fn is_removed(&self) -> Result<bool, Error> {
+        let binding = self.0.borrow();
+
+        if let Ok(e) = binding.element.get() {
+            Ok(e.removed())
+        } else {
+            Err(Error::new(
+                exception::runtime_error(),
+                "`is_removed` is not available",
+            ))
+        }
+    }
 }
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
     let c_element = c_html
-        .define_class("Element", Default::default())
-        .expect("cannot find class Selma::HTML::Element");
+        .define_class("Element", magnus::class::object())
+        .expect("cannot define class Selma::HTML::Element");
 
     c_element.define_method("tag_name", method!(SelmaHTMLElement::tag_name, 0))?;
     c_element.define_method("tag_name=", method!(SelmaHTMLElement::set_tag_name, 1))?;
@@ -250,5 +279,12 @@ pub fn init(c_html: RClass) -> Result<(), Error> {
         method!(SelmaHTMLElement::set_inner_content, -1),
     )?;
 
+    c_element.define_method("remove", method!(SelmaHTMLElement::remove, 0))?;
+    c_element.define_method(
+        "remove_and_keep_content",
+        method!(SelmaHTMLElement::remove_and_keep_content, 0),
+    )?;
+    c_element.define_method("removed?", method!(SelmaHTMLElement::is_removed, 0))?;
+
     Ok(())
 }

data/ext/selma/src/html/end_tag.rs

@@ -26,8 +26,8 @@ impl SelmaHTMLEndTag {
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
     let c_end_tag = c_html
-        .define_class("EndTag", Default::default())
-        .expect("cannot find class Selma::HTML::EndTag");
+        .define_class("EndTag", magnus::class::object())
+        .expect("cannot define class Selma::HTML::EndTag");
 
     c_end_tag.define_method("tag_name", method!(SelmaHTMLEndTag::tag_name, 0))?;
 

data/ext/selma/src/html/text_chunk.rs

@@ -39,12 +39,12 @@ impl SelmaHTMLTextChunk {
 
         if let Ok(tc) = binding.text_chunk.get() {
             match tc.text_type() {
-                TextType::Data => Ok(Symbol::from("data")),
-                TextType::PlainText => Ok(Symbol::from("plain_text")),
-                TextType::RawText => Ok(Symbol::from("raw_text")),
-                TextType::ScriptData => Ok(Symbol::from("script")),
-                TextType::RCData => Ok(Symbol::from("rc_data")),
-                TextType::CDataSection => Ok(Symbol::from("cdata_section")),
+                TextType::Data => Ok(Symbol::new("data")),
+                TextType::PlainText => Ok(Symbol::new("plain_text")),
+                TextType::RawText => Ok(Symbol::new("raw_text")),
+                TextType::ScriptData => Ok(Symbol::new("script")),
+                TextType::RCData => Ok(Symbol::new("rc_data")),
+                TextType::CDataSection => Ok(Symbol::new("cdata_section")),
             }
         } else {
             Err(Error::new(
@@ -99,8 +99,8 @@ impl SelmaHTMLTextChunk {
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
     let c_text_chunk = c_html
-        .define_class("TextChunk", Default::default())
-        .expect("cannot find class Selma::HTML::TextChunk");
+        .define_class("TextChunk", magnus::class::object())
+        .expect("cannot define class Selma::HTML::TextChunk");
 
     c_text_chunk.define_method("to_s", method!(SelmaHTMLTextChunk::to_s, 0))?;
     c_text_chunk.define_method("content", method!(SelmaHTMLTextChunk::to_s, 0))?;

data/ext/selma/src/html.rs

@@ -5,7 +5,9 @@ use magnus::{Error, Module, RModule};
 pub(crate) struct SelmaHTML {}
 
 pub fn init(m_selma: RModule) -> Result<(), Error> {
-    let c_html = m_selma.define_class("HTML", Default::default()).unwrap();
+    let c_html = m_selma
+        .define_class("HTML", magnus::class::object())
+        .expect("cannot define class Selma::HTML");
 
     element::init(c_html).expect("cannot define Selma::HTML::Element class");
     end_tag::init(c_html).expect("cannot define Selma::HTML::EndTag class");

data/ext/selma/src/lib.rs

@@ -9,7 +9,6 @@ pub mod rewriter;
 pub mod sanitizer;
 pub mod selector;
 pub mod tags;
-pub mod wrapped_struct;
 
 #[allow(clippy::let_unit_value)]
 fn scan_text_args(args: &[Value]) -> Result<(String, ContentType), magnus::Error> {

data/ext/selma/src/rewriter.rs

@@ -1,9 +1,14 @@
 use lol_html::{
     doc_comments, doctype, element,
-    html_content::{Element, EndTag, TextChunk},
+    html_content::{Element, TextChunk},
     text, DocumentContentHandlers, ElementContentHandlers, HtmlRewriter, Selector, Settings,
 };
-use magnus::{exception, function, method, scan_args, Module, Object, RArray, RModule, Value};
+use magnus::{
+    exception, function, method, scan_args,
+    typed_data::Obj,
+    value::{Opaque, ReprValue},
+    Module, Object, RArray, RModule, Ruby, Value,
+};
 
 use std::{borrow::Cow, cell::RefCell, primitive::str, rc::Rc};
 
@@ -12,33 +17,29 @@ use crate::{
     sanitizer::SelmaSanitizer,
     selector::SelmaSelector,
     tags::Tag,
-    wrapped_struct::WrappedStruct,
 };
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Handler {
-    rb_handler: Value,
-    rb_selector: WrappedStruct<SelmaSelector>,
-
-    total_element_handler_calls: usize,
-    total_elapsed_element_handlers: f64,
+    rb_handler: Opaque<Value>,
+    rb_selector: Opaque<Obj<SelmaSelector>>,
+    // total_element_handler_calls: usize,
+    // total_elapsed_element_handlers: f64,
 
-    total_text_handler_calls: usize,
-    total_elapsed_text_handlers: f64,
+    // total_text_handler_calls: usize,
+    // total_elapsed_text_handlers: f64,
 }
 
 pub struct Rewriter {
     sanitizer: Option<SelmaSanitizer>,
     handlers: Vec<Handler>,
-
-    total_elapsed: f64,
+    // total_elapsed: f64,
 }
 
 #[magnus::wrap(class = "Selma::Rewriter")]
 pub struct SelmaRewriter(std::cell::RefCell<Rewriter>);
 
-/// SAFETY: This is safe because we only access this data when the GVL is held.
-unsafe impl Send for SelmaRewriter {}
+type RewriterValues = (Option<Option<Obj<SelmaSanitizer>>>, Option<RArray>);
 
 impl SelmaRewriter {
     const SELMA_ON_END_TAG: &str = "on_end_tag";
@@ -56,15 +57,15 @@ impl SelmaRewriter {
         let sanitizer = match rb_sanitizer {
             None => {
                 let default_sanitizer = SelmaSanitizer::new(&[])?;
-                let wrapped_sanitizer = WrappedStruct::from(default_sanitizer);
+                let wrapped_sanitizer = Obj::wrap(default_sanitizer);
                 wrapped_sanitizer.funcall::<&str, (), Value>("setup", ())?;
-                Some(wrapped_sanitizer.get().unwrap().to_owned())
+                Some(wrapped_sanitizer.get().to_owned())
             }
             Some(sanitizer_value) => match sanitizer_value {
                 None => None,
                 Some(sanitizer) => {
                     sanitizer.funcall::<&str, (), Value>("setup", ())?;
-                    Some(sanitizer.get().unwrap().to_owned())
+                    Some(sanitizer.get().to_owned())
                 }
             },
         };
@@ -89,24 +90,23 @@ impl SelmaRewriter {
                         ));
                     }
 
-                    let rb_selector: WrappedStruct<SelmaSelector> =
-                        match rb_handler.funcall("selector", ()) {
-                            Err(err) => {
-                                return Err(magnus::Error::new(
-                                    exception::type_error(),
-                                    format!("Error instantiating selector: {err:?}"),
-                                ));
-                            }
-                            Ok(rb_selector) => rb_selector,
-                        };
+                    let rb_selector: Obj<SelmaSelector> = match rb_handler.funcall("selector", ()) {
+                        Err(err) => {
+                            return Err(magnus::Error::new(
+                                exception::type_error(),
+                                format!("Error instantiating selector: {err:?}"),
+                            ));
+                        }
+                        Ok(rb_selector) => rb_selector,
+                    };
                     let handler = Handler {
-                        rb_handler,
-                        rb_selector,
-                        total_element_handler_calls: 0,
-                        total_elapsed_element_handlers: 0.0,
+                        rb_handler: Opaque::from(rb_handler),
+                        rb_selector: Opaque::from(rb_selector),
+                        // total_element_handler_calls: 0,
+                        // total_elapsed_element_handlers: 0.0,
 
-                        total_text_handler_calls: 0,
-                        total_elapsed_text_handlers: 0.0,
+                        // total_text_handler_calls: 0,
+                        // total_elapsed_text_handlers: 0.0,
                     };
                     handlers.push(handler);
                 }
@@ -124,20 +124,12 @@ impl SelmaRewriter {
         Ok(Self(std::cell::RefCell::new(Rewriter {
             sanitizer,
             handlers,
-            total_elapsed: 0.0,
+            // total_elapsed: 0.0,
         })))
     }
 
     #[allow(clippy::let_unit_value)]
-    fn scan_parse_args(
-        args: &[Value],
-    ) -> Result<
-        (
-            Option<Option<WrappedStruct<SelmaSanitizer>>>,
-            Option<RArray>,
-        ),
-        magnus::Error,
-    > {
+    fn scan_parse_args(args: &[Value]) -> Result<RewriterValues, magnus::Error> {
         let args = scan_args::scan_args(args)?;
         let _: () = args.required;
         let _: () = args.optional;
@@ -148,10 +140,7 @@ impl SelmaRewriter {
         let kwargs = scan_args::get_kwargs::<
             _,
             (),
-            (
-                Option<Option<WrappedStruct<SelmaSanitizer>>>,
-                Option<RArray>,
-            ),
+            (Option<Option<Obj<SelmaSanitizer>>>, Option<RArray>),
             (),
         >(args.keywords, &[], &["sanitizer", "handlers"])?;
         let (rb_sanitizer, rb_handlers) = kwargs.optional;
@@ -273,7 +262,9 @@ impl SelmaRewriter {
         handlers.iter().for_each(|handler| {
             let element_stack: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(vec![]));
 
-            let selector = handler.rb_selector.get_static().unwrap();
+            let ruby = Ruby::get().unwrap();
+
+            let selector = ruby.get_inner(handler.rb_selector);
 
             // TODO: test final raise by simulating errors
             if selector.match_element().is_some() {
@@ -283,7 +274,7 @@ impl SelmaRewriter {
                     selector.match_element().unwrap(),
                     move |el| {
                         match Self::process_element_handlers(
-                            handler.rb_handler,
+                            ruby.get_inner(handler.rb_handler),
                             el,
                             &closure_element_stack.borrow(),
                         ) {
@@ -314,7 +305,9 @@ impl SelmaRewriter {
                             }
                         }
 
-                        match Self::process_text_handlers(handler.rb_handler, text) {
+                        let ruby = Ruby::get().unwrap();
+                        match Self::process_text_handlers(ruby.get_inner(handler.rb_handler), text)
+                        {
                             Ok(_) => Ok(()),
                             Err(err) => Err(err.to_string().into()),
                         }
@@ -334,11 +327,15 @@ impl SelmaRewriter {
                 element_stack.as_ref().borrow_mut().push(tag_name);
 
                 let closure_element_stack = element_stack.clone();
-                el.on_end_tag(move |_end_tag: &mut EndTag| {
-                    let mut stack = closure_element_stack.as_ref().borrow_mut();
-                    stack.pop();
-                    Ok(())
-                })?;
+
+                el.end_tag_handlers()
+                    .unwrap()
+                    .push(Box::new(move |_end_tag| {
+                        let mut stack = closure_element_stack.as_ref().borrow_mut();
+                        stack.pop();
+                        Ok(())
+                    }));
+
                 Ok(())
             }));
         });
@@ -373,14 +370,17 @@ impl SelmaRewriter {
         // if `on_end_tag` function is defined, call it
         if rb_handler.respond_to(Self::SELMA_ON_END_TAG, true).unwrap() {
             // TODO: error here is an "EndTagError"
-            element.on_end_tag(move |end_tag| {
-                let rb_end_tag = SelmaHTMLEndTag::new(end_tag);
-
-                match rb_handler.funcall::<_, _, Value>(Self::SELMA_ON_END_TAG, (rb_end_tag,)) {
-                    Ok(_) => Ok(()),
-                    Err(err) => Err(err.to_string().into()),
-                }
-            });
+            element
+                .end_tag_handlers()
+                .unwrap()
+                .push(Box::new(move |end_tag| {
+                    let rb_end_tag = SelmaHTMLEndTag::new(end_tag);
+
+                    match rb_handler.funcall::<_, _, Value>(Self::SELMA_ON_END_TAG, (rb_end_tag,)) {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err.to_string().into()),
+                    }
+                }));
         }
 
         let rb_element = SelmaHTMLElement::new(element, ancestors);
@@ -417,8 +417,8 @@ impl SelmaRewriter {
 
 pub fn init(m_selma: RModule) -> Result<(), magnus::Error> {
     let c_rewriter = m_selma
-        .define_class("Rewriter", Default::default())
-        .expect("cannot find class Selma::Rewriter");
+        .define_class("Rewriter", magnus::class::object())
+        .expect("cannot define class Selma::Rewriter");
 
     c_rewriter.define_singleton_method("new", function!(SelmaRewriter::new, -1))?;
     c_rewriter

data/ext/selma/src/sanitizer.rs

@@ -4,9 +4,13 @@ use lol_html::{
     errors::AttributeNameError,
     html_content::{Comment, ContentType, Doctype, Element, EndTag},
 };
-use magnus::{class, function, method, scan_args, Module, Object, RArray, RHash, RModule, Value};
+use magnus::{
+    class, function, method, scan_args,
+    value::{Opaque, ReprValue},
+    Module, Object, RArray, RHash, RModule, Ruby, Value,
+};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 struct ElementSanitizer {
     allowed_attrs: Vec<String>,
     required_attrs: Vec<String>,
@@ -14,19 +18,7 @@ struct ElementSanitizer {
     protocol_sanitizers: HashMap<String, Vec<String>>,
 }
 
-impl Default for ElementSanitizer {
-    fn default() -> Self {
-        ElementSanitizer {
-            allowed_attrs: vec![],
-            allowed_classes: vec![],
-            required_attrs: vec![],
-
-            protocol_sanitizers: HashMap::new(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Sanitizer {
     flags: [u8; crate::tags::Tag::TAG_COUNT],
     allowed_attrs: Vec<String>,
@@ -36,10 +28,10 @@ pub struct Sanitizer {
     pub escape_tagfilter: bool,
     pub allow_comments: bool,
     pub allow_doctype: bool,
-    config: RHash,
+    config: Opaque<RHash>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 #[magnus::wrap(class = "Selma::Sanitizer")]
 pub struct SelmaSanitizer(std::cell::RefCell<Sanitizer>);
 
@@ -77,14 +69,15 @@ impl SelmaSanitizer {
             escape_tagfilter: true,
             allow_comments: false,
             allow_doctype: true,
-            config,
+            config: config.into(),
         })))
     }
 
     fn get_config(&self) -> Result<RHash, magnus::Error> {
         let binding = self.0.borrow();
+        let ruby = Ruby::get().unwrap();
 
-        Ok(binding.config)
+        Ok(ruby.get_inner(binding.config))
     }
 
     /// Toggle a sanitizer option on or off.
@@ -308,9 +301,9 @@ impl SelmaSanitizer {
                     let mut buf = String::new();
                     // ...then, escape any special characters, for security
                     if attr_name == "href" {
-                        escapist::escape_href(&mut buf, unescaped_attr_val.as_str());
+                        escapist::escape_href(&mut buf, unescaped_attr_val.as_str()).unwrap();
                     } else {
-                        escapist::escape_html(&mut buf, unescaped_attr_val.as_str());
+                        escapist::escape_html(&mut buf, unescaped_attr_val.as_str()).unwrap();
                     };
 
                     match element.set_attribute(attr_name, &buf) {
@@ -530,11 +523,12 @@ impl SelmaSanitizer {
     fn check_if_end_tag_needs_removal(element: &mut Element) {
         if element.removed() && !crate::tags::Tag::tag_from_element(element).self_closing {
             element
-                .on_end_tag(move |end| {
+                .end_tag_handlers()
+                .unwrap()
+                .push(Box::new(move |end| {
                     Self::remove_end_tag(end);
                     Ok(())
-                })
-                .unwrap();
+                }));
         }
     }
 
@@ -553,7 +547,9 @@ impl SelmaSanitizer {
 }
 
 pub fn init(m_selma: RModule) -> Result<(), magnus::Error> {
-    let c_sanitizer = m_selma.define_class("Sanitizer", Default::default())?;
+    let c_sanitizer = m_selma
+        .define_class("Sanitizer", magnus::class::object())
+        .expect("cannot define class Selma::Sanitizer");
 
     c_sanitizer.define_singleton_method("new", function!(SelmaSanitizer::new, -1))?;
     c_sanitizer.define_method("config", method!(SelmaSanitizer::get_config, 0))?;

data/ext/selma/src/selector.rs

@@ -8,6 +8,8 @@ pub struct SelmaSelector {
     ignore_text_within: Option<Vec<String>>,
 }
 
+type SelectorMatches = (Option<String>, Option<String>, Option<Vec<String>>);
+
 impl SelmaSelector {
     fn new(args: &[Value]) -> Result<Self, Error> {
         let (match_element, match_text_within, rb_ignore_text_within) =
@@ -63,9 +65,7 @@ impl SelmaSelector {
     }
 
     #[allow(clippy::let_unit_value)]
-    fn scan_parse_args(
-        args: &[Value],
-    ) -> Result<(Option<String>, Option<String>, Option<Vec<String>>), Error> {
+    fn scan_parse_args(args: &[Value]) -> Result<SelectorMatches, Error> {
         let args = scan_args::scan_args(args)?;
         let _: () = args.required;
         let _: () = args.optional;
@@ -103,7 +103,7 @@ impl SelmaSelector {
 
 pub fn init(m_selma: RModule) -> Result<(), Error> {
     let c_selector = m_selma
-        .define_class("Selector", Default::default())
+        .define_class("Selector", magnus::class::object())
         .expect("cannot define class Selma::Selector");
 
     c_selector.define_singleton_method("new", function!(SelmaSelector::new, -1))?;

data/lib/selma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Selma
-  VERSION = "0.0.7"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Garen J. Torikian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler-dock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 description: 
 email:
 - gjtorikian@gmail.com
@@ -74,10 +60,11 @@ extensions:
 - ext/selma/extconf.rb
 extra_rdoc_files: []
 files:
+- Cargo.lock
+- Cargo.toml
 - LICENSE.txt
 - README.md
 - ext/selma/Cargo.toml
-- ext/selma/_util.rb
 - ext/selma/extconf.rb
 - ext/selma/src/html.rs
 - ext/selma/src/html/element.rs
@@ -89,7 +76,6 @@ files:
 - ext/selma/src/sanitizer.rs
 - ext/selma/src/selector.rs
 - ext/selma/src/tags.rs
-- ext/selma/src/wrapped_struct.rs
 - lib/selma.rb
 - lib/selma/extension.rb
 - lib/selma/html.rb
@@ -102,7 +88,6 @@ files:
 - lib/selma/sanitizer/config/restricted.rb
 - lib/selma/selector.rb
 - lib/selma/version.rb
-- selma.gemspec
 homepage: 
 licenses:
 - MIT
@@ -126,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.20
 signing_key: 
 specification_version: 4
 summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html