justhtml 3.0.0__tar.gz → 3.1.0__tar.gz

{justhtml-3.0.0 → justhtml-3.1.0}/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.1.0] - 2026-07-02
+
+### Changed
+- `CollapseWhitespace(...)` now trims leading and trailing whitespace at block-container edges by default. Pass `trim_blocks=False` to keep the previous html5lib-like behavior, or customize `block_tags=(...)` for project-specific block containers.
+- Document that DOM insertion methods adopt existing nodes, and show how to clone nodes before appending when using parsed DOMs as templates.
+
+### Fixed
+- Apply explicit `UrlPolicy.allow_rules` to custom URL attributes in constructor sanitization and `DropUrlAttrs(...)`. Previously, rules such as `("el-custom", "data-url")` were ignored unless the attribute name was one of JustHTML's built-in URL sinks.
+- Restore strict-mode reporting for unexpected `</p>` end tags after implicit paragraph closure.
+
+### Performance
+- Speed up pretty HTML serialization for direct text-only elements, repeated tag/attribute names, and common empty-attribute elements; reduce repeated selector name normalization and hot parser namespace checks; and fix the real-world profiler script when run directly.
+- Speed up parser URL sanitization for common lowercase `http://` and `https://` attributes.
+
 ## [3.0.0] - 2026-06-21
 
 JustHTML 3.0.0 ships a new parser core. The old tokenizer and tree-builder are now one integrated system, which makes the parser much faster while keeping browser-style HTML5 recovery and default-safe behavior intact. In practice, this release is mainly about getting materially better performance without asking most users to change how they use the library.

{justhtml-3.0.0 → justhtml-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 3.0.0
+Version: 3.1.0
 Summary: A pure Python HTML5 parser that just works.
 Project-URL: Homepage, https://github.com/emilstenstrom/justhtml
 Project-URL: Issues, https://github.com/emilstenstrom/justhtml/issues

{justhtml-3.0.0 → justhtml-3.1.0}/benchmarks/profile.py

@@ -2,9 +2,10 @@
 """Profile JustHTML on real-world HTML."""
 
 import argparse
-import cProfile
+import importlib
 import pathlib
 import pstats
+import sys
 import tarfile
 
 import zstandard as zstd
@@ -49,15 +50,30 @@ def load_html_files(batch_path: pathlib.Path, dict_bytes: bytes, limit: int = 10
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--mode",
+        choices=["parse", "compact-html", "pretty-html", "text", "fragment"],
+        default="parse",
+        help="Pipeline to profile (default: parse)",
+    )
     parser.add_argument(
         "--to-html",
         action="store_true",
-        help="Profile parse + serialization via to_html() (pretty=True by default)",
+        help="Deprecated alias for --mode pretty-html",
     )
     return parser.parse_args()
 
 
+def remove_script_dir_from_import_path() -> None:
+    script_dir = str(pathlib.Path(__file__).resolve().parent)
+    if sys.path and sys.path[0] == script_dir:
+        sys.path.pop(0)
+
+
 def main() -> None:
+    remove_script_dir_from_import_path()
+    cprofile = importlib.import_module("cProfile")
+
     args = parse_args()
 
     dict_bytes = load_dict(pathlib.Path("/home/emilstenstrom/Projects/web100k/html.dict"))
@@ -69,12 +85,26 @@ def main() -> None:
 
     print(f"Loaded {len(html_files)} files")
 
-    profiler = cProfile.Profile()
+    mode = "pretty-html" if args.to_html else args.mode
+
+    profiler = cprofile.Profile()
     profiler.enable()
 
     for _filename, html in html_files:
+        if mode == "fragment":
+            parser = JustHTML(html, fragment=True)
+            _ = parser.root
+            continue
+
         parser = JustHTML(html)
-        _ = parser.to_html() if args.to_html else parser.root
+        if mode == "compact-html":
+            _ = parser.to_html(pretty=False)
+        elif mode == "pretty-html":
+            _ = parser.to_html()
+        elif mode == "text":
+            _ = parser.to_text()
+        else:
+            _ = parser.root
 
     profiler.disable()
 

{justhtml-3.0.0 → justhtml-3.1.0}/docs/api.md

@@ -408,10 +408,16 @@ When you build documents with `JustHTML(..., sanitize=True)` (the default), this
 
 Append a child node to this node.
 
+If `node` already has a parent, it is moved from that parent to this node. Use
+`node.clone_node(deep=True)` before appending when you want to keep the source
+DOM unchanged.
+
 #### `insert_before(node, reference_node)`
 
 Insert `node` before `reference_node` (or append if `reference_node` is `None`).
 
+If `node` already has a parent, it is moved from that parent to this node.
+
 #### `remove_child(node)`
 
 Remove a direct child node.
@@ -420,6 +426,9 @@ Remove a direct child node.
 
 Replace a direct child node with a new node.
 
+If `new_node` already has a parent, it is moved from that parent before it
+replaces `old_node`.
+
 #### `clone_node(deep=False, override_attrs=None)`
 
 Clone this node. If `deep=True`, children are cloned recursively.

{justhtml-3.0.0 → justhtml-3.1.0}/docs/building.md

@@ -435,6 +435,33 @@ lead = doc.query_one("p.lead")
 lead.to_html(pretty=False)  # => <p class="lead">Hello</p>
 ```
 
+### Clone from template DOMs before appending
+
+DOM insertion methods adopt existing nodes. If you append a node that already
+belongs to another tree, it is removed from its old parent and moved into the new
+tree.
+
+When you use one parsed DOM as a template for another document, clone the source
+node before appending it:
+
+```python
+from justhtml import JustHTML
+from justhtml.dom.builder import element
+
+template = JustHTML('<section><p class="lead">Hello</p></section>', fragment=True, sanitize=False)
+output = JustHTML(element("main"), fragment=True, sanitize=False)
+
+lead = template.query_one("p.lead")
+assert lead is not None
+main = output.query_one("main")
+assert main is not None
+
+main.append_child(lead.clone_node(deep=True))
+
+template.to_html(pretty=False)  # => <section><p class="lead">Hello</p></section>
+output.to_html(pretty=False)  # => <main><p class="lead">Hello</p></main>
+```
+
 ## When Not to Use the Builder
 
 Don’t use the builder just because it exists.

{justhtml-3.0.0 → justhtml-3.1.0}/docs/transforms.md

@@ -268,11 +268,16 @@ Advanced building blocks (useful for policy-driven pipelines):
 
 See [`Linkify(...)`](linkify.md) for full documentation and examples.
 
-### `CollapseWhitespace(skip_tags=(...), enabled=True, callback=None, report=None)`
+### `CollapseWhitespace(skip_tags=(...), trim_blocks=True, block_tags=(...), enabled=True, callback=None, report=None)`
 
 Collapses runs of HTML whitespace characters in text nodes to a single space.
+By default, it also trims leading and trailing whitespace at the edges of block
+containers such as `<p>`, `<div>`, and `<li>`.
 
-This is similar to `html5lib.filters.whitespace.Filter`.
+Pass `trim_blocks=False` for html5lib-like whitespace filtering without edge
+trimming. Use `block_tags=(...)` to define which containers trim their edge
+whitespace; `skip_tags` still wins and preserves whitespace inside matching
+tags.
 
 By default it skips `<pre>`, `<textarea>`, `<code>`, `<title>`, `<script>`, and `<style>`.
 
@@ -280,7 +285,7 @@ By default it skips `<pre>`, `<textarea>`, `<code>`, `<title>`, `<script>`, and
 from justhtml import CollapseWhitespace, JustHTML
 
 doc = JustHTML(
-    "<p>Hello \n\t world</p><pre>a  b</pre>",
+    "<p>\n  Hello \n\t world\n</p><pre>a  b</pre>",
     fragment=True,
     transforms=[CollapseWhitespace()],
 )

{justhtml-3.0.0 → justhtml-3.1.0}/docs/url-cleaning.md

@@ -85,7 +85,8 @@ Output:
 
 ## How URL cleaning works (in order)
 
-For a URL-like attribute (like `img[src]` or `a[href]`), JustHTML applies these steps:
+For a URL-like attribute (like `img[src]` or `a[href]`) or a custom attribute with an explicit
+`UrlPolicy(allow_rules=...)` entry, JustHTML applies these steps:
 
 1. The tag must be allowed by `SanitizationPolicy.allowed_tags`.
 2. The attribute name must be allowed by `SanitizationPolicy.allowed_attributes`.
@@ -103,7 +104,9 @@ URL behavior is controlled by `UrlPolicy`:
 - `default_handling`: the default post-validation action for URL-like attributes that match an allow rule and do not set `UrlRule.handling`.
 - `default_allow_relative`: whether **relative** URLs (like `/path`, `./path`, `../path`, `?q`) are allowed by default.
 
-For URL-like attributes that match an explicit `(tag, attr)` rule in `allow_rules`, validated URLs use `UrlPolicy.default_handling` unless that specific `UrlRule` overrides it with `handling=...`.
+For URL-like attributes, or custom attributes that match an explicit `(tag, attr)` or `("*", attr)` rule in
+`allow_rules`, validated URLs use `UrlPolicy.default_handling` unless that specific `UrlRule` overrides it with
+`handling=...`.
 
 Note: URL validation is always enforced by `UrlRule`.
 

{justhtml-3.0.0 → justhtml-3.1.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "justhtml"
 authors = [{ name = "Emil Stenström", email = "emil@emilstenstrom.se" }]
-version = "3.0.0"
+version = "3.1.0"
 description = "A pure Python HTML5 parser that just works."
 readme = "README.md"
 license = { file = "LICENSE" }

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/core/constants.py

@@ -200,6 +200,57 @@ WHITESPACE_PRESERVING_ELEMENTS: Final[frozenset[str]] = frozenset(
     }
 )
 
+WHITESPACE_TRIMMING_BLOCK_ELEMENTS: Final[frozenset[str]] = frozenset(
+    {
+        "address",
+        "article",
+        "aside",
+        "blockquote",
+        "body",
+        "caption",
+        "center",
+        "dd",
+        "details",
+        "dialog",
+        "dir",
+        "div",
+        "dl",
+        "dt",
+        "fieldset",
+        "figcaption",
+        "figure",
+        "footer",
+        "form",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "header",
+        "hgroup",
+        "html",
+        "li",
+        "listing",
+        "main",
+        "menu",
+        "nav",
+        "ol",
+        "p",
+        "search",
+        "section",
+        "summary",
+        "table",
+        "tbody",
+        "td",
+        "tfoot",
+        "th",
+        "thead",
+        "tr",
+        "ul",
+    }
+)
+
 FORMATTING_ELEMENTS = {
     "a",
     "b",

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/parser/engine.py

@@ -319,12 +319,17 @@ def _compile_tag_actions(
         preserve_state_attrs = tag in _ACTIVE_FORMATTING_TAGS and not allowed
         url_attr_kinds: dict[str, UrlSinkKind] = {}
         url_attr_rules: dict[str, UrlRule] = {}
-        for attr in allowed_attrs.intersection(_URL_SINK_ATTRS):
-            rule = url_rules.get((tag, attr))
-            if rule is None:  # pragma: no cover - planner only iterates explicitly configured URL attributes
+        for attr in allowed_attrs:
+            rule = url_rules.get((tag, attr)) or url_rules.get(("*", attr))
+            if attr not in _URL_SINK_ATTRS and rule is None:
                 continue
-            kind = _url_sink_kind_for_attr(tag=tag, attr=attr, attrs={attr: ""})
-            if kind is None:  # pragma: no cover - URL sink attributes always have a declared sink kind
+            if rule is None:  # pragma: no cover - URL sink policy validation rejects missing rules
+                continue
+            if attr in _URL_SINK_ATTRS:
+                kind = _url_sink_kind_for_attr(tag=tag, attr=attr, attrs={attr: ""})
+            else:
+                kind = "url"
+            if kind is None:  # pragma: no cover - guarded URL sink attrs require matching state attrs
                 continue
             url_attr_kinds[attr] = kind
             url_attr_rules[attr] = rule
@@ -972,6 +977,13 @@ class ParseEngine:
             if tag_end == -1:
                 self._emit_error("eof-in-tag", end - 1)
                 return
+            if name in self._p_closing_start_tags:
+                for idx in range(len(open_tags) - 1, -1, -1):
+                    if open_tags[idx] == "p":
+                        del open_tags[idx:]
+                        break
+                    if open_tags[idx] in _P_SCOPE_BOUNDARIES:
+                        break
             if name not in self._void_elements and not self._is_self_closing_source_tag(pos + len(name), tag_end):
                 open_tags.append(name)
             pos = tag_end + 1
@@ -1514,7 +1526,7 @@ class ParseEngine:
             and not self._ignore_lf
             and not self._track_node_locations
             and not self._xml_coercion
-            and parent.namespace in {None, "html"}
+            and (parent.namespace is None or parent.namespace == "html")
             and type(parent) is not Template
             and parent is not self._head
             and parent is not self._html
@@ -2330,8 +2342,10 @@ class ParseEngine:
         if name == "image":
             name = "img"
         action = self._tag_actions.get(name)
-        if self._foreign_context_seen and self._stack[-1].namespace not in {None, "html", _PARSER_ONLY_NAMESPACE}:
-            return self._parse_start_tag(name_start, end)
+        if self._foreign_context_seen:
+            namespace = self._stack[-1].namespace
+            if namespace is not None and namespace != "html" and namespace != _PARSER_ONLY_NAMESPACE:
+                return self._parse_start_tag(name_start, end)
         if not self._initial_mode_done:
             self._mark_initial_content()
 
@@ -5088,6 +5102,12 @@ class ParseEngine:
         if not stripped:
             return None
 
+        allowed_schemes = rule.allowed_schemes
+        if stripped.startswith("https://") and " " not in stripped and stripped.isprintable():
+            return stripped if "https" in allowed_schemes else None
+        if stripped.startswith("http://") and " " not in stripped and stripped.isprintable():
+            return stripped if "http" in allowed_schemes else None
+
         if _URL_CONTROL_CHAR_REGEX.search(stripped):
             return None
 
@@ -5117,7 +5137,6 @@ class ParseEngine:
                 stripped if rule.allow_fragment else None
             )  # pragma: no cover - unreachable after parser-state guards
 
-        allowed_schemes = rule.allowed_schemes
         if normalized.startswith("//"):  # pragma: no branch - opposite edge requires invalid parser state
             resolved = rule.resolve_protocol_relative  # pragma: no cover - unreachable after parser-state guards
             if not resolved:  # pragma: no cover - unreachable after parser-state guards

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/selector/core.py

@@ -575,6 +575,7 @@ class SelectorParser:
         self._expect(TokenType.ATTR_START)
 
         attr_name = self._expect(TokenType.TAG).value
+        attr_name = attr_name.lower() if attr_name else attr_name
 
         token = self._peek()
         if token.type == TokenType.ATTR_END:
@@ -591,6 +592,7 @@ class SelectorParser:
         """Parse a pseudo-class selector like :first-child or :not(selector)."""
         self._expect(TokenType.COLON)
         name = self._expect(TokenType.TAG).value
+        name = name.lower() if name else name
 
         # Functional pseudo-class
         if self._peek().type == TokenType.PAREN_OPEN:
@@ -601,7 +603,7 @@ class SelectorParser:
             self._expect(TokenType.PAREN_CLOSE)
             parsed_arg = (
                 _parse_selector(arg, limits=self.limits, parse_depth=self.parse_depth + 1)
-                if (name or "").lower() == "not" and arg
+                if name == "not" and arg
                 else None
             )
             return SimpleSelector(SimpleSelector.TYPE_PSEUDO, name=name, arg=arg, parsed_arg=parsed_arg)
@@ -773,7 +775,9 @@ class SelectorMatcher:
 
         if sel_type == SimpleSelector.TYPE_TAG:
             # HTML tag names are case-insensitive
-            return bool(node.name.lower() == (selector.name.lower() if selector.name else ""))
+            selector_name = selector.name or ""
+            node_name = node.name
+            return bool(node_name == selector_name or node_name.lower() == selector_name)
 
         if sel_type == SimpleSelector.TYPE_ID:
             node_id = node.attrs.get("id", "") if node.attrs else ""
@@ -803,7 +807,7 @@ class SelectorMatcher:
 
     def _matches_attribute(self, node: Any, selector: SimpleSelector) -> bool:
         """Match an attribute selector."""
-        attr_name = (selector.name or "").lower()  # Attribute names are case-insensitive in HTML
+        attr_name = selector.name or ""  # Attribute names are normalized during parsing.
         attr_value = self._attribute_value(node, attr_name)
 
         if attr_value is None:
@@ -893,7 +897,7 @@ class SelectorMatcher:
 
     def _matches_pseudo(self, node: Any, selector: SimpleSelector, *, depth: int = 0) -> bool:
         """Match a pseudo-class selector."""
-        name = (selector.name or "").lower()
+        name = selector.name or ""
 
         if name == "first-child":
             return self._is_first_child(node)
@@ -1067,7 +1071,7 @@ class SelectorMatcher:
     def _compound_tag_name(self, compound: CompoundSelector) -> str | None:
         for simple in compound.selectors:
             if simple.type == SimpleSelector.TYPE_TAG and simple.name:
-                return simple.name.lower()
+                return simple.name
         return None
 
     def _element_child_names(self, parent: Any) -> frozenset[str]:
@@ -1376,8 +1380,7 @@ def _selector_allows_non_elements(selector: ParsedSelector | CompoundSelector |
     if isinstance(selector, SimpleSelector):
         if selector.type != SimpleSelector.TYPE_PSEUDO:
             return False
-        name = (selector.name or "").lower()
-        return name == "comment"
+        return selector.name == "comment"
     return False
 
 

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/serializer/html.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import re
 from enum import Enum
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any
 from urllib.parse import quote as url_quote
 
@@ -63,10 +64,12 @@ def _validate_serializable_name(name: str, pattern: re.Pattern[str], kind: str)
     return name
 
 
+@lru_cache(maxsize=4096)
 def _validate_serializable_tag_name(name: str) -> str:
     return _validate_serializable_name(name, _SERIALIZABLE_TAG_NAME_RE, "element")
 
 
+@lru_cache(maxsize=8192)
 def _validate_serializable_attr_name(name: str) -> str:
     return _validate_serializable_name(name, _SERIALIZABLE_ATTR_NAME_RE, "attribute")
 
@@ -228,31 +231,33 @@ def serialize_start_tag(
     is_void: bool = False,
 ) -> str:
     name = _validate_serializable_tag_name(name)
-    parts: list[str] = ["<", name]
-    if attrs:
-        parts_extend = parts.extend
-        for raw_key, value in attrs.items():
-            key = _validate_serializable_attr_name(raw_key)
-            if minimize_boolean_attributes:
-                if value is None or value == "" or value == key:
-                    parts_extend((" ", key))
-                    continue
-                if len(value) == len(key) and value.lower() == key:
-                    parts_extend((" ", key))
-                    continue
+    if not attrs:
+        return f"<{name} />" if use_trailing_solidus and is_void else f"<{name}>"
 
-            if value is None or value == "":
-                parts_extend((" ", key, '=""'))
+    parts: list[str] = ["<", name]
+    parts_extend = parts.extend
+    for raw_key, value in attrs.items():
+        key = _validate_serializable_attr_name(raw_key)
+        if minimize_boolean_attributes:
+            if value is None or value == "" or value == key:
+                parts_extend((" ", key))
                 continue
-
-            if not quote_attr_values and _can_unquote_attr_value(value):
-                escaped = value.replace("&", "&amp;").replace("<", "&lt;")
-                parts_extend((" ", key, "=", escaped))
+            if len(value) == len(key) and value.lower() == key:
+                parts_extend((" ", key))
                 continue
 
-            quote = _choose_attr_quote(value, quote_char)
-            escaped = _escape_attr_value(value, quote)
-            parts_extend((" ", key, "=", quote, escaped, quote))
+        if value is None or value == "":
+            parts_extend((" ", key, '=""'))
+            continue
+
+        if not quote_attr_values and _can_unquote_attr_value(value):
+            escaped = value.replace("&", "&amp;").replace("<", "&lt;")
+            parts_extend((" ", key, "=", escaped))
+            continue
+
+        quote = _choose_attr_quote(value, quote_char)
+        escaped = _escape_attr_value(value, quote)
+        parts_extend((" ", key, "=", quote, escaped, quote))
 
     if use_trailing_solidus and is_void:
         parts.append(" />")
@@ -723,12 +728,13 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                 continue
 
             open_tag = serialize_start_tag(name, current.attrs)
-            close_tag = serialize_end_tag(name)
 
             if name in VOID_ELEMENTS:
                 results.append(f"{prefix}{open_tag}")
                 continue
 
+            close_tag = f"</{name}>"
+
             children: list[Any] = (
                 current.template_content.children
                 if name == "template" and current.namespace in {None, "html"} and current.template_content is not None
@@ -748,7 +754,11 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                         all_text = False
                         break
                 if all_text:
-                    text_content = current.to_text(separator="", strip=False)
+                    text_content = (
+                        children[0].data or ""
+                        if len(children) == 1 and children[0] is not None
+                        else "".join(child.data or "" for child in children if child is not None)
+                    )
                     text_content = _collapse_html_whitespace(text_content)
                     results.append(f"{prefix}{open_tag}{_serialize_text_for_parent(text_content, name)}{close_tag}")
                     continue

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/transforms/__init__.py

@@ -233,6 +233,8 @@ TransformSpec = Transform | Stage
 class _CompiledCollapseWhitespaceTransform:
     kind: Literal["collapse_whitespace"]
     skip_tags: frozenset[str]
+    trim_blocks: bool
+    block_tags: frozenset[str]
     callback: NodeCallback | None
     report: ReportCallback | None
 

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/transforms/compile.py

@@ -775,11 +775,14 @@ def _compile_drop_url_attrs_transform(
 
         for key in attrs:
             lower_key = key if key.islower() else key.lower()
-            if lower_key not in url_sink_attrs:
+            rule = url_policy.allow_rules.get((tag, lower_key)) or url_policy.allow_rules.get(("*", lower_key))
+            if lower_key not in url_sink_attrs and rule is None:
                 continue
             raw_value = attrs[key]
 
-            sink_kind = _url_sink_kind_for_attr(tag=tag, attr=lower_key, attrs=attrs)
+            sink_kind = (
+                _url_sink_kind_for_attr(tag=tag, attr=lower_key, attrs=attrs) if lower_key in url_sink_attrs else "url"
+            )
             if sink_kind is None:
                 continue
 
@@ -791,7 +794,6 @@ def _compile_drop_url_attrs_transform(
                 to_drop.append(key)
                 continue
 
-            rule = url_policy.allow_rules.get((tag, lower_key))
             if rule is None:
                 if on_report is not None:  # pragma: no cover
                     on_report(f"Unsafe URL in attribute '{lower_key}' (no rule)", node=node)
@@ -968,6 +970,8 @@ def _compile_collapse_whitespace_transform(t: CollapseWhitespace) -> _CompiledCo
     return _CompiledCollapseWhitespaceTransform(
         kind="collapse_whitespace",
         skip_tags=t.skip_tags,
+        trim_blocks=t.trim_blocks,
+        block_tags=t.block_tags,
         callback=t.callback,
         report=t.report,
     )

{justhtml-3.0.0 → justhtml-3.1.0}/src/justhtml/transforms/runtime.py

@@ -258,6 +258,26 @@ def apply_compiled_transforms(
                 node.parent = None
                 return True
 
+            def _trim_block_edge_text(
+                text_data: str,
+                *,
+                parent: Node,
+                children: list[Node],
+                child_index: int,
+                block_tags: frozenset[str],
+            ) -> str:
+                parent_name = parent.name
+                if parent_name.startswith("#") or parent_name == "!doctype":
+                    return text_data
+                if parent_name.lower() not in block_tags:
+                    return text_data
+
+                if child_index == 0:
+                    text_data = text_data.lstrip(" \t\n\f\r")
+                if child_index == len(children) - 1:
+                    text_data = text_data.rstrip(" \t\n\f\r")
+                return text_data
+
             def apply_to_children(
                 parent: Node,
                 *,
@@ -480,12 +500,27 @@ def apply_compiled_transforms(
                                 text_data = str(node.data or "")
                                 if text_data:
                                     collapsed = _collapse_html_space_characters(text_data)
-                                    if collapsed != text_data:
+                                    normalized = collapsed
+                                    if t.trim_blocks:
+                                        normalized = _trim_block_edge_text(
+                                            normalized,
+                                            parent=parent,
+                                            children=children,
+                                            child_index=i,
+                                            block_tags=t.block_tags,
+                                        )
+                                    if normalized != text_data:
                                         if t.callback is not None:
                                             t.callback(node)
                                         if t.report is not None:
                                             t.report("Collapsed whitespace in text node", node=node)
-                                        node.data = collapsed
+                                        if normalized:
+                                            node.data = normalized
+                                        else:
+                                            children.pop(i)
+                                            node.parent = None
+                                            changed = True
+                                            break
                             continue
 
                         if k == "strip_invisible_unicode":