justhtml 3.7.0__tar.gz → 3.9.0__tar.gz

{justhtml-3.7.0 → justhtml-3.9.0}/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [3.9.0] - 2026-07-20
+
+### Performance
+
+Combined, the changes below reduce default-constructor parse time by about 9.5% relative to 3.8.0, on top of that release's 40% reduction from 3.7.1.
+
+- Speed up the default `JustHTML()` constructor by about 3% on the web100k parser benchmark by moving the common text and compiled-attribute paths into their callers and avoiding full active-formatting bookkeeping for uncomplicated first entries.
+- Reduce another 1.2% of default-constructor parse time by dispatching start and end tags before uncommon markup and removing redundant CDATA probes and regular-expression offset lookups while skipping dropped subtrees.
+- Reduce default-constructor parse time by another 2% on a 1,000-document web100k sample by clearing stale foreign-context scan state, using C-level membership for ASCII tag dispatch, and inlining bounded case-insensitive raw-text matching.
+- Reduce default-constructor parse time by another 3.6% on a 1,000-document web100k sample and shrink ordinary element nodes by one third by lazily allocating source-location metadata and bypassing adaptive stack bookkeeping for shallow end-tag mutations.
+
+## [3.8.0] - 2026-07-19
+
+### Performance
+
+On the web100k parser benchmark (1,000 documents, three iterations), the default `JustHTML()` constructor now completes in 13.020 seconds rather than 21.648 seconds in 3.7.1: a 40% reduction in parse time, or about 1.7× higher throughput.
+
+- Speed up the default `JustHTML()` constructor by compiling common start/end-tag and URL-sanitization decisions, and by folding only names that the parser encounters instead of copying and lowercasing the full input.
+- Reduce tree-construction overhead by adaptively tracking open elements, removing completed formatting entries without leaving tombstones, and deferring formatting-attribute signatures until duplicate tracking actually needs them.
+- Remove redundant constructor-path work for discarded end-tag attributes, canonical attribute names, shallow non-paragraph stack updates, active-formatting bookkeeping, and parser state that could never become active.
+- Cut fixed default-constructor overhead by reusing built-in execution plans, skipping no-op finalization and error-list work, lazily allocating formatting indexes, and collapsing duplicate shell, mode, and end-of-input state.
+- Collapse common start-tag and text insertion-mode checks into synchronized state flags, avoiding repeated condition ladders in the default `JustHTML()` constructor.
+- Avoid open-elements membership scans for ordinary HTML insertions and batch large disallowed-wrapper projections instead of repeatedly searching and shifting the same child lists.
+- Remove already-resolved sanitizer insertion, unknown-tag condition ladders, template-mode lookups, and wrapper-list copies from the default `JustHTML()` constructor path.
+
+### Security
+
+- (Severity: Low) Keep sanitization projection linear for large runs of disallowed sibling wrappers and avoid depth-proportional parent validation for nested wrappers. Previously, crafted wrapper-heavy HTML could make the default `JustHTML()` constructor take quadratic time.
+
+## [3.7.1] - 2026-07-17
+
+### Fixed
+
+- Make `CollapseWhitespace(...)` trim text at block-sibling and line-break boundaries, including `<pre>`, `<hr>`, and `<br>`.
+- Preserve visible spacing around closed dialogs and hidden elements while ignoring comments, processing instructions, empty text nodes, and native non-rendering elements when locating rendered siblings.
+- Collapse whitespace across adjacent text runs exposed by transforms such as `Unwrap(...)` and `DropComments(...)` without merging the text nodes.
+
 ## [3.7.0] - 2026-07-15
 
 ### Fixed

{justhtml-3.7.0 → justhtml-3.9.0}/PERFORMANCE.md

@@ -22,6 +22,31 @@ Set `WEB100K_DIR` to use another location, or pass `--batches-dir` and
 pip install -e ".[benchmark]"
 ```
 
+`html5-parser` (the Gumbo benchmark) and `lxml` must use the same libxml2
+implementation. The `html5-parser` wheel uses the system libxml2, while a
+current `lxml` wheel embeds a newer one. Remove that wheel and rebuild only
+`lxml` against the local library:
+
+```bash
+pip uninstall -y lxml
+pip install --no-cache-dir --no-binary=lxml 'lxml==6.1.1'
+```
+
+Confirm that they agree before running the benchmark:
+
+```bash
+python -c 'from lxml import etree; import html5_parser; print(etree.LIBXML_VERSION)'
+```
+
+If pip cannot build lxml, install your platform's libxml2 development package
+and C compiler, then repeat the second command. Reinstalling the project extra
+after this step is unnecessary and can reselect the binary lxml wheel.
+
+The latest MarkupEver and TurboHTML wheels do not currently load on Python
+3.15 pre-releases. On that interpreter they are reported as unavailable while
+the remaining benchmark parsers, including Gumbo, still run. Use a supported
+stable Python release when those comparisons are required.
+
 ## Measure the right pipeline
 
 The benchmark has separate modes for parsing alone and parsing followed by

{justhtml-3.7.0 → justhtml-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 3.7.0
+Version: 3.9.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
@@ -35,14 +35,14 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Provides-Extra: benchmark
-Requires-Dist: beautifulsoup4; extra == 'benchmark'
-Requires-Dist: html5-parser; extra == 'benchmark'
-Requires-Dist: html5lib; extra == 'benchmark'
-Requires-Dist: lxml; extra == 'benchmark'
-Requires-Dist: markupever; extra == 'benchmark'
+Requires-Dist: beautifulsoup4>=4.14.3; extra == 'benchmark'
+Requires-Dist: html5-parser>=0.4.12; extra == 'benchmark'
+Requires-Dist: html5lib>=1.1; extra == 'benchmark'
+Requires-Dist: lxml>=6.1.1; extra == 'benchmark'
+Requires-Dist: markupever>=0.3.4; extra == 'benchmark'
 Requires-Dist: selectolax>=0.4.11; extra == 'benchmark'
-Requires-Dist: turbohtml>=1.3.1; extra == 'benchmark'
-Requires-Dist: zstandard; extra == 'benchmark'
+Requires-Dist: turbohtml>=1.4.0; extra == 'benchmark'
+Requires-Dist: zstandard>=0.25.0; extra == 'benchmark'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: coverage; extra == 'dev'

{justhtml-3.7.0 → justhtml-3.9.0}/benchmarks/performance.py

@@ -454,6 +454,8 @@ def benchmark_gumbo(html_source, iterations=1):
         import html5_parser
     except ImportError:
         return {"error": "html5-parser not installed (pip install html5-parser)"}
+    except RuntimeError as e:
+        return {"error": f"html5-parser unavailable ({e})"}
     times = []
     errors = 0
     total_bytes = 0
@@ -493,8 +495,10 @@ def benchmark_markupever(html_source, iterations=1):
     """Benchmark markupever parser."""
     try:
         from markupever import parse
-    except ImportError:
-        return {"error": "markupever not installed (pip install markupever)"}
+    except ImportError as e:
+        return {"error": f"markupever unavailable ({e})"}
+    except (RuntimeError, SystemError) as e:
+        return {"error": f"markupever unavailable ({e})"}
     times = []
     errors = 0
     total_bytes = 0
@@ -534,8 +538,10 @@ def benchmark_turbohtml(html_source, iterations=1):
     """Benchmark TurboHTML parser."""
     try:
         from turbohtml import parse
-    except ImportError:
-        return {"error": "turbohtml not installed (pip install turbohtml)"}
+    except ImportError as e:
+        return {"error": f"turbohtml unavailable ({e})"}
+    except (RuntimeError, SystemError) as e:
+        return {"error": f"turbohtml unavailable ({e})"}
     times = []
     errors = 0
     total_bytes = 0

{justhtml-3.7.0 → justhtml-3.9.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "justhtml"
 authors = [{ name = "Emil Stenström", email = "emil@emilstenstrom.se" }]
-version = "3.7.0"
+version = "3.9.0"
 description = "A pure Python HTML5 parser that just works."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -14,14 +14,14 @@ classifiers = [
 
 [project.optional-dependencies]
 benchmark = [
-    "zstandard",
-    "html5lib",
-    "lxml",
-    "beautifulsoup4",
+    "zstandard>=0.25.0",
+    "html5lib>=1.1",
+    "lxml>=6.1.1",
+    "beautifulsoup4>=4.14.3",
     "selectolax>=0.4.11",
-    "html5-parser",
-    "markupever",
-    "turbohtml>=1.3.1",
+    "html5-parser>=0.4.12",
+    "markupever>=0.3.4",
+    "turbohtml>=1.4.0",
 ]
 dev = [
     "ruff==0.14.7",

{justhtml-3.7.0 → justhtml-3.9.0}/src/justhtml/core/constants.py

@@ -230,6 +230,7 @@ WHITESPACE_TRIMMING_BLOCK_ELEMENTS: Final[frozenset[str]] = frozenset(
         "header",
         "hgroup",
         "html",
+        "hr",
         "li",
         "listing",
         "main",
@@ -237,6 +238,7 @@ WHITESPACE_TRIMMING_BLOCK_ELEMENTS: Final[frozenset[str]] = frozenset(
         "nav",
         "ol",
         "p",
+        "pre",
         "search",
         "section",
         "summary",

{justhtml-3.7.0 → justhtml-3.9.0}/src/justhtml/dom/__init__.py

@@ -132,10 +132,7 @@ def _to_text_collect_block_chunks(node: NodeType, chunks: list[list[str]], strip
 
 class Node:
     __slots__ = (
-        "_origin_col",
-        "_origin_line",
-        "_origin_pos",
-        "_source_html",
+        "_metadata",
         "attrs",
         "children",
         "data",
@@ -150,10 +147,7 @@ class Node:
     children: list[Any] | None
     data: str | Doctype | None
     namespace: str | None
-    _origin_pos: int | None
-    _origin_line: int | None
-    _origin_col: int | None
-    _source_html: str | None
+    _metadata: list[str | int | None] | None
 
     def __init__(
         self,
@@ -165,10 +159,7 @@ class Node:
         self.name = name
         self.parent = None
         self.data = data
-        self._source_html = None
-        self._origin_pos = None
-        self._origin_line = None
-        self._origin_col = None
+        self._metadata = None
 
         if name.startswith("#") or name == "!doctype":
             self.namespace = namespace
@@ -220,6 +211,66 @@ class Node:
         node.parent = None
         return old_parent, old_index
 
+    @property
+    def _source_html(self) -> str | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("str | None", metadata[0])
+
+    @_source_html.setter
+    def _source_html(self, value: str | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[0] = value
+
+    @property
+    def _origin_pos(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[1])
+
+    @_origin_pos.setter
+    def _origin_pos(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[1] = value
+
+    @property
+    def _origin_line(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[2])
+
+    @_origin_line.setter
+    def _origin_line(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[2] = value
+
+    @property
+    def _origin_col(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[3])
+
+    @_origin_col.setter
+    def _origin_col(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[3] = value
+
     @property
     def origin_offset(self) -> int | None:
         """Best-effort origin offset (0-indexed) in the source HTML, if known."""
@@ -429,10 +480,7 @@ class Node:
             self.data,
             self.namespace,
         )
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         if deep:
             return _clone_subtree_iterative(self)
         return clone
@@ -447,10 +495,7 @@ class Document(Node):
     def clone_node(self, deep: bool = False, override_attrs: dict[str, str | None] | None = None) -> Document:
         _ = override_attrs
         clone = Document()
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         if deep:
             return cast("Document", _clone_subtree_iterative(self))
         return clone
@@ -465,10 +510,7 @@ class DocumentFragment(Node):
     def clone_node(self, deep: bool = False, override_attrs: dict[str, str | None] | None = None) -> DocumentFragment:
         _ = override_attrs
         clone = DocumentFragment()
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         if deep:
             return cast("DocumentFragment", _clone_subtree_iterative(self))
         return clone
@@ -484,10 +526,7 @@ class Comment(Node):
         _ = override_attrs
         _ = deep
         clone = Comment(self.data if isinstance(self.data, str) else None)
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         return clone
 
 
@@ -503,31 +542,20 @@ class ProcessingInstruction(Node):
         _ = override_attrs
         _ = deep
         clone = ProcessingInstruction(self.data if isinstance(self.data, str) else None)
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         return clone
 
 
 class Element(Node):
     __slots__ = (
-        "_end_tag_end",
         "_end_tag_present",
-        "_end_tag_start",
         "_self_closing",
-        "_start_tag_end",
-        "_start_tag_start",
         "template_content",
     )
 
     template_content: Node | None
     children: list[Any]
     attrs: dict[str, str | None]
-    _start_tag_start: int | None
-    _start_tag_end: int | None
-    _end_tag_start: int | None
-    _end_tag_end: int | None
     _end_tag_present: bool
     _self_closing: bool
 
@@ -539,28 +567,74 @@ class Element(Node):
         self.children = []
         self.attrs = attrs if attrs is not None else {}
         self.template_content = None
-        self._source_html = None
-        self._origin_pos = None
-        self._origin_line = None
-        self._origin_col = None
-        self._start_tag_start = None
-        self._start_tag_end = None
-        self._end_tag_start = None
-        self._end_tag_end = None
+        self._metadata = None
         self._end_tag_present = False
         self._self_closing = False
 
+    @property
+    def _start_tag_start(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[4])
+
+    @_start_tag_start.setter
+    def _start_tag_start(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[4] = value
+
+    @property
+    def _start_tag_end(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[5])
+
+    @_start_tag_end.setter
+    def _start_tag_end(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[5] = value
+
+    @property
+    def _end_tag_start(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[6])
+
+    @_end_tag_start.setter
+    def _end_tag_start(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[6] = value
+
+    @property
+    def _end_tag_end(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else cast("int | None", metadata[7])
+
+    @_end_tag_end.setter
+    def _end_tag_end(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None] * 8
+            self._metadata = metadata
+        metadata[7] = value
+
     def clone_node(self, deep: bool = False, override_attrs: dict[str, str | None] | None = None) -> Element:
         attrs = override_attrs.copy() if override_attrs is not None else (self.attrs.copy() if self.attrs else {})
         clone = Element(self.name, attrs, self.namespace)
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
-        clone._start_tag_start = self._start_tag_start
-        clone._start_tag_end = self._start_tag_end
-        clone._end_tag_start = self._end_tag_start
-        clone._end_tag_end = self._end_tag_end
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         clone._end_tag_present = self._end_tag_present
         clone._self_closing = self._self_closing
         if deep:
@@ -593,14 +667,7 @@ class Template(Element):
             None,
             self.namespace,
         )
-        clone._source_html = self._source_html
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
-        clone._start_tag_start = self._start_tag_start
-        clone._start_tag_end = self._start_tag_end
-        clone._end_tag_start = self._end_tag_start
-        clone._end_tag_end = self._end_tag_end
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         clone._end_tag_present = self._end_tag_present
         clone._self_closing = self._self_closing
         if deep:
@@ -637,24 +704,65 @@ def _clone_subtree_iterative(root: Node) -> Node:
 
 
 class Text:
-    __slots__ = ("_origin_col", "_origin_line", "_origin_pos", "data", "name", "namespace", "parent")
+    __slots__ = ("_metadata", "data", "name", "namespace", "parent")
 
     data: str | None
     name: str
     namespace: None
     parent: Node | None
-    _origin_pos: int | None
-    _origin_line: int | None
-    _origin_col: int | None
+    _metadata: list[int | None] | None
 
     def __init__(self, data: str | None) -> None:
         self.data = data
         self.parent = None
         self.name = "#text"
         self.namespace = None
-        self._origin_pos = None
-        self._origin_line = None
-        self._origin_col = None
+        self._metadata = None
+
+    @property
+    def _origin_pos(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else metadata[0]
+
+    @_origin_pos.setter
+    def _origin_pos(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None, None, None]
+            self._metadata = metadata
+        metadata[0] = value
+
+    @property
+    def _origin_line(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else metadata[1]
+
+    @_origin_line.setter
+    def _origin_line(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None, None, None]
+            self._metadata = metadata
+        metadata[1] = value
+
+    @property
+    def _origin_col(self) -> int | None:
+        metadata = self._metadata
+        return None if metadata is None else metadata[2]
+
+    @_origin_col.setter
+    def _origin_col(self, value: int | None) -> None:
+        metadata = self._metadata
+        if metadata is None:
+            if value is None:
+                return
+            metadata = [None, None, None]
+            self._metadata = metadata
+        metadata[2] = value
 
     @property
     def origin_offset(self) -> int | None:
@@ -712,9 +820,7 @@ class Text:
     def clone_node(self, deep: bool = False) -> Text:
         _ = deep
         clone = Text(self.data)
-        clone._origin_pos = self._origin_pos
-        clone._origin_line = self._origin_line
-        clone._origin_col = self._origin_col
+        clone._metadata = self._metadata.copy() if self._metadata is not None else None
         return clone
 
 

{justhtml-3.7.0 → justhtml-3.9.0}/src/justhtml/parser/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from justhtml.core.types import ParseError
 from justhtml.dom import Document, DocumentFragment, Node, QueryMatch, Text
@@ -20,7 +20,6 @@ from .engine import (
     ParseEngine,
     can_compile_engine_plan,
     compile_default_engine_plan,
-    compile_engine_plan,
     compile_raw_engine_plan,
 )
 
@@ -150,7 +149,9 @@ class JustHTML:
         self.encoding = None
 
         html_str: str
-        if isinstance(html, (Node, Text)):
+        if type(html) is str:
+            html_str = html
+        elif isinstance(html, (Node, Text)):
             html_for_serialization = html
             if sanitize_enabled or has_sanitize_transform or has_harden_rawtext_transform:
                 from justhtml.sanitizer import (  # noqa: PLC0415
@@ -179,40 +180,28 @@ class JustHTML:
         # Node location tracking is opt-in to avoid slowing down the common case.
         should_collect = collect_errors or strict
 
-        engine_policy: SanitizationPolicy | None = None
-        if sanitize_enabled and not transforms:
-            if policy is not None:
-                engine_policy = policy
-            else:
-                from justhtml.sanitizer import DEFAULT_DOCUMENT_POLICY, DEFAULT_POLICY  # noqa: PLC0415
-
-                engine_policy = DEFAULT_POLICY if fragment else DEFAULT_DOCUMENT_POLICY
-
-        xml_coercion = False
-        emit_bogus_markup_as_text = False
-        discard_bom = bool(getattr(_parser_opts, "discard_bom", True))
-        if discard_bom and html_str.startswith("\ufeff"):
-            html_str = html_str[1:]
-        if _parser_opts is not None:
-            xml_coercion = bool(getattr(_parser_opts, "xml_coercion", False))
-            emit_bogus_markup_as_text = bool(getattr(_parser_opts, "emit_bogus_markup_as_text", False))
+        if _parser_opts is None:
+            discard_bom = True
+            xml_coercion = False
+            emit_bogus_markup_as_text = False
+        else:
+            discard_bom = _parser_opts.discard_bom
+            xml_coercion = _parser_opts.xml_coercion
+            emit_bogus_markup_as_text = _parser_opts.emit_bogus_markup_as_text
             if emit_bogus_markup_as_text:
                 track_tag_spans = True
+        if discard_bom and html_str.startswith("\ufeff"):
+            html_str = html_str[1:]
 
         use_compiled_safe_engine = (
-            engine_policy is not None and not transforms and can_compile_engine_plan(engine_policy, fragment=fragment)
+            sanitize_enabled
+            and not transforms
+            and (policy is None or can_compile_engine_plan(policy, fragment=fragment))
         )
         if use_compiled_safe_engine:
-            if policy is None:
-                engine_plan = compile_default_engine_plan(fragment=fragment, scripting_enabled=scripting_enabled)
-            else:
-                engine_plan = compile_engine_plan(
-                    policy=cast("SanitizationPolicy", engine_policy),
-                    fragment=fragment,
-                    scripting_enabled=scripting_enabled,
-                )
+            engine_plan = compile_default_engine_plan(fragment, scripting_enabled)
         else:
-            engine_plan = compile_raw_engine_plan(fragment=fragment, scripting_enabled=scripting_enabled)
+            engine_plan = compile_raw_engine_plan(fragment, scripting_enabled)
 
         engine = ParseEngine(
             html_str,
@@ -223,14 +212,14 @@ class JustHTML:
             collect_errors=should_collect,
             max_errors=max_errors,
             iframe_srcdoc=iframe_srcdoc,
-            track_node_locations=bool(track_node_locations),
-            track_tag_spans=bool(track_node_locations) or track_tag_spans,
+            track_node_locations=track_node_locations,
+            track_tag_spans=track_node_locations or track_tag_spans,
             emit_bogus_markup_as_text=emit_bogus_markup_as_text,
             xml_coercion=xml_coercion,
         )
         self.root = engine.parse()
 
-        transform_errors: list[ParseError] = _BoundedErrorList(max_errors - len(engine.errors))
+        errors = engine.errors
         if not use_compiled_safe_engine:
             transform_errors = self._apply_constructor_transforms(
                 transforms=transforms,
@@ -239,11 +228,9 @@ class JustHTML:
                 has_sanitize_transform=has_sanitize_transform,
                 max_errors=max_errors - len(engine.errors),
             )
+            errors = engine.errors + transform_errors if should_collect else transform_errors
 
-        if should_collect:
-            self.errors = self._sorted_errors(engine.errors + transform_errors)
-        else:
-            self.errors = transform_errors
+        self.errors = self._sorted_errors(errors) if should_collect else errors
         if strict and self.errors:
             raise StrictModeError(self.errors[0])