justhtml 2.4.0__tar.gz → 3.0.0__tar.gz

{justhtml-2.4.0 → justhtml-3.0.0}/.github/copilot-instructions.md

@@ -6,19 +6,20 @@
 - Keep preambles to a single declarative sentence ("I'm scanning the repo and then drafting a minimal fix.") — no approval requests.
 
 ### Architecture Snapshot
-- Tokenizer (`tokenizer.py`): HTML5 spec state machine (~60 states). Handles RCDATA, RAWTEXT, CDATA, script escaping, comments, DOCTYPE, etc.
-- Tree builder (`treebuilder.py`): Token sink that constructs DOM tree following HTML5 construction rules.
-- Node tree (`node.py`): DOM-like structure. Always use `append_child()` / `insert_before()` for tree operations.
-- Entities (`entities.py`): HTML5 character reference decoding (named & numeric entities).
-- Constants (`constants.py`): HTML5 element categories, void elements, formatting elements, etc.
+- Parser engine (`src/justhtml/parser/engine.py`): Plan-driven tokenization, tree construction, sanitizer projection, and HTML5 recovery behavior.
+- Parser scanner (`src/justhtml/parser/scanner.py`): Shared low-level scanning for tags, rawtext, and script end markers.
+- DOM (`src/justhtml/dom/`): DOM-like node tree. Use `append_child()` / `insert_before()` for public tree operations.
+- Entities (`src/justhtml/core/entities.py`): HTML5 named and numeric character-reference decoding.
+- Constants (`src/justhtml/core/constants.py`): HTML5 element categories, void elements, formatting elements, and namespaces.
+- Transforms (`src/justhtml/transforms/`): Compiled post-parse tree transformations.
 
 ### Golden Rules
 1. **Spec compliance first**: Follow WHATWG HTML5 spec exactly. No heuristics, no shortcuts.
 2. **No exceptions in hot paths**: Use deterministic control flow, not try/except for branching.
 3. **No reflective probing**: No `hasattr`, `getattr`, or `delattr` - all data structures used are deterministic.
-4. **Minimal allocations**: Reuse buffers, avoid per-token object creation in tokenizer.
-5. **Token reuse**: Create new token objects when emitting (don't reuse references).
-6. **State machine purity**: Tokenizer state transitions follow spec state machine exactly.
+4. **Minimal allocations**: Reuse buffers and avoid transient objects in parser hot paths.
+5. **Node ownership**: Move nodes through DOM helpers and keep parent/child links consistent.
+6. **State-machine clarity**: Keep parser recovery and insertion-mode transitions explicit.
 7. **No test-specific code**: No references to test files in comments or code.
 
 ### Testing Workflow
@@ -75,7 +76,7 @@
 - Debug calls: `self.debug()` / `parser.debug()` - no gating needed
 
 ### Performance Mindset
-- Tokenizer is hot path: minimize allocations, avoid string slicing
+- Parser scanning and tree construction are hot paths: minimize allocations and avoid unnecessary string slicing
 - Use `str.find()` for scanning, not regex when possible
 - Reuse buffers: `text_buffer`, `current_tag_name`, etc.
 - Infer state from structure (stacks, tree) instead of storing flags

{justhtml-2.4.0 → justhtml-3.0.0}/.pre-commit-config.yaml

@@ -37,3 +37,9 @@ repos:
         language: system
         pass_filenames: false
         always_run: true
+      - id: parser-differential
+        name: Parser Differential
+        entry: bash -c 'PYTHONPATH=src python benchmarks/html5lib_engine_diff.py --fail-under-rate 1.0 --fail-on-current-exceptions'
+        language: system
+        pass_filenames: false
+        always_run: true

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

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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.
+
+The breaking part is narrow: if you do not depend on `doc.errors` or on the exact diagnostic details raised by `strict=True`, this release should behave like a faster, more robust JustHTML. If you do depend on parser diagnostics, expect different error codes, counts, locations, and ordering from the old implementation.
+
+### Changed
+- Replace the legacy tokenizer/tree-builder split with one plan-driven parser engine shared across sanitized, unsanitized, fragment, streaming, diagnostic, and source-location modes. This is a new parser architecture, not just an optimization pass: scanning, tree construction, and default-safe decisions now run as one coordinated system.
+- BREAKING: Rework parser diagnostics around a smaller, higher-value built-in error set. `collect_errors=True` and `strict=True` still surface parser problems, but callers should expect different error codes, counts, locations, and ordering than the old tokenizer/tree-builder pipeline.
+
+### Performance
+- Deliver roughly a **2x parsing speedup** from the new fused engine while preserving browser-style HTML5 recovery behavior. The hot path now avoids the old tokenizer-to-treebuilder handoff, compiles default sanitizer decisions into parser tag actions, and scans projected attributes directly while parsing.
+
+### Fixed
+- Preserve HTML5 tree-construction behavior across foreign-content integration points, select/table recovery, framesets, plaintext formatting reconstruction, form-pointer handling, malformed comments, foreign attribute parsing, adoption-agency edge cases, and scope-repair bugs found through Chromium and html5lib differentials.
+- Stabilize sanitization of malformed foreign-namespace rawtext structures so trailing HTML cannot be exposed by mutation-XSS reparsing.
+
+### Breaking
+- BREAKING: Error collection is no longer a compatibility surface for the legacy parser internals. Applications that assert on the exact contents of `doc.errors`, or on the specific exception details raised by `strict=True`, must update to the new diagnostic model. Other users should not need API changes for this release.
+
+## [2.4.1] - 2026-06-21
+
+### Fixed
+- Prevent the leading-line-feed exception for `<pre>`, `<listing>`, and `<textarea>` from leaking past intervening non-character tokens and removing a later newline.
+- Apply paragraph closing and leading-line-feed handling to `<pre>` and `<listing>` inside customizable `<select>` content.
+- Preserve U+000C FORM FEED in HTML text like browsers do, while retaining its intentional conversion to a space in XML-coercion mode.
+
 ## [2.4.0] - 2026-06-20
 
 ### Fixed

{justhtml-2.4.0 → justhtml-3.0.0}/CONTRIBUTING.md

@@ -58,6 +58,7 @@ Pre-commit runs automatically on every commit and checks:
 - **Ruff check** - linting with auto-fix
 - **Ruff format** - code formatting
 - **Tests & Coverage** - full test suite with 100% coverage requirement
+- **Parser Differential** - exact agreement with the reference parser path across scored html5lib tree cases
 
 Run manually:
 ```bash
@@ -92,15 +93,16 @@ python benchmarks/profile.py
 
 ## Architecture Notes
 
-- **Tokenizer** (`tokenizer.py`): HTML5 spec state machine
-- **Tree builder** (`treebuilder.py`): Constructs DOM tree following HTML5 rules
-- **Node tree** (`node.py`): DOM-like structure, use `append_child()` / `insert_before()`
-- **Selector** (`selector.py`): CSS selector matching
+- **Parser engine** (`src/justhtml/parser/engine.py`): Plan-driven tokenization, tree construction, and sanitizer projection
+- **Parser scanner** (`src/justhtml/parser/scanner.py`): Shared low-level tag and rawtext scanning helpers
+- **DOM** (`src/justhtml/dom/`): DOM-like node tree; use `append_child()` / `insert_before()` for public tree operations
+- **Selectors** (`src/justhtml/selector/`): CSS selector parsing and matching
+- **Transforms** (`src/justhtml/transforms/`): Compiled post-parse tree transformations
 
 Golden rules:
 1. Follow WHATWG HTML5 spec exactly
 2. No exceptions in hot paths
-3. Minimal allocations in tokenizer
+3. Minimal allocations in parser hot paths
 4. No `hasattr`/`getattr`/`delattr` - all structures are deterministic
 
 ## Submitting Changes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 2.4.0
+Version: 3.0.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
@@ -164,9 +164,11 @@ justhtml index.html --selector "article" --format markdown
 
 ## Correctness
 
-JustHTML is tested against the official html5lib tokenizer, tree-construction, serializer, and encoding fixtures, plus project-specific sanitizer, selector, transform, CLI, and regression tests.
+JustHTML is tested against the official html5lib tree-construction, serializer, and encoding fixtures, plus project-specific sanitizer, selector, transform, CLI, and regression tests.
 
-The current test summary is 10,257 passing tests with 100% line and branch coverage. See [Correctness Testing](docs/correctness.md) for details.
+The current test suite enforces 100% combined line and branch coverage, including the parser engine.
+The parser engine additionally requires exact agreement with the reference path across the html5lib tree suite.
+See [Correctness Testing](docs/correctness.md) for details.
 
 ## Documentation
 

{justhtml-2.4.0 → justhtml-3.0.0}/README.md

@@ -110,9 +110,11 @@ justhtml index.html --selector "article" --format markdown
 
 ## Correctness
 
-JustHTML is tested against the official html5lib tokenizer, tree-construction, serializer, and encoding fixtures, plus project-specific sanitizer, selector, transform, CLI, and regression tests.
+JustHTML is tested against the official html5lib tree-construction, serializer, and encoding fixtures, plus project-specific sanitizer, selector, transform, CLI, and regression tests.
 
-The current test summary is 10,257 passing tests with 100% line and branch coverage. See [Correctness Testing](docs/correctness.md) for details.
+The current test suite enforces 100% combined line and branch coverage, including the parser engine.
+The parser engine additionally requires exact agreement with the reference path across the html5lib tree suite.
+See [Correctness Testing](docs/correctness.md) for details.
 
 ## Documentation
 

justhtml-3.0.0/benchmarks/chromium_parser_diff.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""Compare JustHTML parse trees with headless Chromium.
+
+Run with an environment containing Playwright, for example:
+
+    PYENV_VERSION=justhtml-html5lib-tests-bench \
+      python benchmarks/chromium_parser_diff.py --generated 5000
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import inspect
+import json
+import random
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+_ROOT = Path(__file__).resolve().parents[1]
+for _path in (str(_ROOT), str(_ROOT / "src")):
+    if _path not in sys.path:
+        sys.path.insert(0, _path)
+
+from justhtml import JustHTML  # noqa: E402
+from justhtml.dom import Template  # noqa: E402
+
+_KNOWN_CHROMIUM_DIVERGENCES = frozenset(
+    {
+        "adoption01.dat:17",
+        "generated:4",
+        "generated:65",
+        "noscript01.dat:12",
+        "tests25.dat:7",
+        "tests_innerHTML_1.dat:75",
+        "webkit02.dat:11",
+        "webkit02.dat:15",
+        "webkit02.dat:16",
+        "webkit02.dat:17",
+        "generated:649",
+        "generated:705",
+    }
+)
+_NON_ATOMIC_FUZZ_STRATEGIES = frozenset({"fuzz_attribute", "fuzz_nested_structure", "fuzz_open_tag"})
+
+
+@dataclass(slots=True)
+class Case:
+    source: str
+    html: str
+    context_name: str | None = None
+    context_namespace: str | None = None
+    scripting_enabled: bool = True
+
+
+def _runner_config() -> dict[str, object]:
+    return {
+        "fail_fast": False,
+        "test_specs": [],
+        "quiet": True,
+        "write_summary": False,
+        "exclude_errors": None,
+        "exclude_files": None,
+        "exclude_html": None,
+        "filter_html": None,
+        "filter_errors": None,
+        "verbosity": 0,
+        "regressions": False,
+        "check_errors": False,
+        "suite": "tree",
+    }
+
+
+def _html5lib_cases(limit: int | None) -> list[Case]:
+    if limit == 0:
+        return []
+    tree_module = importlib.import_module("tests.harness.tree")
+    runner = tree_module.TestRunner(_ROOT / "tests/html5lib-tests-tree", _runner_config())
+    cases: list[Case] = []
+    for path, tests in runner.load_tests():
+        for index, test in enumerate(tests):
+            if test.script_directive == "script-on" or test.xml_coercion or test.iframe_srcdoc:
+                continue
+            context = test.fragment_context
+            cases.append(
+                Case(
+                    source=f"{path.name}:{index}",
+                    html=test.data,
+                    context_name=context.tag_name if context else None,
+                    context_namespace=context.namespace if context else None,
+                    scripting_enabled=test.script_directive != "script-off",
+                )
+            )
+            if limit is not None and len(cases) >= limit:
+                return cases
+    return cases
+
+
+def _generated_cases(count: int, seed: int) -> list[Case]:
+    fuzz = importlib.import_module("benchmarks.fuzz")
+    random.seed(seed)
+    return [
+        Case(source=f"generated:{index}", html=fuzz.generate_fuzzed_html(), scripting_enabled=False)
+        for index in range(count)
+    ]
+
+
+def _atomic_generated_cases(count_per_strategy: int, seed: int) -> list[Case]:
+    fuzz = importlib.import_module("benchmarks.fuzz")
+    random.seed(seed)
+    strategies = []
+    for name, value in vars(fuzz).items():
+        if not name.startswith("fuzz_") or name in _NON_ATOMIC_FUZZ_STRATEGIES or not callable(value):
+            continue
+        signature = inspect.signature(value)
+        if any(
+            parameter.default is inspect.Parameter.empty
+            and parameter.kind in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
+            for parameter in signature.parameters.values()
+        ):
+            continue
+        strategies.append((name, value))
+
+    cases = []
+    for name, strategy in sorted(strategies):
+        cases.extend(
+            [
+                Case(
+                    source=f"atomic:{name}:{index}",
+                    html=strategy(),
+                    scripting_enabled=False,
+                )
+                for index in range(count_per_strategy)
+            ]
+        )
+    return cases
+
+
+def _merge_adjacent_text(nodes: list[list[Any]]) -> list[list[Any]]:
+    merged: list[list[Any]] = []
+    for node in nodes:
+        if node[0] == "text" and merged and merged[-1][0] == "text":
+            merged[-1][1] += node[1]
+        else:
+            merged.append(node)
+    return merged
+
+
+def _canonical_node(node: Any) -> list[Any]:
+    name = node.name
+    if name == "#text":
+        return ["text", node.data or ""]
+    if name == "#comment":
+        return ["comment", node.data or ""]
+    if name == "!doctype":
+        doctype = node.data
+        return ["doctype", doctype.name or "", doctype.public_id or "", doctype.system_id or ""]
+
+    namespace = node.namespace or "html"
+    attrs = [[name, value or ""] for name, value in sorted((node.attrs or {}).items())]
+    children = _merge_adjacent_text([_canonical_node(child) for child in node.children or ()])
+    content = None
+    if type(node) is Template and node.template_content is not None:
+        content = _merge_adjacent_text([_canonical_node(child) for child in node.template_content.children])
+    return ["element", namespace, name, attrs, children, content]
+
+
+def _render_justhtml(case: Case) -> list[Any]:
+    context = None
+    if case.context_name is not None:
+        context_module = importlib.import_module("justhtml.parser.context")
+        context = context_module.FragmentContext(case.context_name, case.context_namespace)
+    document = JustHTML(
+        case.html,
+        fragment_context=context,
+        scripting_enabled=case.scripting_enabled,
+        sanitize=False,
+    )
+    return [_canonical_node(child) for child in document.root.children or ()]
+
+
+def _canonical_subtree_is_empty(node: list[Any]) -> bool:
+    if node[0] == "text":
+        return not node[1].strip()
+    if node[0] != "element":
+        return False
+    return all(_canonical_subtree_is_empty(child) for child in node[4])
+
+
+def _is_known_divergence(case: Case, actual: list[Any], expected: list[Any]) -> bool:
+    if case.source in _KNOWN_CHROMIUM_DIVERGENCES:
+        return True
+    if case.html.startswith("\ufeff"):
+        # DOMParser receives an already-decoded string and preserves this
+        # character. JustHTML applies its byte-stream-compatible BOM policy.
+        return True
+    if case.html in {"&#x;", "&#X;"}:
+        # The HTML Standard requires an absent-digit numeric reference to be
+        # flushed unchanged. Chromium currently emits U+FFFD for this input.
+        return True
+    if case.html == "	":
+        # Chromium DOMParser preserves this as a body text node even though the
+        # tree builder ignores the leading character before the html element.
+        return True
+    if case.html.startswith("<!D") and not case.html.lower().startswith("<!doctype"):
+        # Chromium drops an incomplete uppercase DOCTYPE prefix where the
+        # tokenizer rules instead produce a bogus comment.
+        return True
+    if "<frameset" in case.html.lower() and actual and expected:
+        actual_html = actual[-1]
+        expected_html = expected[-1]
+        if actual_html[:3] == ["element", "html", "html"] and expected_html[:3] == ["element", "html", "html"]:
+            actual_elements = [node for node in actual_html[4] if node[0] == "element"]
+            expected_elements = [node for node in expected_html[4] if node[0] == "element"]
+            if (
+                actual_elements
+                and expected_elements
+                and actual_elements[-1][2] == "body"
+                and expected_elements[-1][2] == "frameset"
+                and all(_canonical_subtree_is_empty(child) for child in actual_elements[-1][4])
+            ):
+                # Chromium still accepts a frameset after recursively empty
+                # unknown elements. The standard marks frameset-ok false.
+                return True
+    return case.source.startswith(("atomic:fuzz_scope_terminators:", "atomic:fuzz_formatting_boundary:")) and (
+        "<button><button>" in case.html
+    )
+
+
+_CHROMIUM_RENDER = r"""
+(cases) => {
+  const namespaceUri = {
+    html: "http://www.w3.org/1999/xhtml",
+    svg: "http://www.w3.org/2000/svg",
+    math: "http://www.w3.org/1998/Math/MathML",
+    mathml: "http://www.w3.org/1998/Math/MathML",
+  };
+  const namespaceName = (uri) => {
+    if (!uri || uri === namespaceUri.html) return "html";
+    if (uri === namespaceUri.svg) return "svg";
+    if (uri === namespaceUri.math) return "math";
+    return uri;
+  };
+  const canonical = (node) => {
+    if (node.nodeType === Node.TEXT_NODE) return ["text", node.data];
+    if (node.nodeType === Node.COMMENT_NODE) return ["comment", node.data];
+    if (node.nodeType === Node.DOCUMENT_TYPE_NODE) {
+      return ["doctype", node.name || "", node.publicId, node.systemId];
+    }
+    const attrs = Array.from(node.attributes || [], (attr) => [attr.name, attr.value])
+      .sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    const mergeAdjacentText = (nodes) => {
+      const merged = [];
+      for (const item of nodes) {
+        if (item[0] === "text" && merged.length && merged[merged.length - 1][0] === "text") {
+          merged[merged.length - 1][1] += item[1];
+        } else {
+          merged.push(item);
+        }
+      }
+      return merged;
+    };
+    const children = mergeAdjacentText(Array.from(node.childNodes, canonical));
+    const content = node.localName === "template" && node.namespaceURI === namespaceUri.html
+      ? mergeAdjacentText(Array.from(node.content.childNodes, canonical))
+      : null;
+    return ["element", namespaceName(node.namespaceURI), node.localName, attrs, children, content];
+  };
+  return cases.map((item) => {
+    let nodes;
+    if (item.context_name === null) {
+      const document = new DOMParser().parseFromString(item.html, "text/html");
+      nodes = Array.from(document.childNodes);
+    } else {
+      const owner = document.implementation.createHTMLDocument("");
+      const namespace = namespaceUri[item.context_namespace || "html"] || item.context_namespace;
+      const context = owner.createElementNS(namespace, item.context_name);
+      context.innerHTML = item.html;
+      nodes = item.context_name.toLowerCase() === "template" && namespace === namespaceUri.html
+        ? Array.from(context.content.childNodes)
+        : Array.from(context.childNodes);
+    }
+    return nodes.map(canonical);
+  });
+}
+"""
+
+
+def _render_chromium(cases: list[Case], executable: str, chunk_size: int) -> list[list[Any]]:
+    try:
+        from playwright.sync_api import sync_playwright  # noqa: PLC0415
+    except ImportError as exc:  # pragma: no cover - depends on benchmark environment
+        raise SystemExit("Playwright is required for the Chromium differential") from exc
+
+    output: list[list[Any]] = []
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(executable_path=executable, headless=True)
+        page = browser.new_page()
+        for start in range(0, len(cases), chunk_size):
+            payload = [
+                {
+                    "html": case.html,
+                    "context_name": case.context_name,
+                    "context_namespace": case.context_namespace,
+                }
+                for case in cases[start : start + chunk_size]
+            ]
+            rendered = page.evaluate(f"(cases) => JSON.stringify(({_CHROMIUM_RENDER})(cases))", payload)
+            output.extend(json.loads(rendered))
+        browser.close()
+    return output
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--chrome", default="/usr/bin/google-chrome")
+    parser.add_argument("--html5lib-limit", type=int)
+    parser.add_argument("--generated", type=int, default=0)
+    parser.add_argument("--atomic-generated", type=int, default=0, help="Cases per individual fuzz strategy")
+    parser.add_argument("--seed", type=int, default=20260621)
+    parser.add_argument("--chunk-size", type=int, default=250)
+    parser.add_argument("--examples", type=int, default=20)
+    parser.add_argument("--json-output", type=Path)
+    args = parser.parse_args()
+
+    cases = _html5lib_cases(args.html5lib_limit)
+    cases.extend(_generated_cases(args.generated, args.seed))
+    cases.extend(_atomic_generated_cases(args.atomic_generated, args.seed))
+    chromium = _render_chromium(cases, args.chrome, args.chunk_size)
+
+    mismatches: list[dict[str, Any]] = []
+    known_divergences: list[dict[str, Any]] = []
+    exceptions: list[dict[str, str]] = []
+    for case, expected in zip(cases, chromium, strict=True):
+        try:
+            actual = _render_justhtml(case)
+        except Exception as exc:  # noqa: BLE001 - differential must continue
+            exceptions.append({"source": case.source, "html": case.html, "exception": f"{type(exc).__name__}: {exc}"})
+            continue
+        if actual != expected:
+            mismatch = {
+                "source": case.source,
+                "html": case.html,
+                "context_name": case.context_name,
+                "context_namespace": case.context_namespace,
+                "justhtml": actual,
+                "chromium": expected,
+            }
+            (known_divergences if _is_known_divergence(case, actual, expected) else mismatches).append(mismatch)
+
+    print(f"chromium: {args.chrome}")
+    print(f"cases: {len(cases)}")
+    print(f"exact: {len(cases) - len(mismatches) - len(known_divergences) - len(exceptions)}")
+    print(f"known_chromium_divergences: {len(known_divergences)}")
+    print(f"mismatches: {len(mismatches)}")
+    print(f"exceptions: {len(exceptions)}")
+    for mismatch in mismatches[: args.examples]:
+        print(f"\n{mismatch['source']}: {mismatch['html']!r}")
+        print(f"  justhtml: {json.dumps(mismatch['justhtml'], ensure_ascii=False)}")
+        print(f"  chromium: {json.dumps(mismatch['chromium'], ensure_ascii=False)}")
+    for exception in exceptions[: args.examples]:
+        print(f"\n{exception['source']}: {exception['html']!r}")
+        print(f"  exception: {exception['exception']}")
+
+    if args.json_output is not None:
+        args.json_output.write_text(
+            json.dumps(
+                {
+                    "known_chromium_divergences": known_divergences,
+                    "mismatches": mismatches,
+                    "exceptions": exceptions,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+    return int(bool(mismatches or exceptions))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{justhtml-2.4.0 → justhtml-3.0.0}/benchmarks/correctness.py

@@ -230,22 +230,22 @@ def compare_outputs(expected, actual):
 
 def run_test_justhtml(html, fragment_context, expected, xml_coercion=False, iframe_srcdoc=False):
     """Run a single test with JustHTML."""
-    from justhtml.tokenizer import TokenizerOpts
+    from justhtml.parser.options import ParserOptions
 
     try:
-        opts = TokenizerOpts(xml_coercion=xml_coercion)
+        opts = ParserOptions(xml_coercion=xml_coercion)
         if fragment_context:
             namespace, tag_name = fragment_context
             ctx = FragmentContext(tag_name, namespace)
             parser = JustHTML(
                 html,
                 fragment_context=ctx,
-                _tokenizer_opts=opts,
+                _parser_opts=opts,
                 iframe_srcdoc=iframe_srcdoc,
                 sanitize=False,
             )
         else:
-            parser = JustHTML(html, _tokenizer_opts=opts, iframe_srcdoc=iframe_srcdoc, sanitize=False)
+            parser = JustHTML(html, _parser_opts=opts, iframe_srcdoc=iframe_srcdoc, sanitize=False)
         actual = to_test_format(parser.root)
         return _compare_result(expected, actual)
     except Exception as e: