diff --git a/examples/TkinterWebBrowser.py b/examples/TkinterWebBrowser.py
index 1dd4a14..ffa6331 100755
--- a/examples/TkinterWebBrowser.py
+++ b/examples/TkinterWebBrowser.py
@@ -267,8 +267,7 @@ def __init__(self, master, *args, **kwargs):
 
         self.sidebar.javascript.register("frame", frame)
 
-        self.sidebar.load_html(f"""<html>
-  <body>
+        self.sidebar.load_html(f"""
     <style>
       body p, span {{ margin-top: 5px; margin-bottom: 5px; cursor: default; }}
       object {{ width: 100%; cursor: pointer; }}
@@ -331,8 +330,7 @@ def __init__(self, master, *args, **kwargs):
       <object allowscrolling data={html_button}></object>
       <object allowscrolling data={about_button}></object>
     </div>
-  </body>
-</html>""")
+    """)
         
         frame.config = self.html_config
 
@@ -885,4 +883,4 @@ def on_tab_change(self, event):
             self.destroy()
 
 if __name__ == "__main__":   
-    Browser()
\ No newline at end of file
+    Browser()
diff --git a/tkinterweb/bindings.py b/tkinterweb/bindings.py
index bb8762b..797e16a 100644
--- a/tkinterweb/bindings.py
+++ b/tkinterweb/bindings.py
@@ -6,7 +6,7 @@
 
 from re import IGNORECASE, split, sub
 
-from urllib.parse import urljoin
+from urllib.parse import urljoin, DefragResult
 
 from queue import Queue, Empty
 
@@ -297,7 +297,7 @@ def _setup_handlers(self):
         self.register_lazy_handler("node", "base", "node_manager")
         self.register_lazy_handler("attribute", "a", "node_manager")
 
-        if not self.using_tkhtml30:
+        if not self.using_tkhtml30 or self.experimental:
             #self.register_lazy_handler("node", "details", "node_manager")
             self.register_lazy_handler("node", "progress", "node_manager")
             self.register_lazy_handler("attribute", "progress", "node_manager")
@@ -676,7 +676,6 @@ def _parse(self, html):
         self.script_manager._submit_deferred_scripts()
         self.event_manager.send_onload()
 
-        #if self.using_tkhtml30: # Handle unsupported tags
         self.node_manager._handle_load_finish()
 
     def _handle_load_finish(self, post_event=True):
@@ -1750,8 +1749,7 @@ def escape_uri(self, uri, query=False):
         """Returns the decoded data.
         
         New in version 4.19."""
-        a = "-query" if query else ""
-        return self.tk.call("::tkhtml::escape_uri", a, uri)
+        return self.tk.call("::tkhtml::escape_uri", "-query" if query else "", uri)
 
 class TkHtmlParsedURI:
     """Bindings for the Tkhtml URI parsing system. 
@@ -1765,38 +1763,34 @@ def __init__(self, uri, html):
         self.parsed = self.uri(uri)
 
     def __repr__(self):
-        return f"{self._html._w}::{self.__class__.__name__.lower()}"
+        return f"{self._html._w}::{self.__class__.__name__.lower()}{self.parsed}"
 
     def __str__(self):
-        return self.get(self.parsed)
-
-    def __del__(self):
-        self.destroy(self.parsed)
+        return self.get
 
     def uri(self, uri):
         "Returns name of parsed uri to be used in methods below."
         return self._html.tk.call("::tkhtml::uri", uri)
 
-    def tkhtml_uri_decode(self, uri, base64=False):
+    def decode(self, base64=False):
         "This command is designed to help scripts process data: URIs. It is completely separate from the html widget"
-        return self._html.tkhtml_uri_decode(uri, base64)
+        return self._html.decode_uri(self.get, base64)
 
-    def tkhtml_uri_encode(self, uri):
+    def encode(self):
         "Encodes the uri."
-        return self._html.tkhtml_uri_encode(uri)
+        return self._html.encode_uri(self.get)
 
-    def tkhtml_uri_escape(self, uri, query=False):
+    def escape(self, query=False):
         "Returns the decoded data."
-        return self._html.tkhtml_uri_escape(uri, query)
+        return self._html.escape_uri(self.get, query)
 
-    def uri_resolve(self, uri):
+    def resolve(self, uri):
         "Resolve a uri."
         return self._html.tk.call(self.parsed, "resolve", uri)
 
-    @property
     def load(self, uri):
-        "Load a uri."
-        return self._html.tk.call(self.parsed, "load", uri)
+        "Load a URI, which overrides the previous URI string"
+        self._html.tk.call(self.parsed, "load", uri)
 
     @property
     def get(self):
@@ -1835,9 +1829,13 @@ def fragment(self):
 
     @property
     def splitfrag(self):
-        "Return namedtuple with uri and fragment"
-        return self.defrag, self.fragment
+        "Return DefragResult/namedtuple with uri and fragment"
+        return DefragResult(self.defrag, self.fragment)
 
     def destroy(self):
-        "Destroy this uri."
-        self._html.tk.call(self.parsed, "destroy")
+        "Destroy this uri and free Tcl resources."
+        if self.parsed:
+            self._html.tk.call(self.parsed, "destroy")
+            self.parsed = None
+
+    __del__ = destroy
diff --git a/tkinterweb/dom.py b/tkinterweb/dom.py
index 411bdb3..58e6250 100644
--- a/tkinterweb/dom.py
+++ b/tkinterweb/dom.py
@@ -411,9 +411,9 @@ def textContent(self, contents):  # Ditto
                 self.html.widget_manager.set_node_widget(node, None)
 
             self.html.safe_tk_eval("""
-                set html %s
                 set node %s
                 set textnode %s
+                
                 if {$textnode eq ""} {error "$node is empty"}
                 if {[$node tag] eq "html"} {error "textContent cannot be set on <$tag> elements"}
                 $node remove [$node children]
@@ -422,8 +422,8 @@ def textContent(self, contents):  # Ditto
                 }
                 $node insert $textnode
                 
-                if {[winfo ismapped $html]} {update} ; # This must be done to see changes on-screen
-                """ % (self.html, extract_nested(self.node), self.document.createTextNode(contents).node)
+                if {[winfo ismapped .]} {update} ; # This must be done to see changes on-screen
+                """ % (extract_nested(self.node), self.document.createTextNode(contents).node)
             )
         else:
             self.html.set_node_text(self.node, contents)
diff --git a/tkinterweb/handlers.py b/tkinterweb/handlers.py
index a99e3b4..d3f1ec2 100644
--- a/tkinterweb/handlers.py
+++ b/tkinterweb/handlers.py
@@ -1,6 +1,24 @@
 """
 Node handlers and associated extensions to Tkhtml3
 
+This was created because TkinterWeb class was getting enormous and difficult to 
+maintain and debug. It was also full of old workarounds and meaningless code. 
+Generally, the Python philosophy is to have a self-explanatory, modular 
+codebase rather than one massive object that does a million things. It's been 
+on my bucket list for years to make the widget more modular, partly for this 
+reason. So, I split it into separate classes that each have a specific 
+function. This also simplified all the flags for extra features a lot: each 
+feature (i.e. images, CSS, etc.) is tied to a subclass that can be enabled or 
+disabled, saving me from having if/else statements everywhere checking if 
+actions are enabled. This also gave me the chance to add lazy loading into the 
+mix. Since less code has to be evaluated at startup, apps tend to start a bit 
+quicker (it's barely noticeable, but hey, I'll take it). Splitting off the node 
+handlers removes roughly 1000 lines from an object that as it is, is still 
+roughly at 1700 lines (which I personally think is still too much). Breaking 
+things into chunks just makes things simpler and easier to maintain. The 
+overhead in Python of creating another class is negligible, but the scalability 
+and ease of maintenance is much, much higher. That's my philosophy anyway!
+
 Copyright (c) 2021-2025 Andrew Clarke
 """
 
@@ -159,7 +177,7 @@ def _update_details(self, node, display):
 
     def _set_open(self, node, display):
         self.html.set_node_attribute(node, "open", "" if display else "false")
-        if self.html.using_tkhtml30:
+        if self.html.using_tkhtml30 and not self.html.experimental:
             # In Tkhtml 3.1+ we add an attribute handler, which does this for us
             self._update_details(node, display)
 
@@ -204,7 +222,7 @@ def _handle_summary_click(self, node):
         
         open = not self._is_open(details)
         self._set_open(details, open)
-        if open and self.html.using_tkhtml30:
+        if open and self.html.using_tkhtml30 or not self.html.experimental:
             self._close_other_details(details)
 
     def _on_progress(self, node):
@@ -297,20 +315,14 @@ def _handle_form_submission(self, node, event=None):
                     continue
                 elif nodetype == "file":
                     for value in nodevalue:
-                        data.append(
-                            (nodeattrname, value),
-                        )
+                        data.append((nodeattrname, value),)
                 else:
-                    data.append(
-                        (nodeattrname, nodevalue),
-                    )
+                    data.append((nodeattrname, nodevalue),)
         if not event:
             nodeattrname = self.html.get_node_attribute(node, "name")
             nodevalue = self.html.get_node_attribute(node, "value")
             if nodeattrname and nodevalue:
-                data.append(
-                    (nodeattrname, nodevalue),
-                )
+                data.append((nodeattrname, nodevalue),)
 
         data = urlencode(data)
 
diff --git a/tkinterweb/htmlwidgets.py b/tkinterweb/htmlwidgets.py
index 3ee9ec3..192040f 100755
--- a/tkinterweb/htmlwidgets.py
+++ b/tkinterweb/htmlwidgets.py
@@ -524,6 +524,7 @@ def load_url(self, url, decode=None, force=False):
         :type force: bool, optional"""
         ### TODO: Maybe consider merging load_url, load_file, and load_website into one
         ### One could use the checker from the sample web browser
+        if url.startswith("mailto") and not self._html.request_func: return  # Don't try to load emails! this happend to me once!
         if not self._current_url == url:
             self._previous_url = self._current_url
         if url in utilities.BUILTIN_PAGES:
@@ -745,33 +746,32 @@ def print_page(self, filename=None, cnf={}, **kwargs):
         :return: A string containing the PostScript code.
         :rtype: str
         :raise NotImplementedError: If experimental mode is not enabled."""
-        if self._html.experimental:
-            cnf |= kwargs
-            self._html.post_message(f"Printing {self._current_url}...")
-            if filename:
-                cnf["file"] = filename
-            if "pagesize" in cnf:
-                pagesizes = {
-                    "A3": "842x1191", "A4": "595x842", "A5": "420x595",
-                    "Legal": "612x792", "Letter": "612x1008"
-                }
-                try:
-                    cnf["pagesize"] = pagesizes[cnf["pagesize"].upper()]
-                    self._html.post_message(f"Setting printer page size to {cnf['pagesize']} PostScript points.")
-                except KeyError:
-                    raise KeyError("Parameter 'pagesize' must be A3, A4, A5, Legal, or Letter")
-
-            self._html.update() # Update the root window to ensure HTML is rendered
-            file = self._html.postscript(cnf)
-            
-            # No need to save - Tkhtml handles that for us
-            if filename:
-                self._html.post_message("Printed!")
-            if file: return file
-        else:
+        if not self._html.experimental:
             self._html.post_message("ERROR: The page could not be printed because print_page is an experimental feature")
             raise NotImplementedError("the page could not be printed because print_page is an experimental feature")
 
+        cnf |= kwargs
+        self._html.post_message(f"Printing {self._current_url}...")
+        if filename:
+            cnf["file"] = filename
+        if "pagesize" in cnf:
+            pagesizes = {
+                "A3": "842x1191", "A4": "595x842", "A5": "420x595",
+                "Legal": "612x792", "Letter": "612x1008"
+            }
+            try:
+                cnf["pagesize"] = pagesizes[cnf["pagesize"].upper()]
+                self._html.post_message(f"Setting printer page size to {cnf['pagesize']} PostScript points.")
+            except KeyError:
+                self._html.post_message(f"Setting printer page size to custom {cnf['pagesize']}.")
+
+        self._html.update() # Update the root window to ensure HTML is rendered
+        file = self._html.postscript(cnf)
+        
+        # No need to save - Tkhtml handles that for us
+        if filename: self._html.post_message("Printed!")
+        if file: return file
+
     def save_page(self, filename=None):
         """Return the page's HTML code or save the page as an HTML file.
 
@@ -1542,11 +1542,10 @@ def unbind(self, sequence, *args, **kwargs):
         else:
             self._html.unbind(sequence, *args, **kwargs)
     
-    def __getitem__(self, key):
-        return self.cget(key)
+    def __setitem__(self, k, v): self.configure({k: v})
+
+    __getitem__ = cget
 
-    def __setitem__(self, key, value):
-        self.configure(**{key: value})
 
 
 class HtmlLabel(HtmlFrame):
@@ -1574,7 +1573,10 @@ def __init__(self, master, *, text="", **kwargs):
         tags.remove("Html")
         self._html.bindtags(tags)
 
-        self._style = Style()
+        self._style = Style(self)
+
+        # Match the ttk theme
+        self._ttk_style_css(kwargs, False)
 
         if text: self.load_html(text)
         # I'd like to just make this an else statement to prevent the widget from being a massive white screen when text=""
@@ -1585,15 +1587,6 @@ def __init__(self, master, *, text="", **kwargs):
     
     def load_html(self, *args, _relayout=True, **kwargs):
         ""
-        # Match the ttk theme
-        style_type = self.cget("style")
-        bg = self._style.lookup(style_type, 'background')
-        fg = self._style.lookup(style_type, 'foreground')
-        style = self._html.default_style + \
-            (self._html.dark_style if self._html.dark_theme_enabled else "") +\
-            f"BODY {{ background-color: {bg}; color: {fg}; }}"
-        self._html.configure(defaultstyle=style)
-        
         # Load the HTML
         super().load_html(*args, **kwargs)
 
@@ -1605,13 +1598,26 @@ def load_html(self, *args, _relayout=True, **kwargs):
             self.update_idletasks()
             self._html.relayout()
 
+    def _ttk_style_css(self, kwargs, add_css):
+        style_type = kwargs["style"]
+        bg = self._style.lookup(style_type, 'background')
+        fg = self._style.lookup(style_type, 'foreground')
+        body_style = f"BODY {{ background-color: {bg}; color: {fg}; }}"
+        style = self._html.default_style +\
+            (self._html.dark_style if self._html.dark_theme_enabled else "") +\
+            body_style # This could it be done by appending `style`
+
+        self._html.configure(defaultstyle=style)
+        if add_css: self.add_css(body_style, priority="agent")
+
     def configure(self, **kwargs):
-        ""
+        "Sets the default value of the specified option(s) in Label/HTML."
         if "text" in kwargs:
             self.load_html(kwargs.pop("text"))
             
         if "style" in kwargs:
             utilities.warn("Since version 4.14 the style keyword no longer sets the HtmlLabel's CSS code. Please use the add_css() method instead.")
+            self._ttk_style_css(kwargs, True)
 
         if kwargs: super().configure(**kwargs)
 
@@ -1619,13 +1625,9 @@ def cget(self, key):
         ""
         if "text" == key:
             return "".join(self._html.serialize_node(0).splitlines())
-        elif "style" == key:
-           return "".join(self._html.serialize_node_style(0).splitlines())
         return super().cget(key)
 
-    def config(self, **kwargs):
-        ""
-        self.configure(**kwargs)
+    config = configure
 
 class HtmlText(HtmlFrame):
     """The :class:`HtmlText` widget is a text-like HTML widget. It inherits from the :class:`HtmlFrame` class. 
@@ -2185,6 +2187,31 @@ def __init__(self, **kwargs): #markup=""
     def __str__(self):
         return f"<html>{self.document.documentElement.innerHTML}</html>"
 
+    def webpage(self, url):
+        """HtmlParse needs its own method for loading documents so as not to use threading and load synchronously."""
+        code = 404
+        parsed = urlparse(url)
+
+        fragment = parsed.fragment
+
+        if fragment:
+            fragment = "".join(char for char in fragment if char.isalnum() or char in ("-", "_", ".")).replace(".", r"\.")
+
+        try:
+            newurl, data, filetype, code = self._html.download_url(url)
+            self._html.post_message(f"Successfully connected to {newurl} {filetype}", True)
+
+            self._html.reset()
+            self._html.base_url = newurl
+            self._html.fragment = fragment
+            self._html.parse(data)
+
+        except Exception as error:
+            self._html.post_message(f"ERROR: could not load {url}: {error}")
+            return code, error
+
+    # NOTE: could add shorthand methods for TkinderWeb handler commands, but may be excessive.
+
     def destroy(self):
         super().destroy()
         self.root.destroy()
